diff --git a/maven-release-api/pom.xml b/maven-release-api/pom.xml index e96feff3e..03985e6e7 100644 --- a/maven-release-api/pom.xml +++ b/maven-release-api/pom.xml @@ -40,6 +40,18 @@ org.apache.maven maven-artifact + + org.apache.maven + maven-core + + + org.apache.maven + maven-model + + + org.apache.maven + maven-settings + org.eclipse.aether aether-util diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java similarity index 100% rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java rename to maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseExecutionException.java diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java similarity index 100% rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java rename to maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseFailureException.java diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseResult.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseResult.java similarity index 96% rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseResult.java rename to maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseResult.java index 088e82059..04547ed3a 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseResult.java +++ b/maven-release-api/src/main/java/org/apache/maven/shared/release/ReleaseResult.java @@ -132,10 +132,4 @@ private String getStackTrace( Exception e ) return byteStream.toString(); } - - @Deprecated - public StringBuffer getOutputBuffer() - { - return new StringBuffer( stdOut ); - } } diff --git a/maven-release-api/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptor.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptor.java new file mode 100644 index 000000000..d9aa16aad --- /dev/null +++ b/maven-release-api/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptor.java @@ -0,0 +1,158 @@ +package org.apache.maven.shared.release.config; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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. + */ + +import java.util.List; + +import org.apache.maven.model.Scm; + +/** + * + * @author Robert Scholte + */ +public interface ReleaseDescriptor +{ + boolean isUpdateDependencies(); + + boolean isUseReleaseProfile(); + + boolean isAutoVersionSubmodules(); + + boolean isSnapshotReleasePluginAllowed(); + + boolean isCommitByProject(); + + boolean isBranchCreation(); + + boolean isUpdateBranchVersions(); + + boolean isUpdateWorkingCopyVersions(); + + boolean isSuppressCommitBeforeTagOrBranch(); + + boolean isAllowTimestampedSnapshots(); + + boolean isUpdateVersionsToSnapshot(); + + boolean isRemoteTagging(); + + boolean isLocalCheckout(); + + boolean isPushChanges(); + + String getDefaultDevelopmentVersion(); + + String getScmRelativePathProjectDirectory(); + + String getCheckoutDirectory(); + + String getPerformGoals(); + + String getDefaultReleaseVersion(); + + String getScmReleasedPomRevision(); + + boolean isAddSchema(); + + boolean isGenerateReleasePoms(); + + boolean isInteractive(); + + boolean isScmUseEditMode(); + + String getCompletedPhase(); + + List getCheckModificationExcludes(); + + String getAdditionalArguments(); + + String getPreparationGoals(); + + String getCompletionGoals(); + + String getPomFileName(); + + String getScmCommentPrefix(); + + String getScmPrivateKeyPassPhrase(); + + String getScmPassword(); + + String getScmPrivateKey(); + + String getScmReleaseLabel(); + + String getScmTagBase(); + + String getScmBranchBase(); + + String getScmId(); + + String getScmSourceUrl(); + + String getScmUsername(); + + int getWaitBeforeTagging(); + + String getWorkingDirectory(); + + String getScmTagNameFormat(); + + String getProjectNamingPolicyId(); + + String getProjectVersionPolicyId(); + + String getReleaseStrategyId(); + + String getDependencyOriginalVersion( String artifactKey ); + + String getDependencyReleaseVersion( String artifactKey ); + + String getDependencyDevelopmentVersion( String artifactKey ); + + String getProjectOriginalVersion( String projectKey ); + + String getProjectDevelopmentVersion( String projectKey ); + + String getProjectReleaseVersion( String key ); + + Scm getOriginalScmInfo( String projectKey ); + + // Modifiable + void addDependencyOriginalVersion( String versionlessKey, String string ); + + void addDependencyReleaseVersion( String versionlessKey, String version ); + + void addDependencyDevelopmentVersion( String versionlessKey, String version ); + + void addReleaseVersion( String projectId, String nextVersion ); + + void addDevelopmentVersion( String projectId, String nextVersion ); + + void setScmReleaseLabel( String tag ); + + void setScmReleasedPomRevision( String scmRevision ); + + void setScmRelativePathProjectDirectory( String scmRelativePathProjectDirectory ); + + void setScmSourceUrl( String scmUrl ); + + +} diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java similarity index 73% rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java rename to maven-release-api/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java index dbbf86c9b..88ef9e20c 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java +++ b/maven-release-api/src/main/java/org/apache/maven/shared/release/env/ReleaseEnvironment.java @@ -34,36 +34,18 @@ public interface ReleaseEnvironment String getMavenExecutorId(); - ReleaseEnvironment setMavenExecutorId( String mavenExecutorId ); - File getLocalRepositoryDirectory(); - ReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory ); - Settings getSettings(); - ReleaseEnvironment setSettings( Settings settings ); - File getMavenHome(); - ReleaseEnvironment setMavenHome( File mavenHome ); - File getJavaHome(); - ReleaseEnvironment setJavaHome( File javaHome ); - /** * * @return the locale * @since 2.4 */ Locale getLocale(); - - /** - * @param locale - * @return the locale - * @since 2.4 - */ - ReleaseEnvironment setLocale( Locale locale ); - } diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java b/maven-release-api/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java similarity index 100% rename from maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java rename to maven-release-api/src/main/java/org/apache/maven/shared/release/phase/ReleasePhase.java diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java index 8e7070e0e..470c6c24a 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/AbstractReleaseRequest.java @@ -22,7 +22,7 @@ import java.util.List; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; /** * @@ -31,7 +31,7 @@ */ public abstract class AbstractReleaseRequest { - private ReleaseDescriptor releaseDescriptor; + private ReleaseDescriptorBuilder releaseDescriptorBuilder; private List reactorProjects; @@ -40,17 +40,17 @@ public abstract class AbstractReleaseRequest /** * @return the releaseDescriptor */ - public ReleaseDescriptor getReleaseDescriptor() + public ReleaseDescriptorBuilder getReleaseDescriptorBuilder() { - return releaseDescriptor; + return releaseDescriptorBuilder; } /** * @param releaseDescriptor the releaseDescriptor to set */ - public void setReleaseDescriptor( ReleaseDescriptor releaseDescriptor ) + public void setReleaseDescriptorBuilder( ReleaseDescriptorBuilder releaseDescriptor ) { - this.releaseDescriptor = releaseDescriptor; + this.releaseDescriptorBuilder = releaseDescriptor; } /** diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java index ad93daae0..1cbcb8939 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/DefaultReleaseManager.java @@ -28,8 +28,11 @@ import org.apache.commons.lang3.BooleanUtils; import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor; import org.apache.maven.shared.release.config.ReleaseDescriptorStore; import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.phase.ReleasePhase; import org.apache.maven.shared.release.strategy.Strategy; import org.codehaus.plexus.component.annotations.Component; @@ -99,15 +102,36 @@ public void prepare( ReleasePrepareRequest prepareRequest ) private void prepare( ReleasePrepareRequest prepareRequest, ReleaseResult result ) throws ReleaseExecutionException, ReleaseFailureException { - ReleaseDescriptor config; + + final ReleaseDescriptorBuilder builder = prepareRequest.getReleaseDescriptorBuilder(); + + // Create a config containing values from the session properties (ie command line properties with cli). + ReleaseUtils.copyPropertiesToReleaseDescriptor( prepareRequest.getUserProperties(), + new ReleaseDescriptorBuilder() + { + public ReleaseDescriptorBuilder addDevelopmentVersion( String key, + String value ) + { + builder.addDevelopmentVersion( key, value ); + return this; + } + + public ReleaseDescriptorBuilder addReleaseVersion( String key, + String value ) + { + builder.addReleaseVersion( key, value ); + return this; + }; + } ); + + BuilderReleaseDescriptor config; if ( BooleanUtils.isNotFalse( prepareRequest.getResume() ) ) { - config = loadReleaseDescriptor( prepareRequest.getReleaseDescriptor(), - prepareRequest.getReleaseManagerListener() ); + config = loadReleaseDescriptor( builder, prepareRequest.getReleaseManagerListener() ); } else { - config = prepareRequest.getReleaseDescriptor(); + config = ReleaseUtils.buildReleaseDescriptor( prepareRequest.getReleaseDescriptorBuilder() ); } Strategy releaseStrategy = getStrategy( config.getReleaseStrategyId() ); @@ -196,7 +220,8 @@ else if ( index >= 0 ) public void rollback( ReleaseRollbackRequest rollbackRequest ) throws ReleaseExecutionException, ReleaseFailureException { - ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( rollbackRequest.getReleaseDescriptor(), null ); + ReleaseDescriptor releaseDescriptor = + loadReleaseDescriptor( rollbackRequest.getReleaseDescriptorBuilder(), null ); Strategy releaseStrategy = getStrategy( releaseDescriptor.getReleaseStrategyId() ); @@ -260,8 +285,9 @@ public void perform( ReleasePerformRequest performRequest ) private void perform( ReleasePerformRequest performRequest, ReleaseResult result ) throws ReleaseExecutionException, ReleaseFailureException { - ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( performRequest.getReleaseDescriptor(), - performRequest.getReleaseManagerListener() ); + ReleaseDescriptor releaseDescriptor = + loadReleaseDescriptor( performRequest.getReleaseDescriptorBuilder(), + performRequest.getReleaseManagerListener() ); Strategy releaseStrategy = getStrategy( releaseDescriptor.getReleaseStrategyId() ); @@ -320,8 +346,28 @@ private void perform( ReleasePerformRequest performRequest, ReleaseResult result public void branch( ReleaseBranchRequest branchRequest ) throws ReleaseExecutionException, ReleaseFailureException { - ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( branchRequest.getReleaseDescriptor(), - branchRequest.getReleaseManagerListener() ); + final ReleaseDescriptorBuilder builder = branchRequest.getReleaseDescriptorBuilder(); + + ReleaseUtils.copyPropertiesToReleaseDescriptor( branchRequest.getUserProperties(), + new ReleaseDescriptorBuilder() + { + public ReleaseDescriptorBuilder addDevelopmentVersion( String key, + String value ) + { + builder.addDevelopmentVersion( key, value ); + return this; + } + + public ReleaseDescriptorBuilder addReleaseVersion( String key, + String value ) + { + builder.addReleaseVersion( key, value ); + return this; + }; + } ); + + ReleaseDescriptor releaseDescriptor = + loadReleaseDescriptor( builder, branchRequest.getReleaseManagerListener() ); boolean dryRun = BooleanUtils.isTrue( branchRequest.getDryRun() ); @@ -369,8 +415,29 @@ public void branch( ReleaseBranchRequest branchRequest ) public void updateVersions( ReleaseUpdateVersionsRequest updateVersionsRequest ) throws ReleaseExecutionException, ReleaseFailureException { - ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( updateVersionsRequest.getReleaseDescriptor(), - updateVersionsRequest.getReleaseManagerListener() ); + final ReleaseDescriptorBuilder builder = updateVersionsRequest.getReleaseDescriptorBuilder(); + + // Create a config containing values from the session properties (ie command line properties with cli). + ReleaseUtils.copyPropertiesToReleaseDescriptor( updateVersionsRequest.getUserProperties(), + new ReleaseDescriptorBuilder() + { + public ReleaseDescriptorBuilder addDevelopmentVersion( String key, + String value ) + { + builder.addDevelopmentVersion( key, value ); + return this; + } + + public ReleaseDescriptorBuilder addReleaseVersion( String key, + String value ) + { + builder.addReleaseVersion( key, value ); + return this; + }; + } ); + + ReleaseDescriptor releaseDescriptor = + loadReleaseDescriptor( builder, updateVersionsRequest.getReleaseManagerListener() ); Strategy releaseStrategy = getStrategy( releaseDescriptor.getReleaseStrategyId() ); @@ -421,14 +488,14 @@ protected File determineWorkingDirectory( File checkoutDirectory, String relativ } } - private ReleaseDescriptor loadReleaseDescriptor( ReleaseDescriptor releaseDescriptor, + private BuilderReleaseDescriptor loadReleaseDescriptor( ReleaseDescriptorBuilder builder, ReleaseManagerListener listener ) throws ReleaseExecutionException { try { updateListener( listener, "verify-release-configuration", PHASE_START ); - ReleaseDescriptor descriptor = configStore.read( releaseDescriptor ); + BuilderReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( configStore.read( builder ) ); updateListener( listener, "verify-release-configuration", PHASE_END ); return descriptor; } @@ -444,7 +511,7 @@ private ReleaseDescriptor loadReleaseDescriptor( ReleaseDescriptor releaseDescri protected void clean( AbstractReleaseRequest releaseRequest ) throws ReleaseFailureException { ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest(); - cleanRequest.setReleaseDescriptor( releaseRequest.getReleaseDescriptor() ); + cleanRequest.setReleaseDescriptorBuilder( releaseRequest.getReleaseDescriptorBuilder() ); cleanRequest.setReleaseManagerListener( releaseRequest.getReleaseManagerListener() ); cleanRequest.setReactorProjects( releaseRequest.getReactorProjects() ); @@ -458,7 +525,8 @@ public void clean( ReleaseCleanRequest cleanRequest ) throws ReleaseFailureExcep getLogger().info( "Cleaning up after release..." ); - ReleaseDescriptor releaseDescriptor = cleanRequest.getReleaseDescriptor(); + ReleaseDescriptor releaseDescriptor = + ReleaseUtils.buildReleaseDescriptor( cleanRequest.getReleaseDescriptorBuilder() ); configStore.delete( releaseDescriptor ); diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java index 9900a17e1..45b69c85e 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseBranchRequest.java @@ -19,6 +19,7 @@ * under the License. */ +import java.util.Properties; import org.apache.maven.shared.release.env.ReleaseEnvironment; /** @@ -32,6 +33,8 @@ public class ReleaseBranchRequest extends AbstractReleaseRequest private Boolean dryRun; private ReleaseEnvironment releaseEnvironment; + + private Properties userProperties; /** * @return the dryRun @@ -64,4 +67,14 @@ public void setReleaseEnvironment( ReleaseEnvironment releaseEnvironment ) { this.releaseEnvironment = releaseEnvironment; } + + public Properties getUserProperties() + { + return userProperties; + } + + public void setUserProperties( Properties userProperties ) + { + this.userProperties = userProperties; + } } \ No newline at end of file diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java index 1ab4a2bbf..7ac691559 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleasePrepareRequest.java @@ -19,6 +19,8 @@ * under the License. */ +import java.util.Properties; + import org.apache.maven.shared.release.env.ReleaseEnvironment; /** @@ -36,6 +38,8 @@ public class ReleasePrepareRequest private Boolean resume; private ReleaseEnvironment releaseEnvironment; + + private Properties userProperties; /** * @return the dryRun @@ -84,4 +88,14 @@ public void setReleaseEnvironment( ReleaseEnvironment releaseEnvironment ) { this.releaseEnvironment = releaseEnvironment; } + + public Properties getUserProperties() + { + return userProperties; + } + + public void setUserProperties( Properties userProperties ) + { + this.userProperties = userProperties; + } } \ No newline at end of file diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java index ba87ad068..81c768c35 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/ReleaseUpdateVersionsRequest.java @@ -19,6 +19,8 @@ * under the License. */ +import java.util.Properties; + import org.apache.maven.shared.release.env.ReleaseEnvironment; /** @@ -30,6 +32,8 @@ public class ReleaseUpdateVersionsRequest extends AbstractReleaseRequest { private ReleaseEnvironment releaseEnvironment; + + private Properties userProperties; /** * @return the releaseEnvironment @@ -46,4 +50,14 @@ public void setReleaseEnvironment( ReleaseEnvironment releaseEnvironment ) { this.releaseEnvironment = releaseEnvironment; } + + public Properties getUserProperties() + { + return userProperties; + } + + public void setUserProperties( Properties userProperties ) + { + this.userProperties = userProperties; + } } \ No newline at end of file diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java index 7256ce3be..259d9a373 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStore.java @@ -30,6 +30,7 @@ import java.util.Properties; import org.apache.maven.model.Scm; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor; import org.apache.maven.shared.release.scm.IdentifiedScm; import org.codehaus.plexus.component.annotations.Component; import org.codehaus.plexus.component.annotations.Requirement; @@ -61,19 +62,19 @@ public class PropertiesReleaseDescriptorStore private DefaultSecDispatcher secDispatcher; @Override - public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor ) + public ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor ) throws ReleaseDescriptorStoreException { - return read( mergeDescriptor, getDefaultReleasePropertiesFile( mergeDescriptor ) ); + return read( mergeDescriptor, getDefaultReleasePropertiesFile( mergeDescriptor.build() ) ); } - public ReleaseDescriptor read( File file ) + public ReleaseDescriptorBuilder read( File file ) throws ReleaseDescriptorStoreException { return read( null, file ); } - public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor, File file ) + public ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor, File file ) throws ReleaseDescriptorStoreException { Properties properties = new Properties(); @@ -92,21 +93,26 @@ public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor, File file ) "Error reading properties file '" + file.getName() + "': " + e.getMessage(), e ); } - ReleaseDescriptor releaseDescriptor = ReleaseUtils.copyPropertiesToReleaseDescriptor( properties ); - + ReleaseDescriptorBuilder builder; if ( mergeDescriptor != null ) { - releaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor ); + builder = mergeDescriptor; + } + else + { + builder = new ReleaseDescriptorBuilder(); } + + ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder ); - return releaseDescriptor; + return builder; } @Override public void write( ReleaseDescriptor config ) throws ReleaseDescriptorStoreException { - write( config, getDefaultReleasePropertiesFile( config ) ); + write( (BuilderReleaseDescriptor) config, getDefaultReleasePropertiesFile( config ) ); } @Override @@ -119,7 +125,7 @@ public void delete( ReleaseDescriptor config ) } } - public void write( ReleaseDescriptor config, File file ) + public void write( BuilderReleaseDescriptor config, File file ) throws ReleaseDescriptorStoreException { Properties properties = new Properties(); @@ -226,14 +232,17 @@ public void write( ReleaseDescriptor config, File file ) // others boolean properties are not written to the properties file because the value from the caller is always // used - for ( Map.Entry entry : config.getReleaseVersions().entrySet() ) - { - properties.setProperty( "project.rel." + entry.getKey(), entry.getValue() ); - } - - for ( Map.Entry entry : config.getDevelopmentVersions().entrySet() ) + + for ( Map.Entry entry : config.getProjectVersions().entrySet() ) { - properties.setProperty( "project.dev." + entry.getKey(), (String) entry.getValue() ); + if ( entry.getValue().getRelease() != null ) + { + properties.setProperty( "project.rel." + entry.getKey(), entry.getValue().getRelease() ); + } + if ( entry.getValue().getDevelopment() != null ) + { + properties.setProperty( "project.dev." + entry.getKey(), entry.getValue().getDevelopment() ); + } } for ( Map.Entry entry : config.getOriginalScmInfo().entrySet() ) @@ -290,16 +299,16 @@ public void write( ReleaseDescriptor config, File file ) } } - private void processResolvedDependencies( Properties prop, Map> resolvedDependencies ) + private void processResolvedDependencies( Properties prop, Map resolvedDependencies ) { - for ( Map.Entry> currentEntry : resolvedDependencies.entrySet() ) + for ( Map.Entry currentEntry : resolvedDependencies.entrySet() ) { - Map versionMap = currentEntry.getValue(); + ReleaseStageVersions versionMap = currentEntry.getValue(); prop.setProperty( "dependency." + currentEntry.getKey() + ".release", - versionMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + versionMap.getRelease() ); prop.setProperty( "dependency." + currentEntry.getKey() + ".development", - versionMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); + versionMap.getDevelopment() ); } } diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorBuilder.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorBuilder.java new file mode 100644 index 000000000..c2ed277a1 --- /dev/null +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorBuilder.java @@ -0,0 +1,399 @@ +package org.apache.maven.shared.release.config; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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. + */ + +import java.util.List; + +import org.apache.maven.model.Scm; + +/** + * + * @author Robert Scholte + * @since 3.0.0 + */ +public class ReleaseDescriptorBuilder +{ + /** + * Hides inner logic of the release descriptor + * + * @author Robert Scholte + * + */ + public static final class BuilderReleaseDescriptor extends ModelloReleaseDescriptor implements ReleaseDescriptor + { + private BuilderReleaseDescriptor() + { + } + } + + private final BuilderReleaseDescriptor releaseDescriptor; + + public ReleaseDescriptorBuilder() + { + this.releaseDescriptor = new BuilderReleaseDescriptor(); + } + + public ReleaseDescriptorBuilder addCheckModificationExclude( String string ) + { + releaseDescriptor.addCheckModificationExclude( string ); + return this; + } + + public ReleaseDescriptorBuilder setAddSchema( boolean addSchema ) + { + releaseDescriptor.setAddSchema( addSchema ); + return this; + } + + public ReleaseDescriptorBuilder setAdditionalArguments( String additionalArguments ) + { + releaseDescriptor.setAdditionalArguments( additionalArguments ); + return this; + } + + public ReleaseDescriptorBuilder setAllowTimestampedSnapshots( boolean allowTimestampedSnapshots ) + { + releaseDescriptor.setAllowTimestampedSnapshots( allowTimestampedSnapshots ); + return this; + } + + public ReleaseDescriptorBuilder setAutoVersionSubmodules( boolean autoVersionSubmodules ) + { + releaseDescriptor.setAutoVersionSubmodules( autoVersionSubmodules ); + return this; + } + + public ReleaseDescriptorBuilder setBranchCreation( boolean branchCreation ) + { + releaseDescriptor.setBranchCreation( branchCreation ); + return this; + } + + public ReleaseDescriptorBuilder setCheckModificationExcludes( List checkModificationExcludes ) + { + releaseDescriptor.setCheckModificationExcludes( checkModificationExcludes ); + return this; + } + + public ReleaseDescriptorBuilder setCheckoutDirectory( String checkoutDirectory ) + { + releaseDescriptor.setCheckoutDirectory( checkoutDirectory ); + return this; + } + + public ReleaseDescriptorBuilder setCommitByProject( boolean commitByProject ) + { + releaseDescriptor.setCommitByProject( commitByProject ); + return this; + } + + public ReleaseDescriptorBuilder setCompletedPhase( String completedPhase ) + { + releaseDescriptor.setCompletedPhase( completedPhase ); + return this; + } + + public ReleaseDescriptorBuilder setCompletionGoals( String completionGoals ) + { + releaseDescriptor.setCompletionGoals( completionGoals ); + return this; + } + + public ReleaseDescriptorBuilder setDefaultDevelopmentVersion( String defaultDevelopmentVersion ) + { + releaseDescriptor.setDefaultDevelopmentVersion( defaultDevelopmentVersion ); + return this; + } + + public ReleaseDescriptorBuilder setDefaultReleaseVersion( String defaultReleaseVersion ) + { + releaseDescriptor.setDefaultReleaseVersion( defaultReleaseVersion ); + return this; + } + + public ReleaseDescriptorBuilder setDescription( String description ) + { + releaseDescriptor.setDescription( description ); + return this; + } + + public ReleaseDescriptorBuilder setGenerateReleasePoms( boolean generateReleasePoms ) + { + releaseDescriptor.setGenerateReleasePoms( generateReleasePoms ); + return this; + } + + public ReleaseDescriptorBuilder setInteractive( boolean interactive ) + { + releaseDescriptor.setInteractive( interactive ); + return this; + } + + public ReleaseDescriptorBuilder setLocalCheckout( boolean localCheckout ) + { + releaseDescriptor.setLocalCheckout( localCheckout ); + return this; + } + + public ReleaseDescriptorBuilder setModelEncoding( String modelEncoding ) + { + releaseDescriptor.setModelEncoding( modelEncoding ); + return this; + } + + public ReleaseDescriptorBuilder setName( String name ) + { + releaseDescriptor.setName( name ); + return this; + } + + public ReleaseDescriptorBuilder setPerformGoals( String performGoals ) + { + releaseDescriptor.setPerformGoals( performGoals ); + return this; + } + + public ReleaseDescriptorBuilder setPomFileName( String pomFileName ) + { + releaseDescriptor.setPomFileName( pomFileName ); + return this; + } + + public ReleaseDescriptorBuilder setPreparationGoals( String preparationGoals ) + { + releaseDescriptor.setPreparationGoals( preparationGoals ); + return this; + } + + public ReleaseDescriptorBuilder setProjectNamingPolicyId( String projectNamingPolicyId ) + { + releaseDescriptor.setProjectNamingPolicyId( projectNamingPolicyId ); + return this; + } + + public ReleaseDescriptorBuilder setProjectVersionPolicyId( String projectVersionPolicyId ) + { + releaseDescriptor.setProjectVersionPolicyId( projectVersionPolicyId ); + return this; + } + + public ReleaseDescriptorBuilder setPushChanges( boolean pushChanges ) + { + releaseDescriptor.setPushChanges( pushChanges ); + return this; + } + + public ReleaseDescriptorBuilder setReleaseStrategyId( String releaseStrategyId ) + { + releaseDescriptor.setReleaseStrategyId( releaseStrategyId ); + return this; + } + + public ReleaseDescriptorBuilder setRemoteTagging( boolean remoteTagging ) + { + releaseDescriptor.setRemoteTagging( remoteTagging ); + return this; + } + + public ReleaseDescriptorBuilder setScmBranchBase( String scmBranchBase ) + { + releaseDescriptor.setScmBranchBase( scmBranchBase ); + return this; + } + + public ReleaseDescriptorBuilder setScmCommentPrefix( String scmCommentPrefix ) + { + releaseDescriptor.setScmCommentPrefix( scmCommentPrefix ); + return this; + } + + public ReleaseDescriptorBuilder setScmId( String scmId ) + { + releaseDescriptor.setScmId( scmId ); + return this; + } + + public ReleaseDescriptorBuilder setScmPassword( String scmPassword ) + { + releaseDescriptor.setScmPassword( scmPassword ); + return this; + } + + public ReleaseDescriptorBuilder setScmPrivateKey( String scmPrivateKey ) + { + releaseDescriptor.setScmPrivateKey( scmPrivateKey ); + return this; + } + + public ReleaseDescriptorBuilder setScmPrivateKeyPassPhrase( String scmPrivateKeyPassPhrase ) + { + releaseDescriptor.setScmPrivateKeyPassPhrase( scmPrivateKeyPassPhrase ); + return this; + } + + public ReleaseDescriptorBuilder setScmRelativePathProjectDirectory( String scmRelativePathProjectDirectory ) + { + releaseDescriptor.setScmRelativePathProjectDirectory( scmRelativePathProjectDirectory ); + return this; + } + + public ReleaseDescriptorBuilder setScmReleaseLabel( String scmReleaseLabel ) + { + releaseDescriptor.setScmReleaseLabel( scmReleaseLabel ); + return this; + } + + public ReleaseDescriptorBuilder setScmReleasedPomRevision( String scmReleasedPomRevision ) + { + releaseDescriptor.setScmReleasedPomRevision( scmReleasedPomRevision ); + return this; + } + + public ReleaseDescriptorBuilder setScmSourceUrl( String scmSourceUrl ) + { + releaseDescriptor.setScmSourceUrl( scmSourceUrl ); + return this; + } + + public ReleaseDescriptorBuilder setScmTagBase( String scmTagBase ) + { + releaseDescriptor.setScmTagBase( scmTagBase ); + return this; + } + + public ReleaseDescriptorBuilder setScmTagNameFormat( String scmTagNameFormat ) + { + releaseDescriptor.setScmTagNameFormat( scmTagNameFormat ); + return this; + } + + public ReleaseDescriptorBuilder setScmUseEditMode( boolean scmUseEditMode ) + { + releaseDescriptor.setScmUseEditMode( scmUseEditMode ); + return this; + } + + public ReleaseDescriptorBuilder setScmUsername( String scmUsername ) + { + releaseDescriptor.setScmUsername( scmUsername ); + return this; + } + + public ReleaseDescriptorBuilder setSnapshotReleasePluginAllowed( boolean snapshotReleasePluginAllowed ) + { + releaseDescriptor.setSnapshotReleasePluginAllowed( snapshotReleasePluginAllowed ); + return this; + } + + public ReleaseDescriptorBuilder setSuppressCommitBeforeTagOrBranch( boolean suppressCommitBeforeTagOrBranch ) + { + releaseDescriptor.setSuppressCommitBeforeTagOrBranch( suppressCommitBeforeTagOrBranch ); + return this; + } + + public ReleaseDescriptorBuilder setUpdateBranchVersions( boolean updateBranchVersions ) + { + releaseDescriptor.setUpdateBranchVersions( updateBranchVersions ); + return this; + } + + public ReleaseDescriptorBuilder setUpdateDependencies( boolean updateDependencies ) + { + releaseDescriptor.setUpdateDependencies( updateDependencies ); + return this; + } + + public ReleaseDescriptorBuilder setUpdateVersionsToSnapshot( boolean updateVersionsToSnapshot ) + { + releaseDescriptor.setUpdateVersionsToSnapshot( updateVersionsToSnapshot ); + return this; + } + + public ReleaseDescriptorBuilder setUpdateWorkingCopyVersions( boolean updateWorkingCopyVersions ) + { + releaseDescriptor.setUpdateWorkingCopyVersions( updateWorkingCopyVersions ); + return this; + } + + public ReleaseDescriptorBuilder setUseReleaseProfile( boolean useReleaseProfile ) + { + releaseDescriptor.setUseReleaseProfile( useReleaseProfile ); + return this; + } + + public ReleaseDescriptorBuilder setWaitBeforeTagging( int waitBeforeTagging ) + { + releaseDescriptor.setWaitBeforeTagging( waitBeforeTagging ); + return this; + } + + public ReleaseDescriptorBuilder setWorkingDirectory( String workingDirectory ) + { + releaseDescriptor.setWorkingDirectory( workingDirectory ); + return this; + } + + public ReleaseDescriptorBuilder addReleaseVersion( String key, String value ) + { + releaseDescriptor.addReleaseVersion( key, value ); + return this; + } + + public ReleaseDescriptorBuilder addDevelopmentVersion( String key, String value ) + { + releaseDescriptor.addDevelopmentVersion( key, value ); + return this; + } + + public ReleaseDescriptorBuilder addOriginalScmInfo( String key, Scm value ) + { + releaseDescriptor.addOriginalScmInfo( key, value ); + return this; + } + + public void putOriginalVersion( String projectKey, String version ) + { + releaseDescriptor.addOriginalVersion( projectKey, version ); + } + + public ReleaseDescriptorBuilder addDependencyOriginalVersion( String dependencyKey, String version ) + { + releaseDescriptor.addDependencyOriginalVersion( dependencyKey, version ); + return this; + + } + + public ReleaseDescriptorBuilder addDependencyReleaseVersion( String dependencyKey, String version ) + { + releaseDescriptor.addDependencyReleaseVersion( dependencyKey, version ); + return this; + } + + public ReleaseDescriptorBuilder addDependencyDevelopmentVersion( String dependencyKey, String version ) + { + releaseDescriptor.addDependencyDevelopmentVersion( dependencyKey, version ); + return this; + } + + BuilderReleaseDescriptor build() + { + return releaseDescriptor; + } +} diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java index 5b1e8c45e..69092c174 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseDescriptorStore.java @@ -33,7 +33,7 @@ public interface ReleaseDescriptorStore * while others are used to override * @return the configuration */ - ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor ) + ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor ) throws ReleaseDescriptorStoreException; /** diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java index 743b062e8..36504c2e3 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/config/ReleaseUtils.java @@ -19,13 +19,12 @@ * under the License. */ -import java.util.HashMap; import java.util.Iterator; -import java.util.Map; import java.util.Map.Entry; import java.util.Properties; import java.util.Set; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor; import org.apache.maven.shared.release.scm.IdentifiedScm; /** @@ -35,152 +34,119 @@ */ public class ReleaseUtils { + private static final String DEVELOPMENT_KEY = "dev"; + + private static final String RELEASE_KEY = "rel"; + private ReleaseUtils() { // nothing to see here } - /** - * Merge two descriptors together. All SCM settings are overridden by the merge descriptor, as is the - * workingDirectory field. The completedPhase field is used as - * a default from the merge descriptor, but not overridden if it exists. - * - * @param mergeInto the descriptor to be merged into - * @param toBeMerged the descriptor to merge into mergeInto - * @return ReleaseDescriptor the merged descriptor - */ - public static ReleaseDescriptor merge( ReleaseDescriptor mergeInto, ReleaseDescriptor toBeMerged ) + public static BuilderReleaseDescriptor buildReleaseDescriptor( ReleaseDescriptorBuilder builder ) { - // Overridden if configured from the caller - mergeInto.setScmId( mergeOverride( mergeInto.getScmId(), toBeMerged.getScmId() ) ); - mergeInto.setScmSourceUrl( mergeOverride( mergeInto.getScmSourceUrl(), toBeMerged.getScmSourceUrl() ) ); - mergeInto.setScmCommentPrefix( - mergeOverride( mergeInto.getScmCommentPrefix(), toBeMerged.getScmCommentPrefix() ) ); - mergeInto.setScmReleaseLabel( mergeOverride( mergeInto.getScmReleaseLabel(), - toBeMerged.getScmReleaseLabel() ) ); - mergeInto.setScmTagBase( mergeOverride( mergeInto.getScmTagBase(), toBeMerged.getScmTagBase() ) ); - mergeInto.setScmTagNameFormat( - mergeOverride( mergeInto.getScmTagNameFormat(), toBeMerged.getScmTagNameFormat() ) ); - mergeInto.setScmBranchBase( mergeOverride( mergeInto.getScmBranchBase(), toBeMerged.getScmBranchBase() ) ); - mergeInto.setScmUsername( mergeOverride( mergeInto.getScmUsername(), toBeMerged.getScmUsername() ) ); - mergeInto.setScmPassword( mergeOverride( mergeInto.getScmPassword(), toBeMerged.getScmPassword() ) ); - mergeInto.setScmPrivateKey( mergeOverride( mergeInto.getScmPrivateKey(), toBeMerged.getScmPrivateKey() ) ); - mergeInto.setScmPrivateKeyPassPhrase( - mergeOverride( mergeInto.getScmPrivateKeyPassPhrase(), toBeMerged.getScmPrivateKeyPassPhrase() ) ); - mergeInto.setScmCommentPrefix( - mergeOverride( mergeInto.getScmCommentPrefix(), toBeMerged.getScmCommentPrefix() ) ); - mergeInto.setAdditionalArguments( - mergeOverride( mergeInto.getAdditionalArguments(), toBeMerged.getAdditionalArguments() ) ); - mergeInto.setPreparationGoals( - mergeOverride( mergeInto.getPreparationGoals(), toBeMerged.getPreparationGoals() ) ); - mergeInto.setCompletionGoals( - mergeOverride( mergeInto.getCompletionGoals(), toBeMerged.getCompletionGoals() ) ); - mergeInto.setPerformGoals( mergeOverride( mergeInto.getPerformGoals(), toBeMerged.getPerformGoals() ) ); - mergeInto.setPomFileName( mergeOverride( mergeInto.getPomFileName(), toBeMerged.getPomFileName() ) ); - mergeInto.setCheckModificationExcludes( toBeMerged.getCheckModificationExcludes() ); - mergeInto.setScmUseEditMode( toBeMerged.isScmUseEditMode() ); - mergeInto.setAddSchema( toBeMerged.isAddSchema() ); - mergeInto.setGenerateReleasePoms( toBeMerged.isGenerateReleasePoms() ); - mergeInto.setInteractive( toBeMerged.isInteractive() ); - mergeInto.setUpdateDependencies( toBeMerged.isUpdateDependencies() ); - mergeInto.setCommitByProject( mergeOverride( mergeInto.isCommitByProject(), toBeMerged.isCommitByProject(), - false ) ); - mergeInto.setUseReleaseProfile( toBeMerged.isUseReleaseProfile() ); - mergeInto.setBranchCreation( toBeMerged.isBranchCreation() ); - mergeInto.setUpdateBranchVersions( toBeMerged.isUpdateBranchVersions() ); - mergeInto.setUpdateWorkingCopyVersions( toBeMerged.isUpdateWorkingCopyVersions() ); - mergeInto.setSuppressCommitBeforeTagOrBranch( toBeMerged.isSuppressCommitBeforeTagOrBranch() ); - mergeInto.setUpdateVersionsToSnapshot( toBeMerged.isUpdateVersionsToSnapshot() ); - mergeInto.setAllowTimestampedSnapshots( toBeMerged.isAllowTimestampedSnapshots() ); - mergeInto.setSnapshotReleasePluginAllowed( toBeMerged.isSnapshotReleasePluginAllowed() ); - mergeInto.setAutoVersionSubmodules( toBeMerged.isAutoVersionSubmodules() ); - mergeInto.setDefaultReleaseVersion( mergeOverride( mergeInto.getDefaultReleaseVersion(), - toBeMerged.getDefaultReleaseVersion() ) ); - mergeInto.setDefaultDevelopmentVersion( mergeOverride( mergeInto.getDefaultDevelopmentVersion(), - toBeMerged.getDefaultDevelopmentVersion() ) ); - mergeInto.setRemoteTagging( toBeMerged.isRemoteTagging() ); - mergeInto.setLocalCheckout( toBeMerged.isLocalCheckout() ); - mergeInto.setPushChanges( toBeMerged.isPushChanges() ); - mergeInto.setWaitBeforeTagging( toBeMerged.getWaitBeforeTagging() ); + return builder.build(); + } - // If the user specifies versions, these should be override the existing versions - if ( toBeMerged.getReleaseVersions() != null ) + public static void copyPropertiesToReleaseDescriptor( Properties properties, ReleaseDescriptorBuilder builder ) + { + if ( properties.containsKey( "completedPhase" ) ) { - mergeInto.getReleaseVersions().putAll( toBeMerged.getReleaseVersions() ); + builder.setCompletedPhase( properties.getProperty( "completedPhase" ) ); } - if ( toBeMerged.getDevelopmentVersions() != null ) + if ( properties.containsKey( "commitByProject" ) ) { - mergeInto.getDevelopmentVersions().putAll( toBeMerged.getDevelopmentVersions() ); + builder.setCommitByProject( Boolean.parseBoolean( properties.getProperty( "commitByProject" ) ) ); + } + if ( properties.containsKey( "scm.id" ) ) + { + builder.setScmId( properties.getProperty( "scm.id" ) ); + } + if ( properties.containsKey( "scm.url" ) ) + { + builder.setScmSourceUrl( properties.getProperty( "scm.url" ) ); + } + if ( properties.containsKey( "scm.username" ) ) + { + builder.setScmUsername( properties.getProperty( "scm.username" ) ); + } + if ( properties.containsKey( "scm.password" ) ) + { + builder.setScmPassword( properties.getProperty( "scm.password" ) ); + } + if ( properties.containsKey( "scm.privateKey" ) ) + { + builder.setScmPrivateKey( properties.getProperty( "scm.privateKey" ) ); + } + if ( properties.containsKey( "scm.passphrase" ) ) + { + builder.setScmPrivateKeyPassPhrase( properties.getProperty( "scm.passphrase" ) ); + } + if ( properties.containsKey( "scm.tagBase" ) ) + { + builder.setScmTagBase( properties.getProperty( "scm.tagBase" ) ); + } + if ( properties.containsKey( "scm.tagNameFormat" ) ) + { + builder.setScmTagNameFormat( properties.getProperty( "scm.tagNameFormat" ) ); + } + if ( properties.containsKey( "scm.branchBase" ) ) + { + builder.setScmBranchBase( properties.getProperty( "scm.branchBase" ) ); + } + if ( properties.containsKey( "scm.tag" ) ) + { + builder.setScmReleaseLabel( properties.getProperty( "scm.tag" ) ); + } + if ( properties.containsKey( "scm.commentPrefix" ) ) + { + builder.setScmCommentPrefix( properties.getProperty( "scm.commentPrefix" ) ); + } + if ( properties.containsKey( "exec.additionalArguments" ) ) + { + builder.setAdditionalArguments( properties.getProperty( "exec.additionalArguments" ) ); + } + if ( properties.containsKey( "exec.pomFileName" ) ) + { + builder.setPomFileName( properties.getProperty( "exec.pomFileName" ) ); + } + if ( properties.containsKey( "preparationGoals" ) ) + { + builder.setPreparationGoals( properties.getProperty( "preparationGoals" ) ); + } + if ( properties.containsKey( "completionGoals" ) ) + { + builder.setCompletionGoals( properties.getProperty( "completionGoals" ) ); + } + if ( properties.containsKey( "projectVersionPolicyId" ) ) + { + builder.setProjectVersionPolicyId( properties.getProperty( "projectVersionPolicyId" ) ); + } + if ( properties.containsKey( "projectNamingPolicyId" ) ) + { + builder.setProjectNamingPolicyId( properties.getProperty( "projectNamingPolicyId" ) ); + } + if ( properties.containsKey( "releaseStrategyId" ) ) + { + builder.setReleaseStrategyId( properties.getProperty( "releaseStrategyId" ) ); + } + if ( properties.containsKey( "exec.snapshotReleasePluginAllowed" ) ) + { + String snapshotReleasePluginAllowedStr = properties.getProperty( "exec.snapshotReleasePluginAllowed" ); + builder.setSnapshotReleasePluginAllowed( Boolean.valueOf( snapshotReleasePluginAllowedStr ) ); + } + if ( properties.containsKey( "remoteTagging" ) ) + { + String remoteTaggingStr = properties.getProperty( "remoteTagging" ); + builder.setRemoteTagging( Boolean.valueOf( remoteTaggingStr ) ); + } + if ( properties.containsKey( "pushChanges" ) ) + { + String pushChanges = properties.getProperty( "pushChanges" ); + builder.setPushChanges( Boolean.valueOf( pushChanges ) ); } - // These must be overridden, as they are not stored - mergeInto.setWorkingDirectory( - mergeOverride( mergeInto.getWorkingDirectory(), toBeMerged.getWorkingDirectory() ) ); - mergeInto.setCheckoutDirectory( - mergeOverride( mergeInto.getCheckoutDirectory(), toBeMerged.getCheckoutDirectory() ) ); - - // Not overridden - not configured from caller - mergeInto.setCompletedPhase( mergeDefault( mergeInto.getCompletedPhase(), toBeMerged.getCompletedPhase() ) ); - - mergeInto.setProjectVersionPolicyId( mergeDefault( mergeInto.getProjectVersionPolicyId(), - toBeMerged.getProjectVersionPolicyId() ) ); - mergeInto.setProjectNamingPolicyId( mergeDefault( mergeInto.getProjectNamingPolicyId(), - toBeMerged.getProjectNamingPolicyId() ) ); - mergeInto.setReleaseStrategyId( mergeOverride( mergeInto.getReleaseStrategyId(), - toBeMerged.getReleaseStrategyId() ) ); - - return mergeInto; - } - - private static String mergeOverride( String thisValue, String mergeValue ) - { - return mergeValue != null ? mergeValue : thisValue; - } - - private static String mergeDefault( String thisValue, String mergeValue ) - { - return thisValue != null ? thisValue : mergeValue; - } - - private static boolean mergeOverride( boolean thisValue, boolean mergeValue, boolean defaultValue ) - { - return mergeValue != defaultValue ? mergeValue : thisValue; - } - - public static ReleaseDescriptor copyPropertiesToReleaseDescriptor( Properties properties ) - { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setCompletedPhase( properties.getProperty( "completedPhase" ) ); - releaseDescriptor.setCommitByProject( Boolean.parseBoolean( properties.getProperty( "commitByProject" ) ) ); - releaseDescriptor.setScmId( properties.getProperty( "scm.id" ) ); - releaseDescriptor.setScmSourceUrl( properties.getProperty( "scm.url" ) ); - releaseDescriptor.setScmUsername( properties.getProperty( "scm.username" ) ); - releaseDescriptor.setScmPassword( properties.getProperty( "scm.password" ) ); - releaseDescriptor.setScmPrivateKey( properties.getProperty( "scm.privateKey" ) ); - releaseDescriptor.setScmPrivateKeyPassPhrase( properties.getProperty( "scm.passphrase" ) ); - releaseDescriptor.setScmTagBase( properties.getProperty( "scm.tagBase" ) ); - releaseDescriptor.setScmTagNameFormat( properties.getProperty( "scm.tagNameFormat" ) ); - releaseDescriptor.setScmBranchBase( properties.getProperty( "scm.branchBase" ) ); - releaseDescriptor.setScmReleaseLabel( properties.getProperty( "scm.tag" ) ); - releaseDescriptor.setScmCommentPrefix( properties.getProperty( "scm.commentPrefix" ) ); - releaseDescriptor.setAdditionalArguments( properties.getProperty( "exec.additionalArguments" ) ); - releaseDescriptor.setPomFileName( properties.getProperty( "exec.pomFileName" ) ); - releaseDescriptor.setPreparationGoals( properties.getProperty( "preparationGoals" ) ); - releaseDescriptor.setCompletionGoals( properties.getProperty( "completionGoals" ) ); - releaseDescriptor.setProjectVersionPolicyId( properties.getProperty( "projectVersionPolicyId" ) ); - releaseDescriptor.setProjectNamingPolicyId( properties.getProperty( "projectNamingPolicyId" ) ); - releaseDescriptor.setReleaseStrategyId( properties.getProperty( "releaseStrategyId" ) ); - String snapshotReleasePluginAllowedStr = properties.getProperty( "exec.snapshotReleasePluginAllowed" ); - releaseDescriptor.setSnapshotReleasePluginAllowed( snapshotReleasePluginAllowedStr == null - ? false - : Boolean.valueOf( - snapshotReleasePluginAllowedStr ).booleanValue() ); - String remoteTaggingStr = properties.getProperty( "remoteTagging" ); - releaseDescriptor.setRemoteTagging( - remoteTaggingStr == null ? false : Boolean.valueOf( remoteTaggingStr ).booleanValue() ); - String pushChanges = properties.getProperty( "pushChanges" ); - releaseDescriptor.setPushChanges( pushChanges == null ? true : Boolean.valueOf( pushChanges ).booleanValue() ); - loadResolvedDependencies( properties, releaseDescriptor ); + loadResolvedDependencies( properties, builder ); // boolean properties are not written to the properties file because the value from the caller is always used @@ -189,12 +155,12 @@ public static ReleaseDescriptor copyPropertiesToReleaseDescriptor( Properties pr String property = (String) i.next(); if ( property.startsWith( "project.rel." ) ) { - releaseDescriptor.mapReleaseVersion( property.substring( "project.rel.".length() ), + builder.addReleaseVersion( property.substring( "project.rel.".length() ), properties.getProperty( property ) ); } else if ( property.startsWith( "project.dev." ) ) { - releaseDescriptor.mapDevelopmentVersion( property.substring( "project.dev.".length() ), + builder.addDevelopmentVersion( property.substring( "project.dev.".length() ), properties.getProperty( property ) ); } else if ( property.startsWith( "project.scm." ) ) @@ -204,11 +170,11 @@ else if ( property.startsWith( "project.scm." ) ) { String key = property.substring( "project.scm.".length(), index ); - if ( !releaseDescriptor.getOriginalScmInfo().containsKey( key ) ) + if ( builder.build().getOriginalScmInfo( key ) == null ) { if ( properties.getProperty( "project.scm." + key + ".empty" ) != null ) { - releaseDescriptor.mapOriginalScmInfo( key, null ); + builder.addOriginalScmInfo( key, null ); } else { @@ -220,19 +186,16 @@ else if ( property.startsWith( "project.scm." ) ) scm.setTag( properties.getProperty( "project.scm." + key + ".tag" ) ); scm.setId( properties.getProperty( "project.scm." + key + ".id" ) ); - releaseDescriptor.mapOriginalScmInfo( key, scm ); + builder.addOriginalScmInfo( key, scm ); } } } } } - return releaseDescriptor; } - private static void loadResolvedDependencies( Properties prop, ReleaseDescriptor descriptor ) + private static void loadResolvedDependencies( Properties prop, ReleaseDescriptorBuilder builder ) { - Map> resolvedDependencies = new HashMap<>(); - Set entries = prop.entrySet(); Iterator> iterator = entries.iterator(); String propertyName; @@ -245,23 +208,20 @@ private static void loadResolvedDependencies( Properties prop, ReleaseDescriptor if ( propertyName.startsWith( "dependency." ) ) { - Map versionMap; String artifactVersionlessKey; int startIndex = "dependency.".length(); int endIndex; String versionType; - versionMap = new HashMap<>(); - if ( propertyName.indexOf( ".development" ) != -1 ) { endIndex = propertyName.lastIndexOf( ".development" ); - versionType = ReleaseDescriptor.DEVELOPMENT_KEY; + versionType = DEVELOPMENT_KEY; } else if ( propertyName.indexOf( ".release" ) != -1 ) { endIndex = propertyName.lastIndexOf( ".release" ); - versionType = ReleaseDescriptor.RELEASE_KEY; + versionType = RELEASE_KEY; } else { @@ -271,21 +231,16 @@ else if ( propertyName.indexOf( ".release" ) != -1 ) artifactVersionlessKey = propertyName.substring( startIndex, endIndex ); - if ( resolvedDependencies.containsKey( artifactVersionlessKey ) ) + if ( RELEASE_KEY.equals( versionType ) ) { - versionMap = resolvedDependencies.get( artifactVersionlessKey ); + builder.addDependencyReleaseVersion( artifactVersionlessKey, currentEntry.getValue() ); } - else + else if ( DEVELOPMENT_KEY.equals( versionType ) ) { - versionMap = new HashMap<>(); - resolvedDependencies.put( artifactVersionlessKey, versionMap ); + builder.addDependencyDevelopmentVersion( artifactVersionlessKey, currentEntry.getValue() ); } - - versionMap.put( versionType, currentEntry.getValue() ); } } - - descriptor.setResolvedSnapshotDependencies( resolvedDependencies ); } } diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java index 6b5659e2b..3305756f3 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/env/DefaultReleaseEnvironment.java @@ -55,15 +55,13 @@ public Settings getSettings() return settings; } - @Override - public ReleaseEnvironment setMavenHome( File mavenHome ) + public DefaultReleaseEnvironment setMavenHome( File mavenHome ) { this.mavenHome = mavenHome; return this; } - @Override - public ReleaseEnvironment setSettings( Settings settings ) + public DefaultReleaseEnvironment setSettings( Settings settings ) { this.settings = settings; return this; @@ -75,8 +73,7 @@ public String getMavenExecutorId() return mavenExecutorId; } - @Override - public ReleaseEnvironment setMavenExecutorId( String mavenExecutorId ) + public DefaultReleaseEnvironment setMavenExecutorId( String mavenExecutorId ) { this.mavenExecutorId = mavenExecutorId; return this; @@ -88,8 +85,7 @@ public File getJavaHome() return javaHome; } - @Override - public ReleaseEnvironment setJavaHome( File javaHome ) + public DefaultReleaseEnvironment setJavaHome( File javaHome ) { this.javaHome = javaHome; return this; @@ -108,8 +104,7 @@ public File getLocalRepositoryDirectory() return localRepo; } - @Override - public ReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory ) + public DefaultReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory ) { this.localRepositoryDirectory = localRepositoryDirectory; return this; @@ -121,8 +116,7 @@ public Locale getLocale() return locale; } - @Override - public ReleaseEnvironment setLocale( Locale locale ) + public DefaultReleaseEnvironment setLocale( Locale locale ) { this.locale = locale; return this; diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java index 6fd4cb6d3..ac6a682ba 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/AbstractRewritePomsPhase.java @@ -35,7 +35,6 @@ import org.apache.maven.model.ModelBase; import org.apache.maven.model.Plugin; import org.apache.maven.model.Profile; -import org.apache.maven.model.Scm; import org.apache.maven.project.MavenProject; import org.apache.maven.scm.ScmException; import org.apache.maven.scm.ScmFileSet; @@ -49,7 +48,6 @@ import org.apache.maven.shared.release.ReleaseResult; import org.apache.maven.shared.release.config.ReleaseDescriptor; import org.apache.maven.shared.release.env.ReleaseEnvironment; -import org.apache.maven.shared.release.scm.IdentifiedScm; import org.apache.maven.shared.release.scm.ReleaseScmCommandException; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator; @@ -239,51 +237,42 @@ private void transformDocument( MavenProject project, Model modelTarget, Release ReleaseResult result, boolean simulate ) throws ReleaseExecutionException, ReleaseFailureException { - Map mappedVersions = getNextVersionMap( releaseDescriptor ); - Map originalVersions = getOriginalVersionMap( releaseDescriptor, reactorProjects, simulate ); - Map> resolvedSnapshotDependencies = - releaseDescriptor.getResolvedSnapshotDependencies(); Model model = project.getModel(); Properties properties = modelTarget.getProperties(); - String parentVersion = rewriteParent( project, modelTarget, mappedVersions, - resolvedSnapshotDependencies, originalVersions ); + String parentVersion = rewriteParent( project, modelTarget, releaseDescriptor, simulate ); String projectId = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ); - rewriteVersion( modelTarget, mappedVersions, projectId, project, parentVersion ); + rewriteVersion( modelTarget, releaseDescriptor, projectId, project, parentVersion ); Build buildTarget = modelTarget.getBuild(); if ( buildTarget != null ) { // profile.build.extensions doesn't exist, so only rewrite project.build.extensions - rewriteArtifactVersions( toMavenCoordinates( buildTarget.getExtensions() ), mappedVersions, - resolvedSnapshotDependencies, originalVersions, model, properties, result, - releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( buildTarget.getExtensions() ), + model, properties, result, releaseDescriptor, simulate ); - rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPlugins() ), mappedVersions, - resolvedSnapshotDependencies, originalVersions, model, properties, result, - releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPlugins() ), + model, properties, result, releaseDescriptor, simulate ); for ( Plugin plugin : buildTarget.getPlugins() ) { rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), - mappedVersions, resolvedSnapshotDependencies, originalVersions, model, - properties, result, releaseDescriptor ); + model, properties, + result, releaseDescriptor, simulate ); } if ( buildTarget.getPluginManagement() != null ) { - rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPluginManagement().getPlugins() ), - mappedVersions, resolvedSnapshotDependencies, originalVersions, model, - properties, result, releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( buildTarget.getPluginManagement().getPlugins() ), model, + properties, result, releaseDescriptor, simulate ); for ( Plugin plugin : buildTarget.getPluginManagement().getPlugins() ) { - rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), mappedVersions, - resolvedSnapshotDependencies, originalVersions, model, properties, - result, releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), model, properties, result, + releaseDescriptor, simulate ); } } } @@ -293,28 +282,24 @@ private void transformDocument( MavenProject project, Model modelTarget, Release BuildBase profileBuild = profile.getBuild(); if ( profileBuild != null ) { - rewriteArtifactVersions( toMavenCoordinates( profileBuild.getPlugins() ), mappedVersions, - resolvedSnapshotDependencies, originalVersions, model, properties, result, - releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( profileBuild.getPlugins() ), model, properties, result, + releaseDescriptor, simulate ); for ( Plugin plugin : profileBuild.getPlugins() ) { - rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), - mappedVersions, resolvedSnapshotDependencies, originalVersions, model, - properties, result, releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), model, properties, result, + releaseDescriptor, simulate ); } if ( profileBuild.getPluginManagement() != null ) { rewriteArtifactVersions( toMavenCoordinates( profileBuild.getPluginManagement().getPlugins() ), - mappedVersions, resolvedSnapshotDependencies, originalVersions, model, - properties, result, releaseDescriptor ); + model, properties, result, releaseDescriptor, simulate ); for ( Plugin plugin : profileBuild.getPluginManagement().getPlugins() ) { - rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), mappedVersions, - resolvedSnapshotDependencies, originalVersions, model, properties, - result, releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( plugin.getDependencies() ), model, properties, + result, releaseDescriptor, simulate ); } } } @@ -326,22 +311,19 @@ private void transformDocument( MavenProject project, Model modelTarget, Release for ( ModelBase modelBase : modelBases ) { - rewriteArtifactVersions( toMavenCoordinates( modelBase.getDependencies() ), mappedVersions, - resolvedSnapshotDependencies, originalVersions, model, properties, result, - releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( modelBase.getDependencies() ), model, properties, result, + releaseDescriptor, simulate ); if ( modelBase.getDependencyManagement() != null ) { rewriteArtifactVersions( toMavenCoordinates( modelBase.getDependencyManagement().getDependencies() ), - mappedVersions, resolvedSnapshotDependencies, originalVersions, model, - properties, result, releaseDescriptor ); + model, properties, result, releaseDescriptor, simulate ); } if ( modelBase.getReporting() != null ) { - rewriteArtifactVersions( toMavenCoordinates( modelBase.getReporting().getPlugins() ), mappedVersions, - resolvedSnapshotDependencies, originalVersions, model, properties, result, - releaseDescriptor ); + rewriteArtifactVersions( toMavenCoordinates( modelBase.getReporting().getPlugins() ), model, properties, + result, releaseDescriptor, simulate ); } } @@ -360,11 +342,11 @@ private void transformDocument( MavenProject project, Model modelTarget, Release commonBasedir ); } - private void rewriteVersion( Model modelTarget, Map mappedVersions, String projectId, + private void rewriteVersion( Model modelTarget, ReleaseDescriptor releaseDescriptor, String projectId, MavenProject project, String parentVersion ) throws ReleaseFailureException { - String version = mappedVersions.get( projectId ); + String version = getNextVersion( releaseDescriptor, projectId ); if ( version == null ) { throw new ReleaseFailureException( "Version for '" + project.getName() + "' was not mapped" ); @@ -373,9 +355,8 @@ private void rewriteVersion( Model modelTarget, Map mappedVersio modelTarget.setVersion( version ); } - private String rewriteParent( MavenProject project, Model targetModel, Map mappedVersions, - Map> resolvedSnapshotDependencies, - Map originalVersions ) + private String rewriteParent( MavenProject project, Model targetModel, + ReleaseDescriptor releaseDescriptor, boolean simulate ) throws ReleaseFailureException { String parentVersion = null; @@ -383,15 +364,16 @@ private String rewriteParent( MavenProject project, Model targetModel, Map elements, Map mappedVersions, - Map> resolvedSnapshotDependencies, - Map originalVersions, Model projectModel, + private void rewriteArtifactVersions( Collection elements, Model projectModel, Properties properties, ReleaseResult result, - ReleaseDescriptor releaseDescriptor ) + ReleaseDescriptor releaseDescriptor, boolean simulate ) throws ReleaseExecutionException, ReleaseFailureException { if ( elements == null ) @@ -449,12 +429,12 @@ private void rewriteArtifactVersions( Collection elements, Map< String artifactId = ReleaseUtil.interpolate( rawArtifactId, projectModel ); String key = ArtifactUtils.versionlessKey( groupId, artifactId ); - String resolvedSnapshotVersion = getResolvedSnapshotVersion( key, resolvedSnapshotDependencies ); - String mappedVersion = mappedVersions.get( key ); - String originalVersion = originalVersions.get( key ); + String resolvedSnapshotVersion = getResolvedSnapshotVersion( key, releaseDescriptor ); + String mappedVersion = getNextVersion( releaseDescriptor, key ); + String originalVersion = getOriginalVersion( releaseDescriptor, key, simulate ); if ( originalVersion == null ) { - originalVersion = getOriginalResolvedSnapshotVersion( key, resolvedSnapshotDependencies ); + originalVersion = getOriginalResolvedSnapshotVersion( key, releaseDescriptor ); } // MRELEASE-220 @@ -478,7 +458,7 @@ else if ( rawVersion.matches( "\\$\\{.+\\}" ) ) if ( expression.startsWith( "project." ) || expression.startsWith( "pom." ) || "version".equals( expression ) ) { - if ( !mappedVersion.equals( mappedVersions.get( projectId ) ) ) + if ( !mappedVersion.equals( getNextVersion( releaseDescriptor, projectId ) ) ) { logInfo( result, " Updating " + artifactId + " to " + mappedVersion ); coordinate.setVersion( mappedVersion ); @@ -579,13 +559,12 @@ private void prepareScm( File pomFile, ReleaseDescriptor releaseDescriptor, ScmR protected abstract String getResolvedSnapshotVersion( String artifactVersionlessKey, - Map> resolvedSnapshots ); + ReleaseDescriptor releaseDscriptor ); - protected abstract Map getOriginalVersionMap( ReleaseDescriptor releaseDescriptor, - List reactorProjects, - boolean simulate ); + protected abstract String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, + boolean simulate ); - protected abstract Map getNextVersionMap( ReleaseDescriptor releaseDescriptor ); + protected abstract String getNextVersion( ReleaseDescriptor releaseDescriptor, String key ); protected abstract void transformScm( MavenProject project, Model modelTarget, ReleaseDescriptor releaseDescriptor, String projectId, ScmRepository scmRepository, @@ -603,37 +582,9 @@ protected boolean isUpdateScm() } protected String getOriginalResolvedSnapshotVersion( String artifactVersionlessKey, - Map> resolvedSnapshots ) + ReleaseDescriptor releaseDescriptor ) { - Map versionsMap = resolvedSnapshots.get( artifactVersionlessKey ); - - if ( versionsMap != null ) - { - return versionsMap.get( ReleaseDescriptor.ORIGINAL_VERSION ); - } - else - { - return null; - } - } - - protected Scm buildScm( MavenProject project ) - { - IdentifiedScm scm; - if ( project.getOriginalModel().getScm() == null ) - { - scm = null; - } - else - { - scm = new IdentifiedScm(); - scm.setConnection( project.getOriginalModel().getScm().getConnection() ); - scm.setDeveloperConnection( project.getOriginalModel().getScm().getDeveloperConnection() ); - scm.setTag( project.getOriginalModel().getScm().getTag() ); - scm.setUrl( project.getOriginalModel().getScm().getUrl() ); - scm.setId( project.getProperties().getProperty( "project.scm.id" ) ); - } - return scm; + return releaseDescriptor.getDependencyOriginalVersion( artifactVersionlessKey ); } /** diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java index cc762c955..4dd43b720 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhase.java @@ -22,7 +22,6 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; -import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; @@ -78,10 +77,6 @@ public class CheckDependencySnapshotsPhase // We'll probably need to introduce specifiedSnapshots as well. // @TODO MRELEASE-378: verify custom dependencies in plugins. Be aware of deprecated/removed Components in M3, such as PluginCollector // @TODO MRELEASE-763: verify all dependencies in inactive profiles - private Set usedSnapshotDependencies = new HashSet<>(); - private Set usedSnapshotReports = new HashSet<>(); - private Set usedSnapshotExtensions = new HashSet<>(); - private Set usedSnapshotPlugins = new HashSet<>(); // Don't prompt for every project in reactor, remember state of questions private String resolveSnapshot; @@ -99,11 +94,9 @@ public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnviro { logInfo( result, "Checking dependencies and plugins for snapshots ..." ); - Map originalVersions = releaseDescriptor.getOriginalVersions( reactorProjects ); - for ( MavenProject project : reactorProjects ) { - checkProject( project, originalVersions, releaseDescriptor ); + checkProject( project, releaseDescriptor ); } } else @@ -115,35 +108,36 @@ public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnviro return result; } - private void checkProject( MavenProject project, Map originalVersions, - ReleaseDescriptor releaseDescriptor ) + private void checkProject( MavenProject project, ReleaseDescriptor releaseDescriptor ) throws ReleaseFailureException, ReleaseExecutionException { Map artifactMap = ArtifactUtils.artifactMapByVersionlessId( project.getArtifacts() ); + + Set usedSnapshotDependencies = new HashSet<>(); if ( project.getParentArtifact() != null ) { - if ( checkArtifact( project.getParentArtifact(), originalVersions, artifactMap, releaseDescriptor ) ) + if ( checkArtifact( project.getParentArtifact(), artifactMap, releaseDescriptor ) ) { usedSnapshotDependencies.add( project.getParentArtifact() ); } } Set dependencyArtifacts = project.getArtifacts(); - checkDependencies( originalVersions, releaseDescriptor, artifactMap, dependencyArtifacts ); + usedSnapshotDependencies.addAll( checkDependencies( releaseDescriptor, artifactMap, dependencyArtifacts ) ); //@todo check dependencyManagement Set pluginArtifacts = project.getPluginArtifacts(); - checkPlugins( originalVersions, releaseDescriptor, artifactMap, pluginArtifacts ); + Set usedSnapshotPlugins = checkPlugins( releaseDescriptor, artifactMap, pluginArtifacts ); //@todo check pluginManagement Set reportArtifacts = project.getReportArtifacts(); - checkReports( originalVersions, releaseDescriptor, artifactMap, reportArtifacts ); + Set usedSnapshotReports = checkReports( releaseDescriptor, artifactMap, reportArtifacts ); Set extensionArtifacts = project.getExtensionArtifacts(); - checkExtensions( originalVersions, releaseDescriptor, artifactMap, extensionArtifacts ); + Set usedSnapshotExtensions = checkExtensions( releaseDescriptor, artifactMap, extensionArtifacts ); //@todo check profiles @@ -173,13 +167,14 @@ private void checkProject( MavenProject project, Map originalVer } } - private void checkPlugins( Map originalVersions, ReleaseDescriptor releaseDescriptor, + private Set checkPlugins( ReleaseDescriptor releaseDescriptor, Map artifactMap, Set pluginArtifacts ) throws ReleaseExecutionException { + Set usedSnapshotPlugins = new HashSet<>(); for ( Artifact artifact : pluginArtifacts ) { - if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) ) + if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) ) { boolean addToFailures; @@ -212,7 +207,6 @@ else if ( releaseDescriptor.isInteractive() ) if ( result.toLowerCase( Locale.ENGLISH ).startsWith( "y" ) ) { addToFailures = false; - releaseDescriptor.setSnapshotReleasePluginAllowed( true ); } else { @@ -240,52 +234,60 @@ else if ( releaseDescriptor.isInteractive() ) } } } + return usedSnapshotPlugins; } - private void checkDependencies( Map originalVersions, ReleaseDescriptor releaseDescriptor, - Map artifactMap, Set dependencyArtifacts ) + private Set checkDependencies( ReleaseDescriptor releaseDescriptor, + Map artifactMap, + Set dependencyArtifacts ) { + Set usedSnapshotDependencies = new HashSet<>(); for ( Artifact artifact : dependencyArtifacts ) { - if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) ) + if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) ) { usedSnapshotDependencies.add( getArtifactFromMap( artifact, artifactMap ) ); } } + return usedSnapshotDependencies; } - private void checkReports( Map originalVersions, ReleaseDescriptor releaseDescriptor, + private Set checkReports( ReleaseDescriptor releaseDescriptor, Map artifactMap, Set reportArtifacts ) { + Set usedSnapshotReports = new HashSet<>(); for ( Artifact artifact : reportArtifacts ) { - if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) ) + if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) ) { //snapshotDependencies.add( artifact ); usedSnapshotReports.add( artifact ); } } + return usedSnapshotReports; } - private void checkExtensions( Map originalVersions, ReleaseDescriptor releaseDescriptor, + private Set checkExtensions( ReleaseDescriptor releaseDescriptor, Map artifactMap, Set extensionArtifacts ) { + Set usedSnapshotExtensions = new HashSet<>(); for ( Artifact artifact : extensionArtifacts ) { - if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) ) + if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) ) { usedSnapshotExtensions.add( artifact ); } } + return usedSnapshotExtensions; } - private static boolean checkArtifact( Artifact artifact, Map originalVersions, + private static boolean checkArtifact( Artifact artifact, Map artifactMapByVersionlessId, ReleaseDescriptor releaseDescriptor ) { Artifact checkArtifact = getArtifactFromMap( artifact, artifactMapByVersionlessId ); - return checkArtifact( checkArtifact, originalVersions, releaseDescriptor ); + return checkArtifact( checkArtifact, releaseDescriptor ); } private static Artifact getArtifactFromMap( Artifact artifact, Map artifactMapByVersionlessId ) @@ -300,16 +302,14 @@ private static Artifact getArtifactFromMap( Artifact artifact, Map originalVersions, - ReleaseDescriptor releaseDescriptor ) + private static boolean checkArtifact( Artifact artifact, ReleaseDescriptor releaseDescriptor ) { - String versionlessArtifactKey = ArtifactUtils.versionlessKey( artifact.getGroupId(), artifact.getArtifactId() ); - + String versionlessKey = ArtifactUtils.versionlessKey( artifact.getGroupId(), artifact.getArtifactId() ); + // We are only looking at dependencies external to the project - ignore anything found in the reactor as // it's version will be updated - boolean result = - artifact.isSnapshot() - && !artifact.getBaseVersion().equals( originalVersions.get( versionlessArtifactKey ) ); + boolean result = artifact.isSnapshot() + && !artifact.getBaseVersion().equals( releaseDescriptor.getProjectOriginalVersion( versionlessKey ) ); // If we have a snapshot but allowTimestampedSnapshots is true, accept the artifact if the version // indicates that it is a timestamped snapshot. @@ -368,8 +368,6 @@ private void resolveSnapshots( Set projectDependencies, Set if ( resolveSnapshot.toLowerCase( Locale.ENGLISH ).startsWith( "y" ) ) { - Map> resolvedSnapshots = null; - if ( resolveSnapshotType == null ) { prompter.showMessage( RESOLVE_SNAPSHOT_TYPE_MESSAGE ); @@ -381,36 +379,34 @@ private void resolveSnapshots( Set projectDependencies, Set { // all case 0: - resolvedSnapshots = processSnapshot( projectDependencies ); - resolvedSnapshots.putAll( processSnapshot( pluginDependencies ) ); - resolvedSnapshots.putAll( processSnapshot( reportDependencies ) ); - resolvedSnapshots.putAll( processSnapshot( extensionDependencies ) ); + processSnapshot( projectDependencies, releaseDescriptor ); + processSnapshot( pluginDependencies, releaseDescriptor ); + processSnapshot( reportDependencies, releaseDescriptor ); + processSnapshot( extensionDependencies, releaseDescriptor ); break; // project dependencies case 1: - resolvedSnapshots = processSnapshot( projectDependencies ); + processSnapshot( projectDependencies, releaseDescriptor ); break; // plugins case 2: - resolvedSnapshots = processSnapshot( pluginDependencies ); + processSnapshot( pluginDependencies, releaseDescriptor ); break; // reports case 3: - resolvedSnapshots = processSnapshot( reportDependencies ); + processSnapshot( reportDependencies, releaseDescriptor ); break; // extensions case 4: - resolvedSnapshots = processSnapshot( extensionDependencies ); + processSnapshot( extensionDependencies, releaseDescriptor ); break; default: } - - releaseDescriptor.getResolvedSnapshotDependencies().putAll( resolvedSnapshots ); } } catch ( PrompterException | VersionParseException e ) @@ -419,10 +415,9 @@ private void resolveSnapshots( Set projectDependencies, Set } } - private Map> processSnapshot( Set snapshotSet ) + private void processSnapshot( Set snapshotSet, ReleaseDescriptor releaseDescriptor ) throws PrompterException, VersionParseException { - Map> resolvedSnapshots = new HashMap<>(); Iterator iterator = snapshotSet.iterator(); while ( iterator.hasNext() ) @@ -430,15 +425,15 @@ private Map> processSnapshot( Set snapshot Artifact currentArtifact = iterator.next(); String versionlessKey = ArtifactUtils.versionlessKey( currentArtifact ); - Map versionMap = new HashMap<>(); VersionInfo versionInfo = new DefaultVersionInfo( currentArtifact.getBaseVersion() ); - versionMap.put( ReleaseDescriptor.ORIGINAL_VERSION, versionInfo.toString() ); + releaseDescriptor.addDependencyOriginalVersion( versionlessKey, versionInfo.toString() ); prompter.showMessage( "Dependency '" + versionlessKey + "' is a snapshot (" + currentArtifact.getVersion() + ")\n" ); String result = prompter.prompt( "Which release version should it be set to?", versionInfo.getReleaseVersionString() ); - versionMap.put( ReleaseDescriptor.RELEASE_KEY, result ); + + releaseDescriptor.addDependencyReleaseVersion( versionlessKey, result ); iterator.remove(); @@ -457,11 +452,8 @@ private Map> processSnapshot( Set snapshot } result = prompter.prompt( "What version should the dependency be reset to for development?", nextVersion ); - versionMap.put( ReleaseDescriptor.DEVELOPMENT_KEY, result ); - - resolvedSnapshots.put( versionlessKey, versionMap ); + + releaseDescriptor.addDependencyDevelopmentVersion( versionlessKey, result ); } - - return resolvedSnapshots; } } \ No newline at end of file diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java index b5066d223..128721fd8 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckPomPhase.java @@ -30,7 +30,6 @@ import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator; -import org.apache.maven.shared.release.util.ReleaseUtil; import org.codehaus.plexus.util.StringUtils; import java.util.List; @@ -64,30 +63,14 @@ public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnviro ReleaseResult result = new ReleaseResult(); // Currently, we don't deal with multiple SCM locations in a multiproject - if ( scmRequired && StringUtils.isEmpty( releaseDescriptor.getScmSourceUrl() ) ) + if ( scmRequired ) { - MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - if ( rootProject != null && rootProject.getScm() != null ) - { - if ( rootProject.getScm().getDeveloperConnection() != null ) - { - releaseDescriptor.setScmSourceUrl( rootProject.getScm().getDeveloperConnection() ); - } - else if ( rootProject.getScm().getConnection() != null ) - { - releaseDescriptor.setScmSourceUrl( rootProject.getScm().getConnection() ); - } - } - if ( StringUtils.isEmpty( releaseDescriptor.getScmSourceUrl() ) ) { throw new ReleaseFailureException( "Missing required setting: scm connection or developerConnection must be specified." ); } - // As long as Scm.getId() does not exist, read it as a property - releaseDescriptor.setScmId( rootProject.getProperties().getProperty( "project.scm.id" ) ); - try { scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java index eec0f2c6d..33f953778 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScm.java @@ -183,17 +183,10 @@ private ReleaseResult performCheckout( ReleaseDescriptor releaseDescriptor, Rele } MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); + // TODO: sanity check that it is not . or .. or lower - File checkoutDirectory; - if ( StringUtils.isEmpty( releaseDescriptor.getCheckoutDirectory() ) ) - { - checkoutDirectory = new File( rootProject.getFile().getParentFile(), "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - } - else - { - checkoutDirectory = new File( releaseDescriptor.getCheckoutDirectory() ); - } + File checkoutDirectory = + FileUtils.resolveFile( rootProject.getBasedir(), releaseDescriptor.getCheckoutDirectory() ); if ( checkoutDirectory.exists() ) { diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java index fbb074992..455f9b4a3 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhase.java @@ -216,9 +216,6 @@ private Model createReleaseModel( MavenProject project, ReleaseDescriptor releas ReleaseResult result ) throws ReleaseFailureException, ReleaseExecutionException { - Map originalVersions = getOriginalVersionMap( releaseDescriptor, reactorProjects ); - Map mappedVersions = getNextVersionMap( releaseDescriptor ); - MavenProject releaseProject = project.clone(); Model releaseModel = releaseProject.getModel(); @@ -232,7 +229,7 @@ private Model createReleaseModel( MavenProject project, ReleaseDescriptor releas // update project version String projectVersion = releaseModel.getVersion(); String releaseVersion = - getNextVersion( mappedVersions, project.getGroupId(), project.getArtifactId(), projectVersion ); + getNextVersion( releaseDescriptor, project.getGroupId(), project.getArtifactId(), projectVersion ); releaseModel.setVersion( releaseVersion ); String originalFinalName = releaseModel.getBuild().getFinalName(); @@ -283,17 +280,17 @@ private Model createReleaseModel( MavenProject project, ReleaseDescriptor releas } // rewrite dependencies - releaseModel.setDependencies( createReleaseDependencies( originalVersions, mappedVersions, releaseProject ) ); + releaseModel.setDependencies( createReleaseDependencies( releaseDescriptor, releaseProject ) ); // rewrite plugins - releaseModel.getBuild().setPlugins( createReleasePlugins( originalVersions, mappedVersions, releaseProject ) ); + releaseModel.getBuild().setPlugins( createReleasePlugins( releaseDescriptor, releaseProject ) ); // rewrite reports - releaseModel.getReporting().setPlugins( createReleaseReportPlugins( originalVersions, mappedVersions, + releaseModel.getReporting().setPlugins( createReleaseReportPlugins( releaseDescriptor, releaseProject ) ); // rewrite extensions - releaseModel.getBuild().setExtensions( createReleaseExtensions( originalVersions, mappedVersions, + releaseModel.getBuild().setExtensions( createReleaseExtensions( releaseDescriptor, releaseProject ) ); unalignFromBaseDirectory( releaseModel, project.getBasedir() ); @@ -419,18 +416,7 @@ public ReleaseResult simulate( ReleaseDescriptor releaseDescriptor, ReleaseEnvir return execute( releaseDescriptor, releaseEnvironment, reactorProjects, true ); } - protected Map getOriginalVersionMap( ReleaseDescriptor releaseDescriptor, - List reactorProjects ) - { - return releaseDescriptor.getOriginalVersions( reactorProjects ); - } - - protected Map getNextVersionMap( ReleaseDescriptor releaseDescriptor ) - { - return releaseDescriptor.getReleaseVersions(); - } - - private String getNextVersion( Map mappedVersions, String groupId, String artifactId, + private String getNextVersion( ReleaseDescriptor releaseDescriptor, String groupId, String artifactId, String version ) throws ReleaseFailureException { @@ -438,7 +424,7 @@ private String getNextVersion( Map mappedVersions, String groupI String id = ArtifactUtils.versionlessKey( groupId, artifactId ); - String nextVersion = mappedVersions.get( id ); + String nextVersion = releaseDescriptor.getProjectReleaseVersion( id ); if ( nextVersion == null ) { @@ -489,8 +475,8 @@ private Scm createReleaseScm( Scm scm, ScmTranslator scmTranslator, ReleaseDescr return releaseScm; } - private List createReleaseDependencies( Map originalVersions, - Map mappedVersions, MavenProject project ) + private List createReleaseDependencies( ReleaseDescriptor releaseDescriptor, + MavenProject project ) throws ReleaseFailureException { Set artifacts = project.getArtifacts(); @@ -513,7 +499,7 @@ private List createReleaseDependencies( Map original releaseDependency.setGroupId( artifact.getGroupId() ); releaseDependency.setArtifactId( artifact.getArtifactId() ); - String version = getReleaseVersion( originalVersions, mappedVersions, artifact ); + String version = getReleaseVersion( releaseDescriptor, artifact ); releaseDependency.setVersion( version ); releaseDependency.setType( artifact.getType() ); @@ -527,14 +513,14 @@ private List createReleaseDependencies( Map original return releaseDependencies; } - private String getReleaseVersion( Map originalVersions, Map mappedVersions, + private String getReleaseVersion( ReleaseDescriptor releaseDescriptor, Artifact artifact ) throws ReleaseFailureException { String key = ArtifactUtils.versionlessKey( artifact ); - String originalVersion = originalVersions.get( key ); - String mappedVersion = mappedVersions.get( key ); + String originalVersion = releaseDescriptor.getProjectOriginalVersion( key ); + String mappedVersion = releaseDescriptor.getProjectReleaseVersion( key ); String version = artifact.getVersion(); @@ -560,8 +546,8 @@ private String getReleaseVersion( Map originalVersions, Map createReleasePlugins( Map originalVersions, - Map mappedVersions, MavenProject project ) + private List createReleasePlugins( ReleaseDescriptor releaseDescriptor, + MavenProject project ) throws ReleaseFailureException { List releasePlugins = null; @@ -583,7 +569,7 @@ private List createReleasePlugins( Map originalVersions, { String id = ArtifactUtils.versionlessKey( plugin.getGroupId(), plugin.getArtifactId() ); Artifact artifact = artifactsById.get( id ); - String version = getReleaseVersion( originalVersions, mappedVersions, artifact ); + String version = getReleaseVersion( releaseDescriptor, artifact ); Plugin releasePlugin = new Plugin(); releasePlugin.setGroupId( plugin.getGroupId() ); @@ -607,8 +593,8 @@ private List createReleasePlugins( Map originalVersions, return releasePlugins; } - private List createReleaseReportPlugins( Map originalVersions, - Map mappedVersions, MavenProject project ) + private List createReleaseReportPlugins( ReleaseDescriptor releaseDescriptor, + MavenProject project ) throws ReleaseFailureException { List releaseReportPlugins = null; @@ -629,7 +615,7 @@ private List createReleaseReportPlugins( Map origi { String id = ArtifactUtils.versionlessKey( reportPlugin.getGroupId(), reportPlugin.getArtifactId() ); Artifact artifact = artifactsById.get( id ); - String version = getReleaseVersion( originalVersions, mappedVersions, artifact ); + String version = getReleaseVersion( releaseDescriptor, artifact ); ReportPlugin releaseReportPlugin = new ReportPlugin(); releaseReportPlugin.setGroupId( reportPlugin.getGroupId() ); @@ -647,8 +633,8 @@ private List createReleaseReportPlugins( Map origi return releaseReportPlugins; } - private List createReleaseExtensions( Map originalVersions, - Map mappedVersions, MavenProject project ) + private List createReleaseExtensions( ReleaseDescriptor releaseDescriptor, + MavenProject project ) throws ReleaseFailureException { List releaseExtensions = null; @@ -668,7 +654,7 @@ private List createReleaseExtensions( Map originalVer { String id = ArtifactUtils.versionlessKey( extension.getGroupId(), extension.getArtifactId() ); Artifact artifact = project.getExtensionArtifactMap().get( id ); - String version = getReleaseVersion( originalVersions, mappedVersions, artifact ); + String version = getReleaseVersion( releaseDescriptor, artifact ); Extension releaseExtension = new Extension(); releaseExtension.setGroupId( extension.getGroupId() ); diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java index 985b9cf0a..c155e3c46 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/InputVariablesPhase.java @@ -134,7 +134,7 @@ public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnviro { // Must get default version from mapped versions, as the project will be the incorrect snapshot String key = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ); - String releaseVersion = releaseDescriptor.getReleaseVersions().get( key ); + String releaseVersion = releaseDescriptor.getProjectReleaseVersion( key ); if ( releaseVersion == null ) { throw new ReleaseExecutionException( "Project tag cannot be selected if version is not yet mapped" ); diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java index eedf50ab5..1b585ab83 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/MapVersionsPhase.java @@ -121,16 +121,16 @@ public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnviro { if ( releaseDescriptor.isBranchCreation() && convertToBranch ) { - releaseDescriptor.mapReleaseVersion( projectId, nextVersion ); + releaseDescriptor.addReleaseVersion( projectId, nextVersion ); } else { - releaseDescriptor.mapDevelopmentVersion( projectId, nextVersion ); + releaseDescriptor.addDevelopmentVersion( projectId, nextVersion ); } } else { - releaseDescriptor.mapReleaseVersion( projectId, nextVersion ); + releaseDescriptor.addReleaseVersion( projectId, nextVersion ); } for ( MavenProject subProject : reactorProjects ) @@ -152,16 +152,16 @@ public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnviro if ( releaseDescriptor.isBranchCreation() && convertToBranch ) { - releaseDescriptor.mapReleaseVersion( subProjectId, v ); + releaseDescriptor.addReleaseVersion( subProjectId, v ); } else { - releaseDescriptor.mapDevelopmentVersion( subProjectId, v ); + releaseDescriptor.addDevelopmentVersion( subProjectId, v ); } } else { - releaseDescriptor.mapReleaseVersion( subProjectId, nextVersion ); + releaseDescriptor.addReleaseVersion( subProjectId, nextVersion ); } } } @@ -177,16 +177,16 @@ public ReleaseResult execute( ReleaseDescriptor releaseDescriptor, ReleaseEnviro { if ( releaseDescriptor.isBranchCreation() && convertToBranch ) { - releaseDescriptor.mapReleaseVersion( projectId, nextVersion ); + releaseDescriptor.addReleaseVersion( projectId, nextVersion ); } else { - releaseDescriptor.mapDevelopmentVersion( projectId, nextVersion ); + releaseDescriptor.addDevelopmentVersion( projectId, nextVersion ); } } else { - releaseDescriptor.mapReleaseVersion( projectId, nextVersion ); + releaseDescriptor.addReleaseVersion( projectId, nextVersion ); } } } @@ -333,7 +333,7 @@ private String getDevelopmentVersion( String projectId, ReleaseDescriptor releas String defaultVersion = releaseDescriptor.getDefaultDevelopmentVersion(); if ( StringUtils.isEmpty( defaultVersion ) ) { - defaultVersion = releaseDescriptor.getDevelopmentVersions().get( projectId ); + defaultVersion = releaseDescriptor.getProjectDevelopmentVersion( projectId ); } return defaultVersion; } @@ -343,7 +343,7 @@ private String getReleaseVersion( String projectId, ReleaseDescriptor releaseDes String nextVersion = releaseDescriptor.getDefaultReleaseVersion(); if ( StringUtils.isEmpty( nextVersion ) ) { - nextVersion = releaseDescriptor.getReleaseVersions().get( projectId ); + nextVersion = releaseDescriptor.getProjectReleaseVersion( projectId ); } return nextVersion; } diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java index 2ed437665..0ef834e64 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomVersionsPhase.java @@ -19,9 +19,6 @@ * under the License. */ -import java.util.List; -import java.util.Map; - import org.apache.maven.model.Model; import org.apache.maven.project.MavenProject; import org.apache.maven.scm.repository.ScmRepository; @@ -61,21 +58,20 @@ protected boolean isUpdateScm() } @Override - protected Map getOriginalVersionMap( ReleaseDescriptor releaseDescriptor, - List reactorProjects, boolean simulate ) + protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate ) { - return releaseDescriptor.getOriginalVersions( reactorProjects ); + return releaseDescriptor.getProjectOriginalVersion( projectKey ); } @Override - protected Map getNextVersionMap( ReleaseDescriptor releaseDescriptor ) + protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key ) { - return releaseDescriptor.getDevelopmentVersions(); + return releaseDescriptor.getProjectDevelopmentVersion( key ); } @Override protected String getResolvedSnapshotVersion( String artifactVersionlessKey, - Map> resolvedSnapshotsMap ) + ReleaseDescriptor resolvedSnapshotsMap ) { // Only update the pom version, not the dependency versions return null; diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java index 1907e6aa8..586e97d98 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhase.java @@ -20,8 +20,6 @@ */ import java.io.IOException; -import java.util.List; -import java.util.Map; import org.apache.maven.artifact.ArtifactUtils; import org.apache.maven.model.Model; @@ -64,9 +62,6 @@ protected void transformScm( MavenProject project, Model modelTarget, ReleaseDes if ( scmRoot != null ) { - Scm scm = buildScm( project ); - releaseDescriptor.mapOriginalScmInfo( projectId, scm ); - try { translateScm( project, releaseDescriptor, scmRoot, scmRepository, result, commonBasedir ); @@ -78,15 +73,13 @@ protected void transformScm( MavenProject project, Model modelTarget, ReleaseDes } else { - releaseDescriptor.mapOriginalScmInfo( projectId, null ); - MavenProject parent = project.getParent(); if ( parent != null ) { // If the SCM element is not present, only add it if the parent was not mapped (ie, it's external to // the release process and so has not been modified, so the values will not be correct on the tag), String parentId = ArtifactUtils.versionlessKey( parent.getGroupId(), parent.getArtifactId() ); - if ( !releaseDescriptor.getOriginalScmInfo().containsKey( parentId ) ) + if ( releaseDescriptor.getOriginalScmInfo( parentId ) == null ) { // we need to add it, since it has changed from the inherited value scmRoot = new Scm(); @@ -244,31 +237,21 @@ private boolean translateScm( MavenProject project, ReleaseDescriptor releaseDes } @Override - protected Map getOriginalVersionMap( ReleaseDescriptor releaseDescriptor, - List reactorProjects, boolean simulate ) + protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate ) { - return releaseDescriptor.getOriginalVersions( reactorProjects ); + return releaseDescriptor.getProjectOriginalVersion( projectKey ); } @Override - protected Map getNextVersionMap( ReleaseDescriptor releaseDescriptor ) + protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key ) { - return releaseDescriptor.getReleaseVersions(); + return releaseDescriptor.getProjectReleaseVersion( key ); } @Override protected String getResolvedSnapshotVersion( String artifactVersionlessKey, - Map> resolvedSnapshotsMap ) + ReleaseDescriptor releaseDescriptor ) { - Map versionsMap = resolvedSnapshotsMap.get( artifactVersionlessKey ); - - if ( versionsMap != null ) - { - return versionsMap.get( ReleaseDescriptor.RELEASE_KEY ); - } - else - { - return null; - } + return releaseDescriptor.getDependencyReleaseVersion( artifactVersionlessKey ); } } diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java index 01bd7ef95..cb65866d2 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhase.java @@ -19,9 +19,6 @@ * under the License. */ -import java.util.List; -import java.util.Map; - import org.apache.maven.model.Model; import org.apache.maven.model.Scm; import org.apache.maven.project.MavenProject; @@ -59,9 +56,8 @@ protected void transformScm( MavenProject project, Model modelTarget, ReleaseDes Scm scmRoot = modelTarget.getScm(); if ( scmRoot != null ) { - Map originalScmInfo = releaseDescriptor.getOriginalScmInfo(); // check containsKey, not == null, as we store null as a value - if ( !originalScmInfo.containsKey( projectId ) ) + if ( releaseDescriptor.getOriginalScmInfo( projectId ) == null ) { throw new ReleaseExecutionException( "Unable to find original SCM info for '" + project.getName() + "'" ); @@ -70,7 +66,7 @@ protected void transformScm( MavenProject project, Model modelTarget, ReleaseDes ScmTranslator translator = getScmTranslators().get( scmRepository.getProvider() ); if ( translator != null ) { - Scm scm = originalScmInfo.get( projectId ); + Scm scm = releaseDescriptor.getOriginalScmInfo( projectId ); if ( scm != null ) { @@ -96,33 +92,23 @@ protected void transformScm( MavenProject project, Model modelTarget, ReleaseDes } @Override - protected Map getOriginalVersionMap( ReleaseDescriptor releaseDescriptor, - List reactorProjects, boolean simulate ) + protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate ) { return simulate - ? releaseDescriptor.getOriginalVersions( reactorProjects ) - : releaseDescriptor.getReleaseVersions(); + ? releaseDescriptor.getProjectOriginalVersion( projectKey ) + : releaseDescriptor.getProjectReleaseVersion( projectKey ); } @Override - protected Map getNextVersionMap( ReleaseDescriptor releaseDescriptor ) + protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key ) { - return releaseDescriptor.getDevelopmentVersions(); + return releaseDescriptor.getProjectDevelopmentVersion( key ); } @Override protected String getResolvedSnapshotVersion( String artifactVersionlessKey, - Map> resolvedSnapshotsMap ) + ReleaseDescriptor releaseDescriptor ) { - Map versionsMap = resolvedSnapshotsMap.get( artifactVersionlessKey ); - - if ( versionsMap != null ) - { - return versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ); - } - else - { - return null; - } + return releaseDescriptor.getDependencyDevelopmentVersion( artifactVersionlessKey ); } } diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java index 6e2b47e63..dc774a190 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhase.java @@ -20,8 +20,6 @@ */ import java.io.IOException; -import java.util.List; -import java.util.Map; import org.apache.maven.artifact.ArtifactUtils; import org.apache.maven.model.Model; @@ -62,9 +60,6 @@ protected void transformScm( MavenProject project, Model modelTarget, ReleaseDes Scm scmRoot = modelTarget.getScm(); if ( scmRoot != null ) { - Scm scm = buildScm( project ); - releaseDescriptor.mapOriginalScmInfo( projectId, scm ); - try { translateScm( project, releaseDescriptor, scmRoot, scmRepository, result, commonBasedir ); @@ -76,15 +71,13 @@ protected void transformScm( MavenProject project, Model modelTarget, ReleaseDes } else { - releaseDescriptor.mapOriginalScmInfo( projectId, null ); - MavenProject parent = project.getParent(); if ( parent != null ) { // If the SCM element is not present, only add it if the parent was not mapped (ie, it's external to // the release process and so has not been modified, so the values will not be correct on the tag), String parentId = ArtifactUtils.versionlessKey( parent.getGroupId(), parent.getArtifactId() ); - if ( !releaseDescriptor.getOriginalScmInfo().containsKey( parentId ) ) + if ( releaseDescriptor.getOriginalScmInfo( parentId ) == null ) { // we need to add it, since it has changed from the inherited value Scm scmTarget = new Scm(); @@ -238,31 +231,21 @@ private boolean translateScm( MavenProject project, ReleaseDescriptor releaseDes } @Override - protected Map getOriginalVersionMap( ReleaseDescriptor releaseDescriptor, - List reactorProjects, boolean simulate ) + protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate ) { - return releaseDescriptor.getOriginalVersions( reactorProjects ); + return releaseDescriptor.getProjectOriginalVersion( projectKey ); } @Override - protected Map getNextVersionMap( ReleaseDescriptor releaseDescriptor ) + protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key ) { - return releaseDescriptor.getReleaseVersions(); + return releaseDescriptor.getProjectReleaseVersion( key ); } @Override protected String getResolvedSnapshotVersion( String artifactVersionlessKey, - Map> resolvedSnapshotsMap ) + ReleaseDescriptor releaseDescriptor ) { - Map versionsMap = resolvedSnapshotsMap.get( artifactVersionlessKey ); - - if ( versionsMap != null ) - { - return versionsMap.get( ReleaseDescriptor.RELEASE_KEY ); - } - else - { - return null; - } + return releaseDescriptor.getDependencyReleaseVersion( artifactVersionlessKey ); } } diff --git a/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java b/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java index ea76dbaae..00f2c1ed8 100644 --- a/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java +++ b/maven-release-manager/src/main/java/org/apache/maven/shared/release/util/ReleaseUtil.java @@ -34,6 +34,8 @@ import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.codehaus.plexus.interpolation.InterpolationException; import org.codehaus.plexus.interpolation.MapBasedValueSource; import org.codehaus.plexus.interpolation.ObjectBasedValueSource; @@ -188,10 +190,10 @@ public static ReleaseDescriptor createBasedirAlignedReleaseDescriptor( ReleaseDe String url = releaseDescriptor.getScmSourceUrl(); url = realignScmUrl( parentLevels, url ); - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setWorkingDirectory( basedir ); - descriptor.setScmSourceUrl( url ); - return descriptor; + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setWorkingDirectory( basedir ); + builder.setScmSourceUrl( url ); + return ReleaseUtils.buildReleaseDescriptor( builder ); } public static String getCommonBasedir( List reactorProjects ) diff --git a/maven-release-manager/src/main/mdo/release-descriptor.mdo b/maven-release-manager/src/main/mdo/release-descriptor.mdo index 619108733..4123d12fd 100644 --- a/maven-release-manager/src/main/mdo/release-descriptor.mdo +++ b/maven-release-manager/src/main/mdo/release-descriptor.mdo @@ -37,7 +37,7 @@ - ReleaseDescriptor + ModelloReleaseDescriptor 1.0.0+ @@ -241,6 +241,7 @@ checkoutDirectory 1.0.0+ String + target/checkout The directory where the tag will be checked out. @@ -534,71 +535,50 @@ 2.1.0+ > resolvedSnapshotDependencies; - - /** - * Field releaseVersions. - */ - private java.util.Map releaseVersions; + private java.util.Map resolvedSnapshotDependencies = new java.util.HashMap<>(); /** - * Field developmentVersions. + * Field projectVersions */ - private java.util.Map developmentVersions; + private java.util.Map projectVersions = new java.util.HashMap<>(); /** * Field originalScmInfo. */ - private java.util.Map originalScmInfo; + private java.util.Map originalScmInfo = new java.util.HashMap<>(); - /** - * Method getResolvedSnapshotDependencies. - * - * @return Map - */ - public java.util.Map> getResolvedSnapshotDependencies() + + java.util.Map getProjectVersions() { - if ( this.resolvedSnapshotDependencies == null ) - { - this.resolvedSnapshotDependencies = new java.util.HashMap<>(); - } - - return this.resolvedSnapshotDependencies; - } //-- java.util.Map> getResolvedSnapshotDependencies() + return projectVersions; + } - /** - * Set a map of resolved snapshot dependencies versions. - * - * @param resolvedSnapshotDependencies - */ - public void setResolvedSnapshotDependencies( java.util.Map> resolvedSnapshotDependencies ) + java.util.Map getOriginalScmInfo() { - this.resolvedSnapshotDependencies = resolvedSnapshotDependencies; - } //-- void setResolvedSnapshotDependencies( java.util.Map> ) - + return originalScmInfo; + } + /** - * Method getReleaseVersions. + * Method getResolvedSnapshotDependencies. * * @return Map */ - public java.util.Map getReleaseVersions() + java.util.Map getResolvedSnapshotDependencies() { - if ( this.releaseVersions == null ) - { - this.releaseVersions = new java.util.HashMap<>(); - } + return this.resolvedSnapshotDependencies; + } //-- java.util.Map getResolvedSnapshotDependencies() - return this.releaseVersions; - } //-- java.util.Map getReleaseVersions() + public String getProjectReleaseVersion( String projectId ) + { + if ( projectVersions.containsKey( projectId ) ) + { + return projectVersions.get( projectId ).getRelease(); + } + return null; + } /** * Method addReleaseVersion. @@ -606,25 +586,19 @@ * @param key * @param value */ - public void addReleaseVersion( String key, String value ) + public void addReleaseVersion( String projectId, String version ) { - getReleaseVersions().put( key, value ); + computeIfAbsent( projectVersions, projectId ).setRelease( version ); } //-- void addReleaseVersion( String, String ) - /** - * Method getDevelopmentVersions. - * - * @return Map - */ - public java.util.Map getDevelopmentVersions() + public String getProjectDevelopmentVersion( String projectId ) { - if ( this.developmentVersions == null ) - { - this.developmentVersions = new java.util.HashMap<>(); - } - - return this.developmentVersions; - } //-- java.util.Map getDevelopmentVersions() + if ( projectVersions.containsKey( projectId ) ) + { + return projectVersions.get( projectId ).getDevelopment(); + } + return null; + } /** * Method addDevelopmentVersion. @@ -632,9 +606,9 @@ * @param key * @param value */ - public void addDevelopmentVersion( String key, String value ) + public void addDevelopmentVersion( String projectId, String version ) { - getDevelopmentVersions().put( key, value ); + computeIfAbsent( projectVersions, projectId ).setDevelopment( version ); } //-- void addDevelopmentVersion( String, String ) /** @@ -642,14 +616,9 @@ * * @return Map */ - public java.util.Map getOriginalScmInfo() + public org.apache.maven.model.Scm getOriginalScmInfo( String id ) { - if ( this.originalScmInfo == null ) - { - this.originalScmInfo = new java.util.HashMap<>(); - } - - return this.originalScmInfo; + return this.originalScmInfo.get( id ); } //-- java.util.Map getOriginalScmInfo() /** @@ -663,139 +632,89 @@ getOriginalScmInfo().put( key, value ); } //-- void addOriginalScmInfo( String, org.apache.maven.model.Scm ) - /** - * Map a given snapshot dependency to a specified version from when it is released. - * - */ - public void mapResolvedSnapshotDependencies( String artifactName, String releaseVersion, String developmentVersion ) + public String getProjectOriginalVersion( String projectId ) { - if ( resolvedSnapshotDependencies == null ) - { - resolvedSnapshotDependencies = new java.util.HashMap<>(); - } - else - { - assert !resolvedSnapshotDependencies.containsKey( artifactName ); - } - - java.util.Map versionsMap = new java.util.HashMap<>(); - - versionsMap.put( DEVELOPMENT_KEY, developmentVersion ); - versionsMap.put( RELEASE_KEY, releaseVersion ); - resolvedSnapshotDependencies.put( artifactName, versionsMap ); + if ( projectVersions.containsKey( projectId ) ) + { + return projectVersions.get( projectId ).getOriginal(); + } + return null; } - - /** - * Map a given project to a specified version from when it is released. - * - * @param projectId the project's group and artifact ID - * @param nextVersion the version to map to - */ - public void mapReleaseVersion( String projectId, String nextVersion ) + + public void addOriginalVersion( String projectId, String version ) { - if ( releaseVersions == null ) - { - releaseVersions = new java.util.HashMap<>(); - } - - releaseVersions.put( projectId, nextVersion ); + computeIfAbsent( projectVersions, projectId ).setOriginal( version ); } /** - * Map a given project to a specified version from when it is incremented and placed back into development. + * Retrieve the release version for the resolved snapshot dependency. * - * @param projectId the project's group and artifact ID - * @param nextVersion the version to map to */ - public void mapDevelopmentVersion( String projectId, String nextVersion ) + public String getDependencyDevelopmentVersion( String artifactConflictId ) { - if ( developmentVersions == null ) + if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) { - developmentVersions = new java.util.HashMap<>(); + ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId ); + return versionMap.getDevelopment(); } - - developmentVersions.put( projectId, nextVersion ); + return null; } /** - * Map a given project to a specified set of SCM information. + * Retrieve the release version for the resolved snapshot dependency. * - * @param projectId the project's group and artifact ID - * @param scm the original SCM information to store */ - public void mapOriginalScmInfo( String projectId, org.apache.maven.model.Scm scm ) + public String getDependencyReleaseVersion( String artifactConflictId ) { - if ( originalScmInfo == null ) - { - originalScmInfo = new java.util.HashMap<>(); - } - else + if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) { - assert !originalScmInfo.containsKey( projectId ); + ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId ); + return versionMap.getRelease(); } - - originalScmInfo.put( projectId, scm ); + return null; } /** - * A map of projects to original versions before any transformation. - */ - private java.util.Map originalVersions; - - /** - * Retrieve the original version map, before transformation, keyed by project's versionless identifier. - * - * @param reactorProjects The reactor projects. + * Retrieve the original version for the resolved snapshot dependency. * - * @return the map of project IDs to versions. */ - public synchronized java.util.Map getOriginalVersions( java.util.List reactorProjects ) + public String getDependencyOriginalVersion( String artifactConflictId ) { - if ( originalVersions == null ) + if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) { - originalVersions = new java.util.HashMap<>(); - for ( org.apache.maven.project.MavenProject project : reactorProjects ) - { - originalVersions.put( org.apache.maven.artifact.ArtifactUtils.versionlessKey( project.getGroupId(), - project.getArtifactId() ), project.getVersion() ); - } + ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId ); + return versionMap.getOriginal(); } - return originalVersions; + return null; } - - /** - * Retrieve the release version for the resolved snapshot dependency. - * - */ - public String getDependencyDevelopmentVersion( String artifactConflictId ) + + public void addDependencyOriginalVersion( String dependencyKey, String version ) { - if ( ( resolvedSnapshotDependencies == null ) && ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) ) - { - java.util.Map versionMap = resolvedSnapshotDependencies.get( artifactConflictId ); - return versionMap.get( DEVELOPMENT_KEY ); - } - return null; + computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setOriginal( version ); } - /** - * Retrieve the release version for the resolved snapshot dependency. - * - */ - public String getDependencyReleaseVersion( String artifactConflictId ) + public void addDependencyReleaseVersion( String dependencyKey, String version ) { - if ( ( resolvedSnapshotDependencies == null ) && ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) ) - { - java.util.Map versionMap = resolvedSnapshotDependencies.get( artifactConflictId ); - return versionMap.get( RELEASE_KEY ); - } - return null; + computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setRelease( version ); } - boolean safeEquals( String a, String b ) + public void addDependencyDevelopmentVersion( String dependencyKey, String version ) + { + computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setDevelopment( version ); + } + + private static ReleaseStageVersions computeIfAbsent( java.util.Map map, String key ) { - return a != null ? a.equals( b ) : b == null; + ReleaseStageVersions value = map.get( key ); + if ( value == null ) + { + value = new ReleaseStageVersions(); + map.put( key, value ); + } + return value; } + @Override public boolean equals( Object obj ) { if ( this == obj ) @@ -807,165 +726,148 @@ return false; } - ReleaseDescriptor that = (ReleaseDescriptor) obj; + ModelloReleaseDescriptor that = (ModelloReleaseDescriptor) obj; - if ( updateDependencies != that.updateDependencies || - useReleaseProfile != that.useReleaseProfile || - autoVersionSubmodules != that.autoVersionSubmodules || - snapshotReleasePluginAllowed != that.snapshotReleasePluginAllowed || - commitByProject != that.commitByProject || - branchCreation != that.branchCreation || - updateBranchVersions != that.updateBranchVersions || - updateWorkingCopyVersions != that.updateWorkingCopyVersions|| - suppressCommitBeforeTagOrBranch != that.suppressCommitBeforeTagOrBranch || - updateVersionsToSnapshot != that.updateVersionsToSnapshot || - allowTimestampedSnapshots != that.allowTimestampedSnapshots|| - remoteTagging != that.remoteTagging || - localCheckout != that.localCheckout || - pushChanges != that.pushChanges + if ( updateDependencies != that.isUpdateDependencies() || + useReleaseProfile != that.isUseReleaseProfile() || + autoVersionSubmodules != that.isAutoVersionSubmodules() || + snapshotReleasePluginAllowed != that.isSnapshotReleasePluginAllowed() || + commitByProject != that.isCommitByProject() || + branchCreation != that.isBranchCreation() || + updateBranchVersions != that.isUpdateBranchVersions() || + updateWorkingCopyVersions != that.isUpdateWorkingCopyVersions() || + suppressCommitBeforeTagOrBranch != that.isSuppressCommitBeforeTagOrBranch() || + updateVersionsToSnapshot != that.isUpdateVersionsToSnapshot() || + allowTimestampedSnapshots != that.isAllowTimestampedSnapshots() || + remoteTagging != that.isRemoteTagging() || + localCheckout != that.isLocalCheckout() || + pushChanges != that.isPushChanges() ) { return false; } - if ( !safeEquals( defaultDevelopmentVersion, that.defaultDevelopmentVersion ) || - !safeEquals( scmRelativePathProjectDirectory, that.scmRelativePathProjectDirectory ) || - !safeEquals( checkoutDirectory, that.checkoutDirectory ) || - !safeEquals( performGoals, that.performGoals ) || - !safeEquals( defaultReleaseVersion, that.defaultReleaseVersion ) || - !safeEquals( scmReleasedPomRevision, that.scmReleasedPomRevision ) + if ( !java.util.Objects.equals( defaultDevelopmentVersion, that.getDefaultDevelopmentVersion() ) || + !java.util.Objects.equals( scmRelativePathProjectDirectory, that.getScmRelativePathProjectDirectory() ) || + !java.util.Objects.equals( checkoutDirectory, that.getCheckoutDirectory() ) || + !java.util.Objects.equals( performGoals, that.getPerformGoals() ) || + !java.util.Objects.equals( defaultReleaseVersion, that.getDefaultReleaseVersion() ) || + !java.util.Objects.equals( scmReleasedPomRevision, that.getScmReleasedPomRevision() ) ) { return false; } - if ( addSchema != that.addSchema ) + if ( addSchema != that.isAddSchema() ) { return false; } - if ( generateReleasePoms != that.generateReleasePoms ) + if ( generateReleasePoms != that.isGenerateReleasePoms() ) { return false; } - if ( interactive != that.interactive ) + if ( interactive != that.isInteractive() ) { return false; } - if ( scmUseEditMode != that.scmUseEditMode ) + if ( scmUseEditMode != that.isScmUseEditMode() ) { return false; } - if ( !safeEquals( completedPhase, that.completedPhase ) ) + if ( !java.util.Objects.equals( completedPhase, that.getCompletedPhase() ) ) { return false; } if ( ( checkModificationExcludes == null || ( checkModificationExcludes != null && checkModificationExcludes.size() == 0) ) && - ( that.checkModificationExcludes == null || ( that.checkModificationExcludes != null && that.checkModificationExcludes.size() == 0) ) ) - { - // Do nothing. This is a Modello workaround - } - else - { - if ( checkModificationExcludes != null ? !checkModificationExcludes.equals( that.checkModificationExcludes ) - : that.checkModificationExcludes != null ) - { - return false; - } - } - if ( ( developmentVersions == null || ( developmentVersions != null && developmentVersions.size() == 0) ) && - ( that.developmentVersions == null || ( that.developmentVersions != null && that.developmentVersions.size() == 0) ) ) + ( that.getCheckModificationExcludes() == null || ( that.getCheckModificationExcludes() != null && that.getCheckModificationExcludes().size() == 0) ) ) { // Do nothing. This is a Modello workaround } else { - if ( developmentVersions != null ? !developmentVersions.equals( that.developmentVersions ) - : that.developmentVersions != null ) + if ( checkModificationExcludes != null ? !checkModificationExcludes.equals( that.getCheckModificationExcludes() ) + : that.getCheckModificationExcludes() != null ) { return false; } } if ( ( originalScmInfo == null || (originalScmInfo != null && originalScmInfo.size() == 0 ) ) && - ( that.originalScmInfo == null || ( that.originalScmInfo != null && that.originalScmInfo.size() == 0 ) ) ) + ( that.getOriginalScmInfo() == null || ( that.getOriginalScmInfo() != null && that.getOriginalScmInfo().size() == 0 ) ) ) { // Do nothing. This is a Modello workaround } else { - if ( originalScmInfo != null ? !compareScmCollections( that.originalScmInfo ) : that.originalScmInfo != null ) + if ( originalScmInfo != null ? !compareScmCollections( that.getOriginalScmInfo() ) : that.getOriginalScmInfo() != null ) { return false; } } - if ( ( releaseVersions == null || ( releaseVersions != null && releaseVersions.size() == 0 ) ) && - ( that.releaseVersions == null || ( that.releaseVersions != null && that.releaseVersions.size() == 0 ) ) ) + if ( !java.util.Objects.equals( additionalArguments, that.getAdditionalArguments() ) ) { - // Do nothing. This is a Modello workaround + return false; } - else + if ( !java.util.Objects.equals( preparationGoals, that.getPreparationGoals() ) ) { - if ( releaseVersions != null ? !releaseVersions.equals( that.releaseVersions ) : that.releaseVersions != null ) - { - return false; - } + return false; } - if ( !safeEquals( additionalArguments, that.additionalArguments ) ) + if ( !java.util.Objects.equals( completionGoals, that.getCompletionGoals() ) ) { return false; } - if ( !safeEquals( preparationGoals, that.preparationGoals ) ) + if ( !java.util.Objects.equals( pomFileName, that.getPomFileName() ) ) { return false; } - if ( !safeEquals( completionGoals, that.completionGoals ) ) + if ( !java.util.Objects.equals( scmPrivateKeyPassPhrase, that.getScmPrivateKeyPassPhrase() ) ) { return false; } - if ( !safeEquals( pomFileName, that.pomFileName ) ) + if ( !java.util.Objects.equals( scmPassword, that.getScmPassword() ) ) { return false; } - if ( !safeEquals( scmPrivateKeyPassPhrase, that.scmPrivateKeyPassPhrase ) ) + if ( !java.util.Objects.equals( scmPrivateKey, that.getScmPrivateKey() ) ) { return false; } - if ( !safeEquals( scmPassword, that.scmPassword ) ) + if ( !java.util.Objects.equals( scmReleaseLabel, that.getScmReleaseLabel() ) ) { return false; } - if ( !safeEquals( scmPrivateKey, that.scmPrivateKey ) ) + if ( !java.util.Objects.equals( scmTagBase, that.getScmTagBase() ) ) { return false; } - if ( !safeEquals( scmReleaseLabel, that.scmReleaseLabel ) ) + if ( !java.util.Objects.equals( scmBranchBase, that.getScmBranchBase() ) ) { return false; } - if ( !safeEquals( scmTagBase, that.scmTagBase ) ) + if ( !java.util.Objects.equals( scmId, that.getScmId() ) ) { return false; } - if ( !safeEquals( scmBranchBase, that.scmBranchBase ) ) + if ( !java.util.Objects.equals( scmSourceUrl, that.getScmSourceUrl() ) ) { return false; } - if ( !safeEquals( scmId, that.scmId ) ) + if ( !java.util.Objects.equals( scmUsername, that.getScmUsername() ) ) { return false; } - if ( !safeEquals( scmSourceUrl, that.scmSourceUrl ) ) + if ( !java.util.Objects.equals( workingDirectory, that.getWorkingDirectory() ) ) { return false; } - if ( !safeEquals( scmUsername, that.scmUsername ) ) + if ( !java.util.Objects.equals( scmTagNameFormat, that.getScmTagNameFormat() ) ) { return false; } - if ( !safeEquals( workingDirectory, that.workingDirectory ) ) + if ( !java.util.Objects.equals( scmTagNameFormat, that.getScmTagNameFormat() ) ) { return false; } - if ( !safeEquals( scmTagNameFormat, that.scmTagNameFormat ) ) + if ( !java.util.Objects.deepEquals( projectVersions, that.getProjectVersions() ) ) { return false; } @@ -973,7 +875,7 @@ return true; } - private boolean compareScmCollections( java.util.Map that ) + private boolean compareScmCollections( java.util.Map that ) { // Must manually compare as Scm doesn't have an equals method if ( that == null && originalScmInfo == null ) @@ -991,13 +893,13 @@ return false; } - for ( java.util.Iterator i = originalScmInfo.entrySet().iterator(); i.hasNext(); ) + for ( java.util.Iterator> i = originalScmInfo.entrySet().iterator(); i.hasNext(); ) { - java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); + java.util.Map.Entry entry = i.next(); - org.apache.maven.model.Scm thatScm = (org.apache.maven.model.Scm) that.get( entry.getKey() ); + org.apache.maven.model.Scm thatScm = that.get( entry.getKey() ); - org.apache.maven.model.Scm thisScm = (org.apache.maven.model.Scm) entry.getValue(); + org.apache.maven.model.Scm thisScm = entry.getValue(); if ( thatScm == null && thisScm == null ) { return true; @@ -1044,51 +946,51 @@ return true; } + @Override public int hashCode() { - int result = completedPhase != null ? completedPhase.hashCode() : 0; - result = 29 * result + ( scmReleaseLabel != null ? scmReleaseLabel.hashCode() : 0 ); - result = 29 * result + ( additionalArguments != null ? additionalArguments.hashCode() : 0 ); - result = 29 * result + ( preparationGoals != null ? preparationGoals.hashCode() : 0 ); - result = 29 * result + ( completionGoals != null ? completionGoals.hashCode() : 0 ); - result = 29 * result + ( pomFileName != null ? pomFileName.hashCode() : 0 ); - result = 29 * result + ( checkModificationExcludes != null ? checkModificationExcludes.hashCode() : 0 ); - result = 29 * result + ( scmTagBase != null ? scmTagBase.hashCode() : 0 ); - result = 29 * result + ( scmBranchBase != null ? scmBranchBase.hashCode() : 0 ); - result = 29 * result + ( scmUsername != null ? scmUsername.hashCode() : 0 ); - result = 29 * result + ( scmPassword != null ? scmPassword.hashCode() : 0 ); - result = 29 * result + ( scmId != null ? scmId.hashCode() : 0 ); - result = 29 * result + ( scmSourceUrl != null ? scmSourceUrl.hashCode() : 0 ); - result = 29 * result + ( scmPrivateKey != null ? scmPrivateKey.hashCode() : 0 ); - result = 29 * result + ( scmPrivateKeyPassPhrase != null ? scmPrivateKeyPassPhrase.hashCode() : 0 ); - result = 29 * result + ( workingDirectory != null ? workingDirectory.hashCode() : 0 ); - result = 29 * result + ( scmUseEditMode ? 1 : 0 ); - result = 29 * result + ( addSchema ? 1 : 0 ); - result = 29 * result + ( generateReleasePoms ? 1 : 0 ); - result = 29 * result + ( interactive ? 1 : 0 ); - result = 29 * result + ( releaseVersions != null ? releaseVersions.hashCode() : 0 ); - result = 29 * result + ( developmentVersions != null ? developmentVersions.hashCode() : 0 ); - result = 29 * result + ( originalScmInfo != null ? originalScmInfo.hashCode() : 0 ); - result = 29 * result + ( updateDependencies ? 1 : 0 ); - result = 29 * result + ( useReleaseProfile ? 1 : 0 ); - result = 29 * result + ( autoVersionSubmodules ? 1 : 0 ); - result = 29 * result + ( snapshotReleasePluginAllowed ? 1 : 0 ); - result = 29 * result + ( commitByProject ? 1 : 0 ); - result = 29 * result + ( branchCreation ? 1 : 0 ); - result = 29 * result + ( updateBranchVersions ? 1 : 0 ); - result = 29 * result + ( updateWorkingCopyVersions ? 1 : 0 ); - result = 29 * result + ( suppressCommitBeforeTagOrBranch ? 1 : 0 ); - result = 29 * result + ( updateVersionsToSnapshot ? 1 : 0 ); - result = 29 * result + ( allowTimestampedSnapshots ? 1 : 0 ); - result = 29 * result + ( remoteTagging ? 1 : 0 ); - result = 29 * result + ( localCheckout ? 1 : 0 ); - result = 29 * result + ( pushChanges ? 1 : 0 ); - result = 29 * result + ( defaultDevelopmentVersion != null ? defaultDevelopmentVersion.hashCode() : 0 ); - result = 29 * result + ( scmRelativePathProjectDirectory != null ? scmRelativePathProjectDirectory.hashCode() : 0 ); - result = 29 * result + ( checkoutDirectory != null ? checkoutDirectory.hashCode() : 0 ); - result = 29 * result + ( performGoals != null ? performGoals.hashCode() : 0 ); - result = 29 * result + ( defaultReleaseVersion != null ? defaultReleaseVersion.hashCode() : 0 ); - result = 29 * result + ( scmReleasedPomRevision != null ? scmReleasedPomRevision.hashCode() : 0 ); + int result = java.util.Objects.hashCode( completedPhase ); + result = 29 * result + java.util.Objects.hashCode( scmReleaseLabel ); + result = 29 * result + java.util.Objects.hashCode( additionalArguments ); + result = 29 * result + java.util.Objects.hashCode( preparationGoals ); + result = 29 * result + java.util.Objects.hashCode( completionGoals ); + result = 29 * result + java.util.Objects.hashCode( pomFileName ); + result = 29 * result + java.util.Objects.hashCode( checkModificationExcludes ); + result = 29 * result + java.util.Objects.hashCode( scmTagBase ); + result = 29 * result + java.util.Objects.hashCode( scmBranchBase ); + result = 29 * result + java.util.Objects.hashCode( scmUsername ); + result = 29 * result + java.util.Objects.hashCode( scmPassword ); + result = 29 * result + java.util.Objects.hashCode( scmId ); + result = 29 * result + java.util.Objects.hashCode( scmSourceUrl ); + result = 29 * result + java.util.Objects.hashCode( scmPrivateKey ); + result = 29 * result + java.util.Objects.hashCode( scmPrivateKeyPassPhrase ); + result = 29 * result + java.util.Objects.hashCode( workingDirectory ); + result = 29 * result + java.util.Objects.hashCode( scmUseEditMode ); + result = 29 * result + java.util.Objects.hashCode( addSchema ); + result = 29 * result + java.util.Objects.hashCode( generateReleasePoms ); + result = 29 * result + java.util.Objects.hashCode( interactive ); + result = 29 * result + java.util.Objects.hashCode( projectVersions ); + result = 29 * result + java.util.Objects.hashCode( originalScmInfo ); + result = 29 * result + java.util.Objects.hashCode( updateDependencies ); + result = 29 * result + java.util.Objects.hashCode( useReleaseProfile ); + result = 29 * result + java.util.Objects.hashCode( autoVersionSubmodules ); + result = 29 * result + java.util.Objects.hashCode( snapshotReleasePluginAllowed ); + result = 29 * result + java.util.Objects.hashCode( commitByProject ); + result = 29 * result + java.util.Objects.hashCode( branchCreation ); + result = 29 * result + java.util.Objects.hashCode( updateBranchVersions ); + result = 29 * result + java.util.Objects.hashCode( updateWorkingCopyVersions ); + result = 29 * result + java.util.Objects.hashCode( suppressCommitBeforeTagOrBranch ); + result = 29 * result + java.util.Objects.hashCode( updateVersionsToSnapshot ); + result = 29 * result + java.util.Objects.hashCode( allowTimestampedSnapshots ); + result = 29 * result + java.util.Objects.hashCode( remoteTagging ); + result = 29 * result + java.util.Objects.hashCode( localCheckout ); + result = 29 * result + java.util.Objects.hashCode( pushChanges ); + result = 29 * result + java.util.Objects.hashCode( defaultDevelopmentVersion ); + result = 29 * result + java.util.Objects.hashCode( scmRelativePathProjectDirectory ); + result = 29 * result + java.util.Objects.hashCode( checkoutDirectory ); + result = 29 * result + java.util.Objects.hashCode( performGoals ); + result = 29 * result + java.util.Objects.hashCode( defaultReleaseVersion ); + result = 29 * result + java.util.Objects.hashCode( scmReleasedPomRevision ); return result; } @@ -1096,5 +998,69 @@ + + ReleaseStageVersions + + + original + 3.0.0+ + String + + + release + 3.0.0+ + String + + + development + 3.0.0+ + String + + + + + 2.1.0+ + + + + diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java index d68f9f6f1..142d49beb 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/DefaultReleaseManagerTest.java @@ -32,6 +32,7 @@ import java.io.IOException; import java.util.Collections; import java.util.List; +import java.util.Properties; import org.apache.maven.project.MavenProject; import org.apache.maven.scm.CommandParameters; @@ -45,6 +46,7 @@ import org.apache.maven.scm.provider.ScmProviderStub; import org.apache.maven.scm.repository.ScmRepository; import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; import org.apache.maven.shared.release.config.ReleaseDescriptorStore; import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException; import org.apache.maven.shared.release.config.ReleaseDescriptorStoreStub; @@ -80,12 +82,13 @@ public void testPrepareNoCompletedPhase() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( null ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( null ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -105,12 +108,13 @@ public void testPrepareCompletedPhase() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( "step1" ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( "step1" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -130,14 +134,15 @@ public void testPrepareCompletedPhaseNoResume() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( "step1" ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( "step1" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); prepareRequest.setDryRun( false ); prepareRequest.setResume( false ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -157,12 +162,13 @@ public void testPrepareCompletedAllPhases() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( "step3" ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( "step3" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -182,12 +188,13 @@ public void testPrepareInvalidCompletedPhase() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( "foo" ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( "foo" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -207,14 +214,15 @@ public void testPrepareSimulateNoCompletedPhase() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( null ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( null ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); prepareRequest.setDryRun( true ); prepareRequest.setResume( true ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -234,14 +242,15 @@ public void testPrepareSimulateCompletedPhase() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( "step1" ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( "step1" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); prepareRequest.setDryRun( true ); prepareRequest.setResume( true ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -261,14 +270,15 @@ public void testPrepareSimulateCompletedAllPhases() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( "step3" ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( "step3" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); prepareRequest.setDryRun( true ); prepareRequest.setResume( true ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -288,14 +298,15 @@ public void testPrepareSimulateInvalidCompletedPhase() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration(); - releaseDescriptor.setCompletedPhase( "foo" ); + ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration(); + builder.setCompletedPhase( "foo" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); prepareRequest.setDryRun( true ); prepareRequest.setResume( true ); + prepareRequest.setUserProperties( new Properties() ); releaseManager.prepare( prepareRequest ); @@ -316,10 +327,11 @@ public void testPrepareUnknownPhaseConfigured() ReleaseManager releaseManager = lookup( ReleaseManager.class, "bad-phase-configured" ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setReleaseStrategyId( "foo" ); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setReleaseStrategyId( "foo" ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); + prepareRequest.setUserProperties( new Properties() ); try { @@ -336,20 +348,21 @@ public void testReleaseConfigurationStoreReadFailure() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" ); ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class ); - when( configStoreMock.read( releaseDescriptor ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ); + when( configStoreMock.read( builder ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ); releaseManager.setConfigStore( configStoreMock ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); + prepareRequest.setUserProperties( new Properties() ); // execute try @@ -364,7 +377,7 @@ public void testReleaseConfigurationStoreReadFailure() } // verify - verify( configStoreMock ).read( releaseDescriptor ); + verify( configStoreMock ).read( builder ); verifyNoMoreInteractions( configStoreMock ); } @@ -372,22 +385,24 @@ public void testReleaseConfigurationStoreWriteFailure() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" ); ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class ); - doThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ).when( configStoreMock ).write( releaseDescriptor ); + doThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ).when( configStoreMock ).write( any( ReleaseDescriptor.class) ); releaseManager.setConfigStore( configStoreMock ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( releaseDescriptor ); + prepareRequest.setReleaseDescriptorBuilder( builder ); prepareRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); prepareRequest.setDryRun( false ); prepareRequest.setResume( false ); + prepareRequest.setUserProperties( new Properties() ); + // execute try @@ -402,7 +417,7 @@ public void testReleaseConfigurationStoreWriteFailure() } // verify - verify( configStoreMock ).write( releaseDescriptor ) ; + verify( configStoreMock ).write( any( ReleaseDescriptor.class ) ) ; verifyNoMoreInteractions( configStoreMock ); } @@ -410,9 +425,9 @@ public void testReleaseConfigurationStoreClean() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" ); @@ -421,7 +436,7 @@ public void testReleaseConfigurationStoreClean() releaseManager.setConfigStore( configStoreMock ); ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest(); - cleanRequest.setReleaseDescriptor( releaseDescriptor ); + cleanRequest.setReleaseDescriptorBuilder( builder ); // execute releaseManager.clean( cleanRequest ); @@ -439,7 +454,7 @@ public void testReleaseConfigurationStoreClean() phase = (ReleasePhaseStub) lookup( ReleasePhase.class, "branch1" ); assertTrue( "branch1 not cleaned", phase.isCleaned() ); - verify( configStoreMock ).delete( releaseDescriptor ); + verify( configStoreMock ).delete( any( ReleaseDescriptor.class ) ); verifyNoMoreInteractions( configStoreMock ); } @@ -457,13 +472,13 @@ public void testReleasePerformWithResult() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( builder ); performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); performRequest.setReactorProjects( createReactorProjects() ); @@ -476,25 +491,25 @@ public void testReleaseConfigurationStoreReadFailureOnPerform() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" ); ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class ); - when( configStoreMock.read( releaseDescriptor ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ); + when( configStoreMock.read( builder ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ); releaseManager.setConfigStore( configStoreMock ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( builder ); performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); // execute try { - releaseDescriptor.setUseReleaseProfile( false ); + builder.setUseReleaseProfile( false ); releaseManager.perform( performRequest ); fail( "Should have failed to read configuration" ); @@ -506,30 +521,30 @@ public void testReleaseConfigurationStoreReadFailureOnPerform() } // verify - verify( configStoreMock ).read( releaseDescriptor ); + verify( configStoreMock ).read( builder ); verifyNoMoreInteractions( configStoreMock ); } public void testReleasePerformWithIncompletePrepare() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.class, "test" ); ReleaseDescriptorStoreStub configStore = new ReleaseDescriptorStoreStub(); - releaseDescriptor.setCompletedPhase( "scm-tag" ); + builder.setCompletedPhase( "scm-tag" ); releaseManager.setConfigStore( configStore ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( builder ); performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); try { - releaseDescriptor.setUseReleaseProfile( false ); + builder.setUseReleaseProfile( false ); releaseManager.perform( performRequest ); fail( "Should have failed to perform" ); @@ -553,10 +568,10 @@ public void testPerformWithDefaultClean() ReleaseManagerListener managerListener = mock( ReleaseManagerListener.class ); performRequest.setReleaseManagerListener( managerListener ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); - performRequest.setReleaseDescriptor( releaseDescriptor ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() ); + performRequest.setReleaseDescriptorBuilder( builder ); ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); @@ -581,18 +596,18 @@ public void testPerformWithDefaultClean() public void testNoScmUrlPerform() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( builder ); performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); try { - releaseDescriptor.setUseReleaseProfile( false ); + builder.setUseReleaseProfile( false ); releaseManager.perform( performRequest ); @@ -610,10 +625,10 @@ public void testScmExceptionThrown() // prepare ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.checkOut( any( ScmRepository.class ), @@ -626,7 +641,7 @@ public void testScmExceptionThrown() stub.setScmProvider( scmProviderMock ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( builder ); performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); performRequest.setReactorProjects( createReactorProjects() ); @@ -653,19 +668,19 @@ public void testScmResultFailure() { ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); ScmProviderStub providerStub = - (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() ); + (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" ); providerStub.setCheckOutScmResult( new CheckOutScmResult( "", "", "", false ) ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( builder ); performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() ); performRequest.setReactorProjects( createReactorProjects() ); @@ -713,7 +728,7 @@ public void testRollbackCall() ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest(); - rollbackRequest.setReleaseDescriptor( configStore.getReleaseConfiguration() ); + rollbackRequest.setReleaseDescriptorBuilder( configStore.getReleaseConfiguration() ); releaseManager.rollback( rollbackRequest ); @@ -730,7 +745,8 @@ public void testUpdateVersionsCall() ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" ); ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest(); - updateVersionsRequest.setReleaseDescriptor( configStore.getReleaseConfiguration() ); + updateVersionsRequest.setReleaseDescriptorBuilder( configStore.getReleaseConfiguration() ); + updateVersionsRequest.setUserProperties( new Properties() ); releaseManager.updateVersions( updateVersionsRequest ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java index 0b93bbf6a..35903ce01 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/PropertiesReleaseDescriptorStoreTest.java @@ -1,5 +1,7 @@ package org.apache.maven.shared.release.config; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor; + /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file @@ -45,7 +47,7 @@ protected void setUp() { super.setUp(); store = (PropertiesReleaseDescriptorStore) lookup( ReleaseDescriptorStore.class, "properties" ); - secDispatcher = (SecDispatcher) lookup( SecDispatcher.class, "mng-4384" ); + secDispatcher = lookup( SecDispatcher.class, "mng-4384" ); } public void testReadFromFile() @@ -53,9 +55,9 @@ public void testReadFromFile() { File file = getTestFile( "target/test-classes/release.properties" ); - ReleaseDescriptor config = store.read( file ); + ReleaseDescriptor config = store.read( file ).build(); - ReleaseDescriptor expected = createExpectedReleaseConfiguration(); + ReleaseDescriptor expected = createExpectedReleaseConfiguration().build(); assertEquals( "check matches", expected, config ); } @@ -63,14 +65,14 @@ public void testReadFromFile() public void testReadFromFileUsingWorkingDirectory() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( AbstractReleaseTestCase.getPath( getTestFile( "target/test-classes" ) ) ); - ReleaseDescriptor config = store.read( releaseDescriptor ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setWorkingDirectory( AbstractReleaseTestCase.getPath( getTestFile( "target/test-classes" ) ) ); + ReleaseDescriptor config = store.read( builder ).build(); - ReleaseDescriptor expected = createExpectedReleaseConfiguration(); - expected.setWorkingDirectory( releaseDescriptor.getWorkingDirectory() ); + ReleaseDescriptorBuilder expected = createExpectedReleaseConfiguration(); + expected.setWorkingDirectory( builder.build().getWorkingDirectory() ); - assertEquals( "check matches", expected, config ); + assertEquals( "check matches", expected.build(), config ); } public void testReadFromEmptyFile() @@ -78,7 +80,7 @@ public void testReadFromEmptyFile() { File file = getTestFile( "target/test-classes/empty-release.properties" ); - ReleaseDescriptor config = store.read( file ); + BuilderReleaseDescriptor config = store.read( file ).build(); assertDefaultReleaseConfiguration( config ); } @@ -88,7 +90,7 @@ public void testReadMissingFile() { File file = getTestFile( "target/test-classes/no-release.properties" ); - ReleaseDescriptor config = store.read( file ); + BuilderReleaseDescriptor config = store.read( file ).build(); assertDefaultReleaseConfiguration( config ); } @@ -98,10 +100,10 @@ public void testMergeFromEmptyFile() { File file = getTestFile( "target/test-classes/empty-release.properties" ); - ReleaseDescriptor mergeDescriptor = createMergeConfiguration(); - ReleaseDescriptor config = store.read( mergeDescriptor, file ); + ReleaseDescriptorBuilder mergeDescriptor = createMergeConfiguration(); + ReleaseDescriptor config = store.read( mergeDescriptor, file ).build(); - assertEquals( "Check configurations merged", mergeDescriptor, config ); + assertEquals( "Check configurations merged", mergeDescriptor.build(), config ); } public void testMergeFromMissingFile() @@ -109,10 +111,10 @@ public void testMergeFromMissingFile() { File file = getTestFile( "target/test-classes/no-release.properties" ); - ReleaseDescriptor mergeDescriptor = createMergeConfiguration(); - ReleaseDescriptor config = store.read( mergeDescriptor, file ); + ReleaseDescriptorBuilder mergeDescriptor = createMergeConfiguration(); + ReleaseDescriptor config = store.read( mergeDescriptor, file ).build(); - assertEquals( "Check configurations merged", mergeDescriptor, config ); + assertEquals( "Check configurations merged", mergeDescriptor.build(), config ); } public void testWriteToNewFile() @@ -122,16 +124,16 @@ public void testWriteToNewFile() file.delete(); assertFalse( "Check file doesn't exist", file.exists() ); - ReleaseDescriptor config = createReleaseConfigurationForWriting(); + ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting(); - store.write( config, file ); + store.write( config.build(), file ); - ReleaseDescriptor rereadDescriptor = store.read( file ); + ReleaseDescriptor rereadDescriptor = store.read( file ).build(); assertAndAdjustScmPassword( config, rereadDescriptor ); assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptor ); - assertEquals( "compare configuration", config, rereadDescriptor ); + assertEquals( "compare configuration", config.build(), rereadDescriptor ); } public void testWriteToWorkingDirectory() @@ -142,18 +144,18 @@ public void testWriteToWorkingDirectory() assertFalse( "Check file doesn't exist", file.exists() ); file.getParentFile().mkdirs(); - ReleaseDescriptor config = createReleaseConfigurationForWriting(); + ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting(); config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) ); - store.write( config ); + store.write( config.build() ); - ReleaseDescriptor rereadDescriptor = store.read( file ); - rereadDescriptor.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) ); + ReleaseDescriptorBuilder rereadDescriptorBuilder = store.read( file ); + rereadDescriptorBuilder.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) ); - assertAndAdjustScmPassword( config, rereadDescriptor ); - assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptor ); + assertAndAdjustScmPassword( config, rereadDescriptorBuilder.build() ); + assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptorBuilder.build() ); - assertEquals( "compare configuration", config, rereadDescriptor ); + assertEquals( "compare configuration", config.build(), rereadDescriptorBuilder.build() ); } public void testWriteToNewFileRequiredOnly() @@ -163,15 +165,15 @@ public void testWriteToNewFileRequiredOnly() file.delete(); assertFalse( "Check file doesn't exist", file.exists() ); - ReleaseDescriptor config = new ReleaseDescriptor(); + ReleaseDescriptorBuilder config = new ReleaseDescriptorBuilder(); config.setCompletedPhase( "completed-phase-write" ); config.setScmSourceUrl( "url-write" ); - store.write( config, file ); + store.write( config.build(), file ); - ReleaseDescriptor rereadDescriptor = store.read( file ); + ReleaseDescriptor rereadDescriptor = store.read( file ).build(); - assertEquals( "compare configuration", config, rereadDescriptor ); + assertEquals( "compare configuration", config.build(), rereadDescriptor ); } public void testWriteToNewFileDottedIds() @@ -181,12 +183,12 @@ public void testWriteToNewFileDottedIds() file.delete(); assertFalse( "Check file doesn't exist", file.exists() ); - ReleaseDescriptor config = new ReleaseDescriptor(); + ReleaseDescriptorBuilder config = new ReleaseDescriptorBuilder(); config.setCompletedPhase( "completed-phase-write" ); config.setScmSourceUrl( "url-write" ); - config.mapReleaseVersion( "group.id:artifact.id", "1.1" ); - config.mapDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" ); + config.addReleaseVersion( "group.id:artifact.id", "1.1" ); + config.addDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" ); IdentifiedScm scm = new IdentifiedScm(); scm.setId( "id" ); @@ -194,13 +196,13 @@ public void testWriteToNewFileDottedIds() scm.setDeveloperConnection( "devConnection" ); scm.setTag( "tag" ); scm.setUrl( "url" ); - config.mapOriginalScmInfo( "group.id:artifact.id", scm ); + config.addOriginalScmInfo( "group.id:artifact.id", scm ); - store.write( config, file ); + store.write( config.build(), file ); - ReleaseDescriptor rereadDescriptor = store.read( file ); + ReleaseDescriptor rereadDescriptor = store.read( file ).build(); - assertEquals( "compare configuration", config, rereadDescriptor ); + assertEquals( "compare configuration", config.build(), rereadDescriptor ); } public void testWriteToNewFileNullMappedScm() @@ -210,23 +212,23 @@ public void testWriteToNewFileNullMappedScm() file.delete(); assertFalse( "Check file doesn't exist", file.exists() ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setCompletedPhase( "completed-phase-write" ); - config.setScmSourceUrl( "url-write" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletedPhase( "completed-phase-write" ); + builder.setScmSourceUrl( "url-write" ); - config.mapReleaseVersion( "group.id:artifact.id", "1.1" ); - config.mapDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" ); + builder.addReleaseVersion( "group.id:artifact.id", "1.1" ); + builder.addDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" ); - config.mapOriginalScmInfo( "group.id:artifact.id", null ); + builder.addOriginalScmInfo( "group.id:artifact.id", null ); - store.write( config, file ); + store.write( builder.build(), file ); - ReleaseDescriptor rereadDescriptor = store.read( file ); + ReleaseDescriptor rereadDescriptor = store.read( file ).build(); assertNull( "check null scm is mapped correctly", - rereadDescriptor.getOriginalScmInfo().get( "group.id:artifact.id" ) ); + rereadDescriptor.getOriginalScmInfo( "group.id:artifact.id" ) ); - assertEquals( "compare configuration", config, rereadDescriptor ); + assertEquals( "compare configuration", builder.build(), rereadDescriptor ); } public void testOverwriteFile() @@ -235,16 +237,16 @@ public void testOverwriteFile() File file = getTestFile( "target/test-classes/rewrite-release.properties" ); assertTrue( "Check file already exists", file.exists() ); - ReleaseDescriptor config = createReleaseConfigurationForWriting(); + ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting(); - store.write( config, file ); + store.write( config.build(), file ); - ReleaseDescriptor rereadDescriptor = store.read( file ); + ReleaseDescriptor rereadDescriptor = store.read( file ).build(); assertAndAdjustScmPassword( config, rereadDescriptor ); assertAndAdjustScmPrivateKeyPassPhrase( config, rereadDescriptor ); - assertEquals( "compare configuration", config, rereadDescriptor ); + assertEquals( "compare configuration", config.build(), rereadDescriptor ); } public void testDeleteFile() @@ -255,10 +257,10 @@ public void testDeleteFile() file.createNewFile(); assertTrue( "Check file already exists", file.exists() ); - ReleaseDescriptor config = createReleaseConfigurationForWriting(); + ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting(); config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) ); - store.delete( config ); + store.delete( config.build() ); assertFalse( "Check file already exists", file.exists() ); } @@ -271,35 +273,35 @@ public void testMissingDeleteFile() file.delete(); assertFalse( "Check file already exists", file.exists() ); - ReleaseDescriptor config = createReleaseConfigurationForWriting(); + ReleaseDescriptorBuilder config = createReleaseConfigurationForWriting(); config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) ); - store.delete( config ); + store.delete( config.build() ); assertFalse( "Check file already exists", file.exists() ); } - private ReleaseDescriptor createReleaseConfigurationForWriting() + private ReleaseDescriptorBuilder createReleaseConfigurationForWriting() { - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setCompletedPhase( "completed-phase-write" ); - config.setCommitByProject( true ); - config.setScmSourceUrl( "url-write" ); - config.setScmId( "id-write" ); - config.setScmUsername( "username-write" ); - config.setScmPassword( "password-write" ); - config.setScmPrivateKey( "private-key-write" ); - config.setScmPrivateKeyPassPhrase( "passphrase-write" ); - config.setScmTagBase( "tag-base-write" ); - config.setScmBranchBase( "branch-base-write" ); - config.setScmReleaseLabel( "tag-write" ); - config.setAdditionalArguments( "additional-args-write" ); - config.setPreparationGoals( "preparation-goals-write" ); - config.setCompletionGoals( "completion-goals-write" ); - config.setPomFileName( "pom-file-name-write" ); - - config.mapReleaseVersion( "groupId:artifactId", "1.0" ); - config.mapDevelopmentVersion( "groupId:artifactId", "1.1-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletedPhase( "completed-phase-write" ); + builder.setCommitByProject( true ); + builder.setScmSourceUrl( "url-write" ); + builder.setScmId( "id-write" ); + builder.setScmUsername( "username-write" ); + builder.setScmPassword( "password-write" ); + builder.setScmPrivateKey( "private-key-write" ); + builder.setScmPrivateKeyPassPhrase( "passphrase-write" ); + builder.setScmTagBase( "tag-base-write" ); + builder.setScmBranchBase( "branch-base-write" ); + builder.setScmReleaseLabel( "tag-write" ); + builder.setAdditionalArguments( "additional-args-write" ); + builder.setPreparationGoals( "preparation-goals-write" ); + builder.setCompletionGoals( "completion-goals-write" ); + builder.setPomFileName( "pom-file-name-write" ); + + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.addDevelopmentVersion( "groupId:artifactId", "1.1-SNAPSHOT" ); IdentifiedScm scm = new IdentifiedScm(); scm.setId( "id-write" ); @@ -307,17 +309,17 @@ private ReleaseDescriptor createReleaseConfigurationForWriting() scm.setDeveloperConnection( "developerConnection-write" ); scm.setUrl( "url-write" ); scm.setTag( "tag-write" ); - config.mapOriginalScmInfo( "groupId:artifactId", scm ); + builder.addOriginalScmInfo( "groupId:artifactId", scm ); scm = new IdentifiedScm(); scm.setConnection( "connection-write" ); // omit optional elements - config.mapOriginalScmInfo( "groupId:subproject1", scm ); + builder.addOriginalScmInfo( "groupId:subproject1", scm ); - return config; + return builder; } - private static void assertDefaultReleaseConfiguration( ReleaseDescriptor config ) + private static void assertDefaultReleaseConfiguration( BuilderReleaseDescriptor config ) { assertNull( "Expected no completedPhase", config.getCompletedPhase() ); assertFalse( "Expected no commitPerProject", config.isCommitByProject() ); @@ -340,16 +342,19 @@ private static void assertDefaultReleaseConfiguration( ReleaseDescriptor config assertTrue( "Expected default interactive", config.isInteractive() ); assertFalse( "Expected no addScema", config.isAddSchema() ); - assertTrue( "Expected no release version mappings", config.getReleaseVersions().isEmpty() ); - assertTrue( "Expected no dev version mappings", config.getDevelopmentVersions().isEmpty() ); + for ( ReleaseStageVersions versions : config.getProjectVersions().values() ) + { + assertNull( "Expected no release version mappings", versions.getRelease() ); + assertNull( "Expected no dev version mappings", versions.getDevelopment() ); + } assertTrue( "Expected no scm mappings", config.getOriginalScmInfo().isEmpty() ); assertNotNull( "Expected resolved snapshot dependencies map", config.getResolvedSnapshotDependencies() ); } - public ReleaseDescriptor createMergeConfiguration() + public ReleaseDescriptorBuilder createMergeConfiguration() throws IOException { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder(); releaseDescriptor.setScmSourceUrl( "scm-url" ); releaseDescriptor.setScmUsername( "username" ); @@ -360,10 +365,10 @@ public ReleaseDescriptor createMergeConfiguration() return releaseDescriptor; } - private void assertAndAdjustScmPassword( ReleaseDescriptor expected, ReleaseDescriptor original ) + private void assertAndAdjustScmPassword( ReleaseDescriptorBuilder expected, ReleaseDescriptor original ) throws Exception { - String expectedPassword = expected.getScmPassword(); + String expectedPassword = expected.build().getScmPassword(); String originalPassword = original.getScmPassword(); // encrypting the same password twice doesn't have to be the same result @@ -373,13 +378,13 @@ private void assertAndAdjustScmPassword( ReleaseDescriptor expected, ReleaseDesc expected.setScmPassword( originalPassword ); } - assertEquals( expected.getScmPassword(), original.getScmPassword() ); + assertEquals( expected.build().getScmPassword(), original.getScmPassword() ); } - private void assertAndAdjustScmPrivateKeyPassPhrase( ReleaseDescriptor expected, ReleaseDescriptor original ) + private void assertAndAdjustScmPrivateKeyPassPhrase( ReleaseDescriptorBuilder expected, ReleaseDescriptor original ) throws Exception { - String expectedPassPhrase = expected.getScmPrivateKeyPassPhrase(); + String expectedPassPhrase = expected.build().getScmPrivateKeyPassPhrase(); String originalPassPhrase = original.getScmPrivateKeyPassPhrase(); // encrypting the same passphrase twice doesn't have to be the same result @@ -389,54 +394,55 @@ private void assertAndAdjustScmPrivateKeyPassPhrase( ReleaseDescriptor expected, expected.setScmPrivateKeyPassPhrase( originalPassPhrase ); } - assertEquals( expected.getScmPrivateKeyPassPhrase(), original.getScmPrivateKeyPassPhrase() ); + assertEquals( expected.build().getScmPrivateKeyPassPhrase(), original.getScmPrivateKeyPassPhrase() ); } - private ReleaseDescriptor createExpectedReleaseConfiguration() + private ReleaseDescriptorBuilder createExpectedReleaseConfiguration() { - ReleaseDescriptor expected = new ReleaseDescriptor(); - expected.setCompletedPhase( "step1" ); - expected.setCommitByProject( true ); - expected.setScmId( "scm-id" ); - expected.setScmSourceUrl( "scm-url" ); - expected.setScmUsername( "username" ); - expected.setScmPassword( "password" ); - expected.setScmPrivateKey( "private-key" ); - expected.setScmPrivateKeyPassPhrase( "passphrase" ); - expected.setScmTagBase( "tagBase" ); - expected.setScmTagNameFormat( "expectedTagNameFormat" ); - expected.setScmBranchBase( "branchBase" ); - expected.setScmReleaseLabel( "tag" ); - expected.setAdditionalArguments( "additional-arguments" ); - expected.setPreparationGoals( "preparation-goals" ); - expected.setCompletionGoals( "completion-goals" ); - expected.setPomFileName( "pom-file-name" ); - expected.setWorkingDirectory( null ); - expected.setGenerateReleasePoms( false ); - expected.setScmUseEditMode( false ); - expected.setInteractive( true ); - expected.setAddSchema( false ); - expected.mapReleaseVersion( "groupId:artifactId1", "2.0" ); - expected.mapReleaseVersion( "groupId:artifactId2", "3.0" ); - expected.mapDevelopmentVersion( "groupId:artifactId1", "2.1-SNAPSHOT" ); - expected.mapDevelopmentVersion( "groupId:artifactId2", "3.0.1-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletedPhase( "step1" ); + builder.setCommitByProject( true ); + builder.setScmId( "scm-id" ); + builder.setScmSourceUrl( "scm-url" ); + builder.setScmUsername( "username" ); + builder.setScmPassword( "password" ); + builder.setScmPrivateKey( "private-key" ); + builder.setScmPrivateKeyPassPhrase( "passphrase" ); + builder.setScmTagBase( "tagBase" ); + builder.setScmTagNameFormat( "expectedTagNameFormat" ); + builder.setScmBranchBase( "branchBase" ); + builder.setScmReleaseLabel( "tag" ); + builder.setAdditionalArguments( "additional-arguments" ); + builder.setPreparationGoals( "preparation-goals" ); + builder.setCompletionGoals( "completion-goals" ); + builder.setPomFileName( "pom-file-name" ); + builder.setWorkingDirectory( null ); + builder.setGenerateReleasePoms( false ); + builder.setScmUseEditMode( false ); + builder.setInteractive( true ); + builder.setAddSchema( false ); + builder.addReleaseVersion( "groupId:artifactId1", "2.0" ); + builder.addReleaseVersion( "groupId:artifactId2", "3.0" ); + builder.addDevelopmentVersion( "groupId:artifactId1", "2.1-SNAPSHOT" ); + builder.addDevelopmentVersion( "groupId:artifactId2", "3.0.1-SNAPSHOT" ); IdentifiedScm scm = new IdentifiedScm(); scm.setId( "id" ); scm.setConnection( "connection" ); scm.setDeveloperConnection( "developerConnection" ); scm.setUrl( "url" ); scm.setTag( "tag" ); - expected.mapOriginalScmInfo( "groupId:artifactId1", scm ); + builder.addOriginalScmInfo( "groupId:artifactId1", scm ); scm = new IdentifiedScm(); scm.setId( null ); scm.setConnection( "connection2" ); scm.setUrl( "url2" ); scm.setTag( null ); scm.setDeveloperConnection( null ); - expected.mapOriginalScmInfo( "groupId:artifactId2", scm ); - expected.mapResolvedSnapshotDependencies( "external:artifactId", "1.0", "1.1-SNAPSHOT" ); + builder.addOriginalScmInfo( "groupId:artifactId2", scm ); + builder.addDependencyReleaseVersion( "external:artifactId", "1.0" ); + builder.addDependencyDevelopmentVersion( "external:artifactId", "1.1-SNAPSHOT" ); - return expected; + return builder; } } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java index 7470bd281..1352d288a 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseDescriptorStoreStub.java @@ -30,19 +30,17 @@ public class ReleaseDescriptorStoreStub /** * The release configuration to use. */ - private ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + private ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder(); @Override - public ReleaseDescriptor read( ReleaseDescriptor mergeDescriptor ) + public ReleaseDescriptorBuilder read( ReleaseDescriptorBuilder mergeDescriptor ) { - ReleaseUtils.merge( releaseDescriptor, mergeDescriptor ); - return releaseDescriptor; + return mergeDescriptor; } @Override public void write( ReleaseDescriptor config ) { - this.releaseDescriptor = config; } @Override @@ -50,7 +48,7 @@ public void delete( ReleaseDescriptor config ) { } - public ReleaseDescriptor getReleaseConfiguration() + public ReleaseDescriptorBuilder getReleaseConfiguration() { return releaseDescriptor; } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java index ea85a18cd..4cff313cb 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/config/ReleaseUtilsTest.java @@ -23,11 +23,11 @@ import org.apache.maven.artifact.ArtifactUtils; import org.apache.maven.model.Scm; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor; import org.apache.maven.shared.release.phase.AbstractReleaseTestCase; import java.io.File; import java.io.IOException; -import java.util.Map; import java.util.Properties; /** @@ -38,220 +38,171 @@ public class ReleaseUtilsTest extends TestCase { - public void testMergeConfigurationSourceEmpty() - throws IOException - { - ReleaseDescriptor mergeDescriptor = createReleaseDescriptor(); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor ); - ReleaseDescriptor mergedMergeDescriptor = ReleaseUtils.merge( mergeDescriptor, releaseDescriptor ); - - assertEquals( "Check merge", mergedReleaseDescriptor, mergedMergeDescriptor ); - } - - public void testMergeEqualsWithUpdateWorkingCopyTrue() - throws IOException - { - ReleaseDescriptor mergeDescriptor = createReleaseDescriptor(); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - - ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor ); - ReleaseDescriptor mergedMergeDescriptor = ReleaseUtils.merge( mergeDescriptor, releaseDescriptor ); - - assertEquals( "Check merge", mergedReleaseDescriptor, mergedMergeDescriptor ); - } - - public void testMergeConfigurationDestEmpty() - throws IOException - { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); - ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, new ReleaseDescriptor() ); - ReleaseDescriptor expectedDescriptor = copyReleaseDescriptor( mergedReleaseDescriptor ); - - assertEquals( "Check merge", expectedDescriptor, releaseDescriptor ); - } - - public void testMergeConfiguration() - throws IOException - { - File workingDirectory = new File( "." ); - - ReleaseDescriptor mergeDescriptor = - createMergeDescriptor( AbstractReleaseTestCase.getPath( workingDirectory ), "completed-phase-merge" ); - - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); - releaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor ); - - ReleaseDescriptor expected = - createMergeDescriptor( releaseDescriptor.getWorkingDirectory(), releaseDescriptor.getCompletedPhase() ); - assertEquals( "Check merge", expected, releaseDescriptor ); - } - public void testEquals() throws IOException { - ReleaseDescriptor originalReleaseDescriptor = createReleaseDescriptor(); - ReleaseDescriptor releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor ); - doEqualsAssertions( releaseDescriptor, originalReleaseDescriptor, "other", new File( "f" ) ); + ReleaseDescriptorBuilder originalReleaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = copyReleaseDescriptor( originalReleaseDescriptor.build() ); + doEqualsAssertions( builder, originalReleaseDescriptor, "other", new File( "f" ) ); originalReleaseDescriptor = createReleaseDescriptor(); - releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor ); - doEqualsAssertions( originalReleaseDescriptor, releaseDescriptor, "other", new File( "f" ) ); + builder = copyReleaseDescriptor( originalReleaseDescriptor.build() ); + doEqualsAssertions( originalReleaseDescriptor, builder, "other", new File( "f" ) ); originalReleaseDescriptor = createReleaseDescriptor(); - releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor ); - doEqualsAssertions( releaseDescriptor, originalReleaseDescriptor, null, null ); + builder = copyReleaseDescriptor( originalReleaseDescriptor.build() ); + doEqualsAssertions( builder, originalReleaseDescriptor, null, null ); originalReleaseDescriptor = createReleaseDescriptor(); - releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor ); - doEqualsAssertions( originalReleaseDescriptor, releaseDescriptor, null, null ); + builder = copyReleaseDescriptor( originalReleaseDescriptor.build() ); + doEqualsAssertions( originalReleaseDescriptor, builder, null, null ); - assertEquals( "test ==", releaseDescriptor, releaseDescriptor ); + assertEquals( "test ==", builder, builder ); Object obj = this; - assertFalse( "test class instance", releaseDescriptor.equals( obj ) ); + assertFalse( "test class instance", builder.equals( obj ) ); } - private static void doEqualsAssertions( ReleaseDescriptor releaseDescriptor, - ReleaseDescriptor originalReleaseDescriptor, String other, File otherFile ) + private static void doEqualsAssertions( ReleaseDescriptorBuilder releaseDescriptor, + ReleaseDescriptorBuilder originalReleaseDescriptor, String other, File otherFile ) throws IOException { - ReleaseDescriptor origConfig = originalReleaseDescriptor; - ReleaseDescriptor config = releaseDescriptor; - assertEquals( "Check original comparison", config, origConfig ); + BuilderReleaseDescriptor origConfig = originalReleaseDescriptor.build(); + ReleaseDescriptorBuilder configBuilder = releaseDescriptor; + assertEquals( "Check original comparison", configBuilder.build(), origConfig ); - config.setScmSourceUrl( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmSourceUrl( origConfig.getScmSourceUrl() ); + configBuilder.setScmSourceUrl( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmSourceUrl( origConfig.getScmSourceUrl() ); - config.setAdditionalArguments( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setAdditionalArguments( origConfig.getAdditionalArguments() ); + configBuilder.setAdditionalArguments( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setAdditionalArguments( origConfig.getAdditionalArguments() ); - config.setAddSchema( !origConfig.isAddSchema() ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setAddSchema( origConfig.isAddSchema() ); + configBuilder.setAddSchema( !origConfig.isAddSchema() ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setAddSchema( origConfig.isAddSchema() ); - config.setGenerateReleasePoms( !origConfig.isAddSchema() ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setGenerateReleasePoms( origConfig.isGenerateReleasePoms() ); + configBuilder.setGenerateReleasePoms( !origConfig.isAddSchema() ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setGenerateReleasePoms( origConfig.isGenerateReleasePoms() ); - config.setScmUseEditMode( !origConfig.isScmUseEditMode() ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmUseEditMode( origConfig.isScmUseEditMode() ); + configBuilder.setScmUseEditMode( !origConfig.isScmUseEditMode() ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmUseEditMode( origConfig.isScmUseEditMode() ); - config.setInteractive( !origConfig.isInteractive() ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setInteractive( origConfig.isInteractive() ); + configBuilder.setInteractive( !origConfig.isInteractive() ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setInteractive( origConfig.isInteractive() ); - config.setCommitByProject( !origConfig.isCommitByProject() ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setCommitByProject( origConfig.isCommitByProject() ); + configBuilder.setCommitByProject( !origConfig.isCommitByProject() ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setCommitByProject( origConfig.isCommitByProject() ); - config.setCompletedPhase( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setCompletedPhase( origConfig.getCompletedPhase() ); + configBuilder.setCompletedPhase( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setCompletedPhase( origConfig.getCompletedPhase() ); - config.setScmPrivateKeyPassPhrase( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmPrivateKeyPassPhrase( origConfig.getScmPrivateKeyPassPhrase() ); + configBuilder.setScmPrivateKeyPassPhrase( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmPrivateKeyPassPhrase( origConfig.getScmPrivateKeyPassPhrase() ); - config.setScmPassword( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmPassword( origConfig.getScmPassword() ); + configBuilder.setScmPassword( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmPassword( origConfig.getScmPassword() ); - config.setScmUsername( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmUsername( origConfig.getScmUsername() ); + configBuilder.setScmUsername( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmUsername( origConfig.getScmUsername() ); - config.setScmPrivateKey( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmPrivateKey( origConfig.getScmPrivateKey() ); + configBuilder.setScmPrivateKey( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmPrivateKey( origConfig.getScmPrivateKey() ); - config.setPomFileName( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setPomFileName( origConfig.getPomFileName() ); + configBuilder.setPomFileName( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setPomFileName( origConfig.getPomFileName() ); - config.setPreparationGoals( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setPreparationGoals( origConfig.getPreparationGoals() ); + configBuilder.setPreparationGoals( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setPreparationGoals( origConfig.getPreparationGoals() ); - config.setScmReleaseLabel( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmReleaseLabel( origConfig.getScmReleaseLabel() ); + configBuilder.setScmReleaseLabel( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmReleaseLabel( origConfig.getScmReleaseLabel() ); - config.setScmTagBase( other ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config.setScmTagBase( origConfig.getScmTagBase() ); + configBuilder.setScmTagBase( other ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder.setScmTagBase( origConfig.getScmTagBase() ); if ( otherFile != null ) { - config.setWorkingDirectory( AbstractReleaseTestCase.getPath( otherFile ) ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); + configBuilder.setWorkingDirectory( AbstractReleaseTestCase.getPath( otherFile ) ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); } - config.setWorkingDirectory( origConfig.getWorkingDirectory() ); + configBuilder.setWorkingDirectory( origConfig.getWorkingDirectory() ); // sanity check the test was resetting correctly - assertEquals( "Check original comparison", config, origConfig ); - - config.mapDevelopmentVersion( "groupId:artifactId", "1.0-SNAPSHOT" ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config = copyReleaseDescriptor( origConfig ); - - config.mapReleaseVersion( "groupId:artifactId", "1.0" ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", new Scm() ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", new Scm() ); - origConfig.mapOriginalScmInfo( "foo", new Scm() ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - origConfig = createReleaseDescriptor(); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", new Scm() ); - origConfig.mapOriginalScmInfo( "groupId:artifactId", new Scm() ); - assertEquals( "Check original comparison", config, origConfig ); - origConfig = createReleaseDescriptor(); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); - origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); - assertEquals( "Check original comparison", config, origConfig ); - origConfig = createReleaseDescriptor(); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", getScm( "-", "dev", "url", "tag" ) ); - origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - origConfig = createReleaseDescriptor(); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "-", "url", "tag" ) ); - origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - origConfig = createReleaseDescriptor(); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "-", "tag" ) ); - origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); - origConfig = createReleaseDescriptor(); - config = copyReleaseDescriptor( origConfig ); - - config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "-" ) ); - origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); - assertFalse( "Check original comparison", config.equals( origConfig ) ); + assertEquals( "Check original comparison", configBuilder.build(), origConfig ); + + configBuilder.addDevelopmentVersion( "groupId:artifactId", "1.0-SNAPSHOT" ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addReleaseVersion( "groupId:artifactId", "1.0" ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", new Scm() ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", new Scm() ); + origConfig.addOriginalScmInfo( "foo", new Scm() ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + origConfig = createReleaseDescriptor().build(); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", new Scm() ); + origConfig.addOriginalScmInfo( "groupId:artifactId", new Scm() ); + assertEquals( "Check original comparison", configBuilder.build(), origConfig ); + origConfig = createReleaseDescriptor().build(); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); + origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); + assertEquals( "Check original comparison", configBuilder.build(), origConfig ); + origConfig = createReleaseDescriptor().build(); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "-", "dev", "url", "tag" ) ); + origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + origConfig = createReleaseDescriptor().build(); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "-", "url", "tag" ) ); + origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + origConfig = createReleaseDescriptor().build(); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "-", "tag" ) ); + origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); + origConfig = createReleaseDescriptor().build(); + configBuilder = copyReleaseDescriptor( origConfig ); + + configBuilder.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "-" ) ); + origConfig.addOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) ); + assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) ); } public void testHashCode() throws IOException { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptor releaseDescriptor = createReleaseDescriptor().build(); assertEquals( "Check hash code", releaseDescriptor.hashCode(), - createReleaseDescriptor( releaseDescriptor.getWorkingDirectory() ).hashCode() ); + createReleaseDescriptor( releaseDescriptor.getWorkingDirectory() ).build().hashCode() ); } public void testLoadResolvedDependencies() @@ -260,11 +211,13 @@ public void testLoadResolvedDependencies() String dependencyKey = ArtifactUtils.versionlessKey( "com.groupId", "artifactId" ); properties.put( "dependency." + dependencyKey + ".release", "1.3" ); properties.put( "dependency." + dependencyKey + ".development", "1.3-SNAPSHOT" ); - ReleaseDescriptor descriptor = ReleaseUtils.copyPropertiesToReleaseDescriptor( properties ); + + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder ); + ReleaseDescriptor descriptor = builder.build(); - Map versionMap = descriptor.getResolvedSnapshotDependencies().get( dependencyKey ); - assertEquals( "1.3", versionMap.get( ReleaseDescriptor.RELEASE_KEY ) ); - assertEquals( "1.3-SNAPSHOT", versionMap.get( ReleaseDescriptor.DEVELOPMENT_KEY) ); + assertEquals( "1.3", descriptor.getDependencyReleaseVersion( dependencyKey ) ); + assertEquals( "1.3-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( dependencyKey ) ); } // MRELEASE-750 @@ -275,13 +228,13 @@ public void testArtifactIdEndswithDependency() properties.put( "dependency." + relDependencyKey + ".release", "1.3" ); String devDependencyKey = ArtifactUtils.versionlessKey( "com.development.magic", "dependency" ); properties.put( "dependency." + devDependencyKey + ".development", "1.3-SNAPSHOT" ); - ReleaseDescriptor descriptor = ReleaseUtils.copyPropertiesToReleaseDescriptor( properties ); - - Map versionMap = descriptor.getResolvedSnapshotDependencies().get( relDependencyKey ); - assertEquals( "1.3", versionMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder ); + ReleaseDescriptor descriptor = builder.build(); - versionMap = descriptor.getResolvedSnapshotDependencies().get( devDependencyKey ); - assertEquals( "1.3-SNAPSHOT", versionMap.get( ReleaseDescriptor.DEVELOPMENT_KEY) ); + assertEquals( "1.3", descriptor.getDependencyReleaseVersion( relDependencyKey ) ); + assertEquals( "1.3-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( devDependencyKey ) ); } // MRELEASE-834 @@ -289,10 +242,10 @@ public void testSystemPropertyStartingWithDependency() { Properties properties = new Properties(); properties.setProperty( "dependency.locations.enabled", "false" ); - ReleaseUtils.copyPropertiesToReleaseDescriptor( properties ); + ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, new ReleaseDescriptorBuilder() ); } - private static ReleaseDescriptor copyReleaseDescriptor( ReleaseDescriptor originalReleaseDescriptor ) + private static ReleaseDescriptorBuilder copyReleaseDescriptor( ReleaseDescriptor originalReleaseDescriptor ) { return createReleaseDescriptor( originalReleaseDescriptor.getWorkingDirectory() ); } @@ -307,25 +260,7 @@ private static Scm getScm( String connection, String developerConnection, String return scm; } - private static ReleaseDescriptor createMergeDescriptor( String workingDirectory, String completedPhase ) - { - ReleaseDescriptor mergeDescriptor = new ReleaseDescriptor(); - mergeDescriptor.setScmSourceUrl( "scm-url-merge" ); - mergeDescriptor.setCompletedPhase( completedPhase ); - mergeDescriptor.setScmPrivateKeyPassPhrase( "passphrase-merge" ); - mergeDescriptor.setScmPassword( "password-merge" ); - mergeDescriptor.setScmPrivateKey( "private-key-merge" ); - mergeDescriptor.setScmTagBase( "tag-base-merge" ); - mergeDescriptor.setScmReleaseLabel( "tag-merge" ); - mergeDescriptor.setScmUsername( "username-merge" ); - mergeDescriptor.setAdditionalArguments( "additional-arguments-merge" ); - mergeDescriptor.setPomFileName( "pom-file-name-merge" ); - mergeDescriptor.setPreparationGoals( "preparation-goals-merge" ); - mergeDescriptor.setWorkingDirectory( workingDirectory ); - return mergeDescriptor; - } - - private static ReleaseDescriptor createReleaseDescriptor() + private static ReleaseDescriptorBuilder createReleaseDescriptor() throws IOException { File workingDirectory = new File( "." ); @@ -333,9 +268,9 @@ private static ReleaseDescriptor createReleaseDescriptor() return createReleaseDescriptor(AbstractReleaseTestCase.getPath( workingDirectory ) ); } - private static ReleaseDescriptor createReleaseDescriptor( String workingDirectory ) + private static ReleaseDescriptorBuilder createReleaseDescriptor( String workingDirectory ) { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder(); releaseDescriptor.setScmSourceUrl( "scm-url" ); releaseDescriptor.setCompletedPhase( "completed-phase" ); releaseDescriptor.setScmPrivateKeyPassPhrase( "passphrase" ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java index 7ef8d6e82..8b655932a 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/ForkedMavenExecutorTest.java @@ -41,7 +41,6 @@ import org.apache.maven.settings.io.xpp3.SettingsXpp3Writer; import org.apache.maven.shared.release.ReleaseResult; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; -import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.codehaus.plexus.PlexusTestCase; import org.codehaus.plexus.util.cli.Arg; import org.codehaus.plexus.util.cli.CommandLineException; @@ -332,7 +331,7 @@ public void testEncryptSettings() proxy.setPassword( "proxy_password" ); settings.addProxy( proxy ); - ReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment(); + DefaultReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment(); releaseEnvironment.setSettings( settings ); AbstractMavenExecutor executorSpy = spy( executor ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java index 3f4789d64..57327e205 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/exec/InvokerMavenExecutorTest.java @@ -36,7 +36,6 @@ import org.apache.maven.shared.invoker.InvocationRequest; import org.apache.maven.shared.release.ReleaseResult; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; -import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.codehaus.plexus.PlexusTestCase; import org.codehaus.plexus.logging.Logger; import org.junit.Test; @@ -156,7 +155,7 @@ public void testEncryptSettings() proxy.setPassword( "proxy_password" ); settings.addProxy( proxy ); - ReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment(); + DefaultReleaseEnvironment releaseEnvironment = new DefaultReleaseEnvironment(); releaseEnvironment.setSettings( settings ); releaseEnvironment.setMavenHome( new File( System.getProperty( "injectedMavenHome" ) ) ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java index 9d510cc9f..9bc40d841 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractEditModeRewritingReleasePhaseTestCase.java @@ -41,7 +41,8 @@ import org.apache.maven.scm.repository.ScmRepository; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator; import org.apache.maven.shared.release.scm.ReleaseScmCommandException; @@ -66,11 +67,11 @@ public void testRewriteBasicPomWithEditMode() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.setScmUseEditMode( true ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.setScmUseEditMode( true ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -80,21 +81,21 @@ public void testRewriteBasicPomWithEditModeFailure() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.setScmUseEditMode( true ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.setScmUseEditMode( true ); + mapNextVersion( builder, "groupId:artifactId" ); ScmManagerStub scmManager = new ScmManagerStub(); DefaultScmRepositoryConfigurator configurator = (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.class, "default" ); configurator.setScmManager( scmManager ); - ScmProviderStub providerStub = (ScmProviderStub) scmManager.getProviderByUrl( config.getScmSourceUrl() ); + ScmProviderStub providerStub = (ScmProviderStub) scmManager.getProviderByUrl( ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() ); providerStub.setEditScmResult( new EditScmResult( "", "", "", false ) ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -110,9 +111,9 @@ public void testRewriteBasicPomWithEditModeException() { // prepare List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.setScmUseEditMode( true ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.setScmUseEditMode( true ); + mapNextVersion( builder, "groupId:artifactId" ); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.edit( isA( ScmRepository.class ), @@ -127,7 +128,7 @@ public void testRewriteBasicPomWithEditModeException() // execute try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -145,9 +146,9 @@ public void testRewritePomPluginDependencies() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-plugin-deps" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -157,11 +158,11 @@ public void testRewritePomUnmappedPluginDependencies() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-plugin-deps" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -176,9 +177,9 @@ public void testRewritePomProfile() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-profile" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -188,11 +189,11 @@ public void testRewritePomUnmappedProfile() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-profile" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java index 2deaf8b52..96eadcd17 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractReleaseTestCase.java @@ -57,6 +57,7 @@ import org.apache.maven.project.ProjectSorter; import org.apache.maven.repository.internal.MavenRepositorySystemSession; import org.apache.maven.shared.release.PlexusJUnit4TestCase; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; import org.apache.maven.shared.release.util.ReleaseUtil; import org.sonatype.aether.impl.internal.SimpleLocalRepositoryManager; import org.sonatype.aether.repository.WorkspaceReader; @@ -102,6 +103,16 @@ protected List createReactorProjects( String path, String subpath { return createReactorProjects( path, path, subpath ); } + + protected ReleaseDescriptorBuilder createReleaseDescriptorBuilder( List reactorProjects ) + { + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + for ( MavenProject project : reactorProjects ) + { + builder.putOriginalVersion( project.getGroupId() + ':' + project.getArtifactId(), project.getVersion() ); + } + return builder; + } /** * diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java index 903cf93e6..427371c1f 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractRewritingReleasePhaseTestCase.java @@ -40,7 +40,8 @@ import org.apache.maven.scm.repository.ScmRepositoryException; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; @@ -81,7 +82,7 @@ public void setUp() throws Exception { super.setUp(); - phase = (ReleasePhase) lookup( ReleasePhase.class, getRoleHint() ); + phase = lookup( ReleasePhase.class, getRoleHint() ); if( phase instanceof AbstractRewritePomsPhase) { @@ -96,10 +97,10 @@ public void testRewriteBasicPom() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -109,10 +110,10 @@ public void testRewriteBasicPomEntities() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-entities" ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -122,10 +123,10 @@ public void testRewriteBasicPomNamespace() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-namespace" ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -135,10 +136,10 @@ public void testRewriteBasicPomWithEncoding() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-encoding" ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -148,9 +149,9 @@ public void testRewritePomWithParent() throws Exception { List reactorProjects = createReactorProjects( "pom-with-parent" ); - ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); + ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -161,17 +162,17 @@ public void testRewritePomWithUnmappedParent() { List reactorProjects = createReactorProjects( "pom-with-parent" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); // Process the child first reactorProjects = new ArrayList<>( reactorProjects ); Collections.reverse( reactorProjects ); - mapAlternateNextVersion( config, "groupId:subproject1" ); + mapAlternateNextVersion( builder, "groupId:subproject1" ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -187,27 +188,27 @@ public void testRewritePomWithReleasedParent() { List reactorProjects = createReactorProjects( "pom-with-released-parent" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - mapAlternateNextVersion( config, "groupId:subproject1" ); - config.mapReleaseVersion( "groupId:artifactId", "1" ); - config.mapDevelopmentVersion( "groupId:artifactId", "1" ); + mapAlternateNextVersion( builder, "groupId:subproject1" ); + builder.addReleaseVersion( "groupId:artifactId", "1" ); + builder.addDevelopmentVersion( "groupId:artifactId", "1" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } - protected abstract void mapAlternateNextVersion( ReleaseDescriptor config, String projectId ); + protected abstract void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId ); @Test public void testRewritePomWithInheritedVersion() throws Exception { List reactorProjects = createReactorProjects( "pom-with-inherited-version" ); - ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects ); + ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -217,15 +218,15 @@ public void testRewritePomWithChangedInheritedVersion() throws Exception { List reactorProjects = createReactorProjects( "pom-with-inherited-version" ); - ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); + ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); MavenProject project = getProjectsAsMap( reactorProjects ).get( "groupId:subproject1" ); comparePomFiles( project, "-version-changed" ); } - protected abstract ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) + protected abstract ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) throws Exception; @Test @@ -233,10 +234,10 @@ public void testRewritePomDependencies() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-dependencies" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); - mapNextVersion( config, "groupId:subsubproject" ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); + mapNextVersion( builder, "groupId:subsubproject" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -246,11 +247,11 @@ public void testRewritePomUnmappedDependencies() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-dependencies" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -265,9 +266,9 @@ public void testRewritePomDependenciesDifferentVersion() throws Exception { List reactorProjects = createReactorProjects( "internal-differing-snapshot-dependencies" ); - ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -277,9 +278,9 @@ public void testRewriteManagedPomDependencies() throws Exception { List reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -289,11 +290,11 @@ public void testRewriteManagedPomUnmappedDependencies() throws Exception { List reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -308,9 +309,9 @@ public void testRewritePomPlugins() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-plugins" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -320,11 +321,11 @@ public void testRewritePomUnmappedPlugins() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-plugins" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -339,9 +340,9 @@ public void testRewritePomPluginsDifferentVersion() throws Exception { List reactorProjects = createReactorProjects( "internal-differing-snapshot-plugins" ); - ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -351,9 +352,9 @@ public void testRewriteManagedPomPlugins() throws Exception { List reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -363,11 +364,11 @@ public void testRewriteManagedPomUnmappedPlugins() throws Exception { List reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -382,9 +383,9 @@ public void testRewritePomReportPlugins() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -394,11 +395,11 @@ public void testRewritePomUnmappedReportPlugins() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -413,9 +414,9 @@ public void testRewritePomReportPluginsDifferentVersion() throws Exception { List reactorProjects = createReactorProjects( "internal-differing-snapshot-report-plugins" ); - ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -426,9 +427,9 @@ public void testRewritePomExtension() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-extension" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -439,11 +440,11 @@ public void testRewritePomUnmappedExtension() throws Exception { List reactorProjects = createReactorProjects( "internal-snapshot-extension" ); - ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -459,9 +460,9 @@ public void testRewritePomExtensionDifferentVersion() throws Exception { List reactorProjects = createReactorProjects( "internal-differing-snapshot-extension" ); - ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -472,9 +473,9 @@ public void testRewritePomExtensionUndefinedVersion() throws Exception { List reactorProjects = createReactorProjects( "pom-without-extension-version" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -490,11 +491,11 @@ public void testRewriteAddSchema() { String path = "basic-pom"; List reactorProjects = prepareReactorProjects( path, copyFiles ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); - config.setAddSchema( true ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); + builder.setAddSchema( true ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); comparePomFiles( reactorProjects, "-with-schema" ); @@ -510,9 +511,9 @@ public void testSimulateRewriteEditModeSkipped() { // prepare List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.setScmUseEditMode( true ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.setScmUseEditMode( true ); + mapNextVersion( builder, "groupId:artifactId" ); ScmProvider scmProviderMock = mock( ScmProvider.class ); @@ -523,7 +524,7 @@ public void testSimulateRewriteEditModeSkipped() scmManager.setScmProvider( scmProviderMock ); // execute - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verifyNoMoreInteractions( scmProviderMock ); @@ -534,11 +535,11 @@ public void testRewriteUnmappedPom() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -554,12 +555,12 @@ public void testRewriteBasicPomWithScmRepoException() { // prepare List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.setScmUseEditMode( true ); - config.setScmSourceUrl( "scm:svn:fail" ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.setScmUseEditMode( true ); + builder.setScmSourceUrl( "scm:svn:fail" ); + mapNextVersion( builder, "groupId:artifactId" ); - ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); + ScmManager scmManager = lookup( ScmManager.class ); if ( scmManager instanceof ScmManagerStub ) { ((ScmManagerStub) scmManager ).setException( new ScmRepositoryException( "..." ) ); @@ -567,7 +568,7 @@ public void testRewriteBasicPomWithScmRepoException() try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -583,10 +584,10 @@ public void testRewriteBasicPomWithNoSuchProviderException() { // prepare List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.setScmUseEditMode( true ); - config.setScmSourceUrl( "scm:fail:path" ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.setScmUseEditMode( true ); + builder.setScmSourceUrl( "scm:fail:path" ); + mapNextVersion( builder, "groupId:artifactId" ); ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); if ( scmManager instanceof ScmManagerStub ) @@ -597,7 +598,7 @@ public void testRewriteBasicPomWithNoSuchProviderException() // execute try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } @@ -613,10 +614,10 @@ public void testRewriteWhitespaceAroundValues() throws Exception { List reactorProjects = createReactorProjects( "whitespace-around-values" ); - ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); - mapNextVersion( config, "groupId:subproject2" ); + ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); + mapNextVersion( builder, "groupId:subproject2" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -626,10 +627,10 @@ public void testRewriteCommentsAroundValues() throws Exception { List reactorProjects = createReactorProjects( "comments-around-values" ); - ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); - mapNextVersion( config, "groupId:subproject2" ); + ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); + mapNextVersion( builder, "groupId:subproject2" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -639,10 +640,10 @@ public void testRewriteCDataAroundValues() throws Exception { List reactorProjects = createReactorProjects( "cdata-around-values" ); - ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); - mapNextVersion( config, "groupId:subproject2" ); + ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); + mapNextVersion( builder, "groupId:subproject2" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -652,25 +653,19 @@ public void testCleanNoProjects() throws Exception { // This occurs when it is release:perform run standalone. Just check there are no errors. - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); - config.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); - phase.clean( Collections.emptyList() ); - - assertTrue( true ); } - protected ReleaseDescriptor createUnmappedConfiguration( List reactorProjects ) + protected ReleaseDescriptorBuilder createUnmappedConfiguration( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - unmapNextVersion( config, "groupId:subproject1" ); - mapNextVersion( config, "groupId:subproject2" ); - mapNextVersion( config, "groupId:subproject3" ); - mapNextVersion( config, "groupId:artifactId" ); - return config; + unmapNextVersion( builder, "groupId:subproject1" ); + mapNextVersion( builder, "groupId:subproject2" ); + mapNextVersion( builder, "groupId:subproject3" ); + mapNextVersion( builder, "groupId:artifactId" ); + return builder; } protected List createReactorProjects( String path ) @@ -679,31 +674,31 @@ protected List createReactorProjects( String path ) return prepareReactorProjects( path, true ); } - protected ReleaseDescriptor createDefaultConfiguration( List reactorProjects ) + protected ReleaseDescriptorBuilder createDefaultConfiguration( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - mapNextVersion( config, "groupId:subproject4" ); - return config; + mapNextVersion( builder, "groupId:subproject4" ); + return builder; } - protected ReleaseDescriptor createMappedConfiguration( List reactorProjects ) + protected ReleaseDescriptorBuilder createMappedConfiguration( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects ); - mapNextVersion( config, "groupId:subproject3" ); - return config; + mapNextVersion( builder, "groupId:subproject3" ); + return builder; } - private ReleaseDescriptor createDifferingVersionConfiguration( List reactorProjects ) + private ReleaseDescriptorBuilder createDifferingVersionConfiguration( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects ); + ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects ); - mapNextVersion( config, "groupId:subproject2" ); - return config; + mapNextVersion( builder, "groupId:subproject2" ); + return builder; } protected List createReactorProjectsFromBasicPom() @@ -712,14 +707,14 @@ protected List createReactorProjectsFromBasicPom() return createReactorProjects( "basic-pom" ); } - protected abstract ReleaseDescriptor createConfigurationForWithParentNextVersion( List reactorProjects ) + protected abstract ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List reactorProjects ) throws Exception; - protected abstract void unmapNextVersion( ReleaseDescriptor config, String projectId ); + protected abstract void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId ); - protected abstract void mapNextVersion( ReleaseDescriptor config, String projectId ); + protected abstract void mapNextVersion( ReleaseDescriptorBuilder config, String projectId ); - protected ReleaseDescriptor createDescriptorFromBasicPom( List reactorProjects ) + protected ReleaseDescriptorBuilder createDescriptorFromBasicPom( List reactorProjects ) throws Exception { return createDescriptorFromProjects( reactorProjects ); @@ -733,9 +728,9 @@ public void testRewritePomDependenciesWithNamespace() throws Exception { List reactorProjects = createReactorProjects( "pom-with-namespace" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -748,21 +743,33 @@ protected void verifyReactorProjects( String path, boolean copyFiles ) { } - protected ReleaseDescriptor createDescriptorFromProjects( List reactorProjects ) + protected ReleaseDescriptorBuilder createDescriptorFromProjects( List reactorProjects ) + { + return createDescriptorFromProjects( new ReleaseDescriptorBuilder(), reactorProjects ); + } + + protected ReleaseDescriptorBuilder createDescriptorFromProjects( ReleaseDescriptorBuilder builder, List reactorProjects ) { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); + + for ( MavenProject project : reactorProjects ) + { + String key = project.getGroupId() + ':' + project.getArtifactId(); + builder.putOriginalVersion( key, project.getVersion() ); + builder.addOriginalScmInfo( key, project.getScm() ); + } + if ( rootProject.getScm() == null ) { - descriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo/trunk" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo/trunk" ); } else { - descriptor.setScmSourceUrl( rootProject.getScm().getConnection() ); + builder.setScmSourceUrl( rootProject.getScm().getConnection() ); } - descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); - return descriptor; + return builder; } } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java index 087ea96c7..3a6bbae2e 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/AbstractScmCommitPhaseTest.java @@ -27,7 +27,8 @@ import org.apache.maven.model.Model; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.junit.Test; public class AbstractScmCommitPhaseTest @@ -37,8 +38,9 @@ public void testDefaultCreatePomFiles() throws Exception { List files = - AbstractScmCommitPhase.createPomFiles( new ReleaseDescriptor(), - createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) ); + AbstractScmCommitPhase.createPomFiles( ReleaseUtils.buildReleaseDescriptor( new ReleaseDescriptorBuilder() ), + createProject( "artifactId", "1.0-SNAPSHOT", + new File( "pom.xml" ) ) ); assertEquals( "Number of created files", files.size(), 1 ); assertTrue( files.contains( new File( "pom.xml" ) ) ); } @@ -48,10 +50,10 @@ public void testDefaultCreatePomFiles() public void testCreatePomFilesSuppressCommitBeforeTag() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setSuppressCommitBeforeTagOrBranch( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setSuppressCommitBeforeTagOrBranch( true ); List files = - AbstractScmCommitPhase.createPomFiles( releaseDescriptor, + AbstractScmCommitPhase.createPomFiles( ReleaseUtils.buildReleaseDescriptor( builder ), createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) ); assertEquals( "Number of created files", files.size(), 1 ); assertTrue( files.contains( new File( "pom.xml" ) ) ); @@ -61,10 +63,10 @@ public void testCreatePomFilesSuppressCommitBeforeTag() public void testCreatePomFilesWithReleasePom() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setGenerateReleasePoms( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setGenerateReleasePoms( true ); List files = - AbstractScmCommitPhase.createPomFiles( releaseDescriptor, + AbstractScmCommitPhase.createPomFiles( ReleaseUtils.buildReleaseDescriptor( builder ), createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) ); assertEquals( "Number of created files", files.size(), 2 ); assertTrue( files.contains( new File( "pom.xml" ) ) ); @@ -75,11 +77,11 @@ public void testCreatePomFilesWithReleasePom() public void testCreatePomFilesWithReleasePomAndSuppressCommitBeforeTag() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setGenerateReleasePoms( true ); - releaseDescriptor.setSuppressCommitBeforeTagOrBranch( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setGenerateReleasePoms( true ); + builder.setSuppressCommitBeforeTagOrBranch( true ); List files = - AbstractScmCommitPhase.createPomFiles( releaseDescriptor, + AbstractScmCommitPhase.createPomFiles( ReleaseUtils.buildReleaseDescriptor( builder ), createProject( "artifactId", "1.0-SNAPSHOT", new File( "pom.xml" ) ) ); assertEquals( "Number of created files", files.size(), 1 ); assertTrue( files.contains( new File( "pom.xml" ) ) ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java index d0e69f8e5..1ff575f7c 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/BranchInputVariablesPhaseTest.java @@ -36,7 +36,8 @@ import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.PlexusJUnit4TestCase; import org.apache.maven.shared.release.ReleaseExecutionException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.codehaus.plexus.components.interactivity.Prompter; import org.codehaus.plexus.components.interactivity.PrompterException; @@ -71,26 +72,26 @@ public void testInputVariablesInteractive() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); verify( mockPrompter, times( 2 ) ).prompt( isA( String.class ) ); verifyNoMoreInteractions( mockPrompter ); @@ -102,11 +103,11 @@ public void testUnmappedVersion() { List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -115,11 +116,11 @@ public void testUnmappedVersion() assertNull( "check no cause", e.getCause() ); } - releaseDescriptor = new ReleaseDescriptor(); + builder = new ReleaseDescriptorBuilder(); try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -139,26 +140,26 @@ public void testInputVariablesNonInteractiveConfigured() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setScmReleaseLabel( "tag-value" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.setScmReleaseLabel( "tag-value" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.setScmReleaseLabel( "simulated-tag-value" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // never use prompter verifyNoMoreInteractions( mockPrompter ); @@ -174,24 +175,24 @@ public void testInputVariablesInteractiveConfigured() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmReleaseLabel( "tag-value" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmReleaseLabel( "tag-value" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" ); + builder = new ReleaseDescriptorBuilder(); + builder.setScmReleaseLabel( "simulated-tag-value" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // never use prompter verifyNoMoreInteractions( mockPrompter ); @@ -209,14 +210,14 @@ public void testPrompterException() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -226,14 +227,14 @@ public void testPrompterException() } // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -264,16 +265,16 @@ public void testEmptyBranchName() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setScmReleaseLabel( null ); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.setScmReleaseLabel( null ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -283,16 +284,16 @@ public void testEmptyBranchName() } // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setScmReleaseLabel( null ); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.setScmReleaseLabel( null ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -308,17 +309,17 @@ public void testEmptyBranchName() @Test public void testNamingPolicy() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setProjectNamingPolicyId( "stub" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setInteractive( false ); + builder.setProjectNamingPolicyId( "stub" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - assertEquals( "STUB", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "STUB", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); } private static MavenProject createProject( String artifactId, String version ) diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java index 81466d822..2b0edf66d 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckDependencySnapshotsPhaseTest.java @@ -31,13 +31,14 @@ import java.util.Arrays; import java.util.Collections; import java.util.List; -import java.util.Map; import java.util.Objects; import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.codehaus.plexus.components.interactivity.Prompter; import org.codehaus.plexus.components.interactivity.PrompterException; @@ -67,19 +68,19 @@ public void setUp() { super.setUp(); - phase = (ReleasePhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); + phase = lookup( ReleasePhase.class, "check-dependency-snapshots" ); } @Test public void testNoSnapshotDependencies() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();; List reactorProjects = createDescriptorFromProjects( "no-snapshot-dependencies" ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -92,16 +93,16 @@ public void testNoSnapshotRangeDependencies() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "no-snapshot-range-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.1", "1.2-SNAPSHOT" ) ) ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.1", "1.2-SNAPSHOT" ) ) ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -111,12 +112,12 @@ public void testNoSnapshotRangeDependencies() public void testSnapshotDependenciesInProjectOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -126,13 +127,13 @@ public void testSnapshotDependenciesInProjectOnly() public void testSnapshotReleasePluginNonInteractive() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); + builder.setInteractive( false ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -143,7 +144,7 @@ public void testSnapshotReleasePluginNonInteractive() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -160,14 +161,14 @@ public void testSnapshotReleasePluginInteractiveDeclined() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( NO, NO ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -180,7 +181,7 @@ public void testSnapshotReleasePluginInteractiveDeclined() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -197,12 +198,12 @@ public void testSnapshotReleasePluginInteractiveAcceptedForExecution() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createYesMockPrompter() ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( true ); } @@ -214,12 +215,12 @@ public void testSnapshotReleasePluginInteractiveAcceptedForSimulation() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createYesMockPrompter() ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( true ); } @@ -231,14 +232,14 @@ public void testSnapshotReleasePluginInteractiveInvalid() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( "donkey", NO ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -251,7 +252,7 @@ public void testSnapshotReleasePluginInteractiveInvalid() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -268,8 +269,8 @@ public void testSnapshotReleasePluginInteractiveException() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); Prompter mockPrompter = mock( Prompter.class ); when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ), @@ -278,7 +279,7 @@ public void testSnapshotReleasePluginInteractiveException() try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -293,7 +294,7 @@ public void testSnapshotReleasePluginInteractiveException() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -310,14 +311,14 @@ public void testSnapshotDependenciesInProjectOnlyMismatchedVersion() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-differing-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -330,7 +331,7 @@ public void testSnapshotDependenciesInProjectOnlyMismatchedVersion() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -344,12 +345,12 @@ public void testSnapshotDependenciesInProjectOnlyMismatchedVersion() public void testSnapshotManagedDependenciesInProjectOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-managed-snapshot-dependency" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -359,13 +360,13 @@ public void testSnapshotManagedDependenciesInProjectOnly() public void testSnapshotUnusedInternalManagedDependency() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "unused-internal-managed-snapshot-dependency" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -375,13 +376,13 @@ public void testSnapshotUnusedInternalManagedDependency() public void testSnapshotUnusedExternalManagedDependency() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "unused-external-managed-snapshot-dependency" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -391,14 +392,14 @@ public void testSnapshotUnusedExternalManagedDependency() public void testSnapshotExternalManagedDependency() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-managed-snapshot-dependency" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - releaseDescriptor.setInteractive( false ); + builder.setInteractive( false ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -409,7 +410,7 @@ public void testSnapshotExternalManagedDependency() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -423,14 +424,14 @@ public void testSnapshotExternalManagedDependency() public void testSnapshotDependenciesOutsideProjectOnlyNonInteractive() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - releaseDescriptor.setInteractive( false ); + builder.setInteractive( false ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -441,7 +442,7 @@ public void testSnapshotDependenciesOutsideProjectOnlyNonInteractive() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -455,14 +456,14 @@ public void testSnapshotDependenciesOutsideProjectOnlyNonInteractive() public void testRangeSnapshotDependenciesOutsideProjectOnlyNonInteractive() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-range-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - releaseDescriptor.setInteractive( false ); + builder.setInteractive( false ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -473,7 +474,7 @@ public void testRangeSnapshotDependenciesOutsideProjectOnlyNonInteractive() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -490,26 +491,25 @@ public void testSnapshotDependenciesOutsideProjectOnlyInteractiveWithSnapshotsRe CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.1-SNAPSHOT" ), new VersionPair( "1.0", "1.0" ) ) ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // validate - Map versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" ); + ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder ); + + assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) ); + assertEquals( "1.1-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) ); - assertNotNull( versionsMap ); - assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); - - releaseDescriptor = new ReleaseDescriptor(); + builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.1-SNAPSHOT" ) ) ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); } @Test @@ -519,20 +519,19 @@ public void testSnapshotDependenciesSelectOlderRelease() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "0.9", "1.0-SNAPSHOT" ), new VersionPair( "1.0", "1.0-SNAPSHOT" ) ) ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // validate - Map versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" ); + ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder ); - assertNotNull( versionsMap ); - assertEquals( "1.0-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "0.9", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + assertEquals( "0.9", descriptor.getDependencyReleaseVersion( "external:artifactId" ) ); + assertEquals( "1.0-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) ); } @Test @@ -542,19 +541,18 @@ public void testSnapshotDependenciesSelectDefaults() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.0" ) ) ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // validate - Map versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" ); + ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder ); - assertNotNull( versionsMap ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) ); + assertEquals( "1.0", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) ); } @Test @@ -564,19 +562,18 @@ public void testSnapshotDependenciesUpdateAllOnlyDependenciesNeeded() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createMockPrompter( YES, "0", new VersionPair( "1.0", "1.0" ) ) ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // validate - Map versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" ); + ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder ); - assertNotNull( versionsMap ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) ); + assertEquals( "1.0", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) ); } @Test @@ -586,8 +583,8 @@ public void testSnapshotDependenciesUpdateAll() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-all" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); Prompter mockPrompter = createMockPrompter( YES, "0", @@ -595,14 +592,13 @@ public void testSnapshotDependenciesUpdateAll() new VersionPair( "1.2", "1.2" ), new VersionPair( "1.3", "1.3" ) ) ); phase.setPrompter( mockPrompter ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // validate - Map versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" ); + ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder ); - assertNotNull( versionsMap ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) ); + assertEquals( "1.0", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) ); } // MRELEASE-589 @@ -613,9 +609,9 @@ public void testSnapshotDependenciesOutsideMultimoduleProjectOnlyInteractiveWith CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "multimodule-external-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); VersionPair pair = new VersionPair( "1.0", "1.1-SNAPSHOT" ); VersionPair defaultPair = new VersionPair( "1.0", "1.0" ); @@ -623,27 +619,15 @@ public void testSnapshotDependenciesOutsideMultimoduleProjectOnlyInteractiveWith createMockPrompter( "yes", "1", Arrays.asList( pair, pair ), Arrays.asList( defaultPair, defaultPair ) ); phase.setPrompter( mockPrompter ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); - - Map> resolvedDependencies = releaseDescriptor.getResolvedSnapshotDependencies(); - - assertNotNull( resolvedDependencies ); - assertEquals( 2, resolvedDependencies.size() ); - - assertTrue( resolvedDependencies.containsKey( "external:artifactId" ) ); - assertTrue( resolvedDependencies.containsKey( "external:artifactId2" ) ); - - Map versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - assertNotNull( versionsMap ); - assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder ); - versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId2" ); + assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) ); + assertEquals( "1.1-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) ); - assertNotNull( versionsMap ); - assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId2" ) ); + assertEquals( "1.1-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId2" ) ); } @Test @@ -653,15 +637,15 @@ public void testSnapshotDependenciesInsideAndOutsideProject() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-and-external-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -674,7 +658,7 @@ public void testSnapshotDependenciesInsideAndOutsideProject() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -688,12 +672,12 @@ public void testSnapshotDependenciesInsideAndOutsideProject() public void testNoSnapshotReportPlugins() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();; List reactorProjects = createDescriptorFromProjects( "no-snapshot-report-plugins" ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -703,12 +687,12 @@ public void testNoSnapshotReportPlugins() public void testSnapshotReportPluginsInProjectOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-snapshot-report-plugins" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -721,14 +705,14 @@ public void testSnapshotReportPluginsOutsideProjectOnly() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-report-plugins" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -741,7 +725,7 @@ public void testSnapshotReportPluginsOutsideProjectOnly() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -758,15 +742,15 @@ public void testSnapshotReportPluginsInsideAndOutsideProject() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-and-external-snapshot-report-plugins" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -779,7 +763,7 @@ public void testSnapshotReportPluginsInsideAndOutsideProject() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -793,12 +777,12 @@ public void testSnapshotReportPluginsInsideAndOutsideProject() public void testNoSnapshotPlugins() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();; List reactorProjects = createDescriptorFromProjects( "no-snapshot-plugins" ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -808,12 +792,12 @@ public void testNoSnapshotPlugins() public void testSnapshotPluginsInProjectOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-snapshot-plugins" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -823,12 +807,12 @@ public void testSnapshotPluginsInProjectOnly() public void testSnapshotManagedPluginInProjectOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-managed-snapshot-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -838,12 +822,12 @@ public void testSnapshotManagedPluginInProjectOnly() public void testSnapshotUnusedInternalManagedPlugin() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "unused-internal-managed-snapshot-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -853,12 +837,12 @@ public void testSnapshotUnusedInternalManagedPlugin() public void testSnapshotUnusedExternalManagedPlugin() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "unused-external-managed-snapshot-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -871,14 +855,14 @@ public void testSnapshotExternalManagedPlugin() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-managed-snapshot-plugin" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -891,7 +875,7 @@ public void testSnapshotExternalManagedPlugin() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -908,14 +892,14 @@ public void testSnapshotPluginsOutsideProjectOnly() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-plugins" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -928,7 +912,7 @@ public void testSnapshotPluginsOutsideProjectOnly() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -945,14 +929,14 @@ public void testSnapshotPluginsInsideAndOutsideProject() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-and-external-snapshot-plugins" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -965,7 +949,7 @@ public void testSnapshotPluginsInsideAndOutsideProject() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -982,14 +966,14 @@ public void testSnapshotExternalParent() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-parent/child" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -1002,7 +986,7 @@ public void testSnapshotExternalParent() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -1019,33 +1003,32 @@ public void testSnapshotExternalParentAdjusted() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-parent/child" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); Prompter mockPrompter = createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0-test", "1.0-test" ), new VersionPair( "1.0", "1.0-test" ) ); phase.setPrompter( mockPrompter ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // validate - Map versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "groupId:parent-external" ); + ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder ); - assertNotNull( versionsMap ); - assertEquals( "1.0-test", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) ); - assertEquals( "1.0-test", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) ); + assertEquals( "1.0-test", descriptor.getDependencyReleaseVersion( "groupId:parent-external" ) ); + assertEquals( "1.0-test", descriptor.getDependencyDevelopmentVersion( "groupId:parent-external" ) ); } @Test public void testReleaseExternalParent() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();; List reactorProjects = createDescriptorFromProjects( "external-parent/child" ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -1058,14 +1041,14 @@ public void testSnapshotExternalExtension() CheckDependencySnapshotsPhase phase = (CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-snapshot-extension" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); phase.setPrompter( createNoMockPrompter() ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -1078,7 +1061,7 @@ public void testSnapshotExternalExtension() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -1092,12 +1075,12 @@ public void testSnapshotExternalExtension() public void testSnapshotInternalExtension() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "internal-snapshot-extension" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -1107,12 +1090,12 @@ public void testSnapshotInternalExtension() public void testReleaseExternalExtension() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();; List reactorProjects = createDescriptorFromProjects( "external-extension" ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); @@ -1122,16 +1105,16 @@ public void testReleaseExternalExtension() public void testAllowTimestampedSnapshots() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); List reactorProjects = createDescriptorFromProjects( "external-timestamped-snapshot-dependencies" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects ); - releaseDescriptor.setInteractive( false ); + builder.setInteractive( false ); // confirm POM fails without allowTimestampedSnapshots try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have failed execution" ); } @@ -1141,11 +1124,11 @@ public void testAllowTimestampedSnapshots() } // check whether flag allows - releaseDescriptor.setAllowTimestampedSnapshots( true ); + builder.setAllowTimestampedSnapshots( true ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // successful execution is verification enough assertTrue( true ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java index 3e3eac444..84e78d7d5 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckPomPhaseTest.java @@ -23,7 +23,8 @@ import org.apache.maven.model.Scm; import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; import org.codehaus.plexus.PlexusTestCase; @@ -52,12 +53,12 @@ protected void setUp() public void testCorrectlyConfigured() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); // successful execution is verification enough assertTrue( true ); @@ -66,73 +67,66 @@ public void testCorrectlyConfigured() public void testGetUrlFromProjectConnection() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" ); + MavenProject project = createProject( "1.0-SNAPSHOT" ); - Scm scm = new Scm(); - scm.setConnection( "scm:svn:file://localhost/tmp/repo" ); - project.setScm( scm ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); - assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() ); + assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() ); } public void testGetUrlFromProjectConnectionSimulate() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" ); + MavenProject project = createProject( "1.0-SNAPSHOT" ); - Scm scm = new Scm(); - scm.setConnection( "scm:svn:file://localhost/tmp/repo" ); - project.setScm( scm ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); - assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() ); + assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() ); } public void testGetUrlFromProjectDevConnection() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:https://localhost/tmp/repo" ); + MavenProject project = createProject( "1.0-SNAPSHOT" ); - Scm scm = new Scm(); - scm.setConnection( "scm:svn:file://localhost/tmp/repo" ); - scm.setDeveloperConnection( "scm:svn:https://localhost/tmp/repo" ); - project.setScm( scm ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); - assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() ); + assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() ); } public void testGetUrlFromProjectDevConnectionSimulate() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:https://localhost/tmp/repo" ); + MavenProject project = createProject( "1.0-SNAPSHOT" ); - Scm scm = new Scm(); - scm.setConnection( "scm:svn:file://localhost/tmp/repo" ); - scm.setDeveloperConnection( "scm:svn:https://localhost/tmp/repo" ); - project.setScm( scm ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); - assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() ); + assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() ); } public void testGetInvalidUrl() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:cvs:" ); + MavenProject project = createProject( "1.0-SNAPSHOT" ); - Scm scm = new Scm(); - scm.setConnection( "scm:cvs:" ); - project.setScm( scm ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); fail( "Should have thrown an exception" ); } @@ -145,7 +139,7 @@ public void testGetInvalidUrl() public void testGetInvalidProvider() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); MavenProject project = createProject( "1.0-SNAPSHOT" ); Scm scm = new Scm(); scm.setConnection( "scm:foo:" ); @@ -153,7 +147,7 @@ public void testGetInvalidProvider() try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) ); fail( "Should have thrown an exception" ); } @@ -166,11 +160,11 @@ public void testGetInvalidProvider() public void testMissingUrl() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); fail( "Should have failed to execute" ); } @@ -181,7 +175,7 @@ public void testMissingUrl() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) ); fail( "Should have failed to simulate" ); } @@ -194,12 +188,12 @@ public void testMissingUrl() public void testReleasingNonSnapshot() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) ); fail( "Should have failed to execute" ); } @@ -210,7 +204,7 @@ public void testReleasingNonSnapshot() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0" ) ) ); fail( "Should have failed to simulate" ); } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java index 8f714aa42..defcb175c 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/CheckoutProjectFromScmTest.java @@ -45,7 +45,8 @@ import org.apache.maven.scm.repository.ScmRepository; import org.apache.maven.scm.repository.ScmRepositoryException; import org.apache.maven.shared.release.ReleaseExecutionException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; import org.apache.maven.shared.release.stubs.ScmManagerStub; @@ -73,13 +74,13 @@ public void testExecuteStandard() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); File checkoutDirectory = getTestFile( "target/checkout-test/standard" ); - descriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); String sourceUrl = "file://localhost/tmp/scm-repo/trunk"; String scmUrl = "scm:svn:" + sourceUrl; - descriptor.setScmSourceUrl( scmUrl ); + builder.setScmSourceUrl( scmUrl ); ScmProvider scmProviderMock = mock( ScmProvider.class ); SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository( sourceUrl ); @@ -98,10 +99,10 @@ public void testExecuteStandard() List reactorProjects = createReactorProjects( dir, dir, null ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // prepare - assertEquals( "", descriptor.getScmRelativePathProjectDirectory() ); + assertEquals( "", ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory() ); verify( scmProviderMock ).checkOut( eq( repository ), argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ), @@ -115,13 +116,13 @@ public void testExecuteMultiModuleWithDeepSubprojects() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); File checkoutDirectory = getTestFile( "target/checkout-test/multimodule-with-deep-subprojects" ); - descriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); String sourceUrl = "file://localhost/tmp/scm-repo/trunk"; String scmUrl = "scm:svn:" + sourceUrl; - descriptor.setScmSourceUrl( scmUrl ); + builder.setScmSourceUrl( scmUrl ); ScmProvider scmProviderMock = mock( ScmProvider.class ); SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository( sourceUrl ); @@ -141,10 +142,10 @@ public void testExecuteMultiModuleWithDeepSubprojects() createReactorProjects( dir, dir, null ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "", descriptor.getScmRelativePathProjectDirectory() ); + assertEquals( "", ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory() ); verify( scmProviderMock ).checkOut( eq( repository ), argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ), @@ -158,13 +159,13 @@ public void testExecuteFlatMultiModule() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); File checkoutDirectory = getTestFile( "target/checkout-test/flat-multi-module" ); - descriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); String sourceUrl = "file://localhost/tmp/scm-repo/trunk/root-project"; String scmUrl = "scm:svn:" + sourceUrl; - descriptor.setScmSourceUrl( scmUrl ); + builder.setScmSourceUrl( scmUrl ); ScmProvider scmProviderMock = mock( ScmProvider.class ); SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository( sourceUrl ); @@ -183,11 +184,11 @@ public void testExecuteFlatMultiModule() createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "not found root-project but " + descriptor.getScmRelativePathProjectDirectory(), "root-project", - descriptor.getScmRelativePathProjectDirectory() ); + assertEquals( "not found root-project but " + ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory(), "root-project", + ReleaseUtils.buildReleaseDescriptor( builder ).getScmRelativePathProjectDirectory() ); verify( scmProviderMock ).checkOut( eq( repository ), argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ), @@ -201,9 +202,9 @@ public void testNoSuchScmProviderExceptionThrown() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new NoSuchScmProviderException( "..." ) ); @@ -214,9 +215,9 @@ public void testNoSuchScmProviderExceptionThrown() // execute try { - releaseDescriptor.setUseReleaseProfile( false ); + builder.setUseReleaseProfile( false ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "commit should have failed" ); } @@ -231,9 +232,9 @@ public void testScmRepositoryExceptionThrown() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new ScmRepositoryException( "..." ) ); @@ -244,9 +245,9 @@ public void testScmRepositoryExceptionThrown() // execute try { - releaseDescriptor.setUseReleaseProfile( false ); + builder.setUseReleaseProfile( false ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "commit should have failed" ); } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java index 1c17c6499..990bd4144 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/EndReleasePhaseTest.java @@ -25,7 +25,8 @@ import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleaseResult; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.junit.Test; @@ -45,14 +46,14 @@ public void setUp() { super.setUp(); - phase = (ReleasePhase) lookup( ReleasePhase.class, "end-release" ); + phase = lookup( ReleasePhase.class, "end-release" ); } @Test public void testExecute() throws ReleaseExecutionException, ReleaseFailureException { - ReleaseResult result = phase.execute( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null ); + ReleaseResult result = phase.execute( ReleaseUtils.buildReleaseDescriptor( new ReleaseDescriptorBuilder() ), new DefaultReleaseEnvironment(), null ); assertEquals( ReleaseResult.SUCCESS, result.getResultCode() ); } @@ -61,7 +62,7 @@ public void testExecute() public void testSimulate() throws ReleaseExecutionException, ReleaseFailureException { - ReleaseResult result = phase.simulate( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null ); + ReleaseResult result = phase.simulate( ReleaseUtils.buildReleaseDescriptor( new ReleaseDescriptorBuilder() ), new DefaultReleaseEnvironment(), null ); assertEquals( ReleaseResult.SUCCESS, result.getResultCode() ); } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java index d261323cc..744e14343 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/GenerateReleasePomsPhaseTest.java @@ -45,7 +45,8 @@ import org.apache.maven.scm.manager.ScmManagerStub; import org.apache.maven.scm.provider.ScmProvider; import org.apache.maven.scm.repository.ScmRepository; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.util.ReleaseUtil; import org.junit.Test; @@ -100,9 +101,9 @@ public void testRewriteExternalRangeDependency() throws Exception { List reactorProjects = createReactorProjects( "external-range-dependency" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); comparePomFiles( reactorProjects ); } @@ -113,13 +114,13 @@ public void testSuppressCommitBeforeTagOrBranch() throws Exception { List reactorProjects = createReactorProjects( "basic-pom" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setGenerateReleasePoms( true ); - config.setSuppressCommitBeforeTagOrBranch( true ); - config.setRemoteTagging( false ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setGenerateReleasePoms( true ); + builder.setSuppressCommitBeforeTagOrBranch( true ); + builder.setRemoteTagging( false ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); verify( scmProviderMock ).add( isA( ScmRepository.class ), isA( ScmFileSet.class ) ); @@ -131,13 +132,13 @@ public void testSuppressCommitBeforeTagOrBranchAndReomoteTagging() throws Exception { List reactorProjects = createReactorProjects( "basic-pom" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setGenerateReleasePoms( true ); - config.setSuppressCommitBeforeTagOrBranch( true ); - config.setRemoteTagging( true ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setGenerateReleasePoms( true ); + builder.setSuppressCommitBeforeTagOrBranch( true ); + builder.setRemoteTagging( true ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); verify( scmProviderMock ).add( isA( ScmRepository.class ), isA( ScmFileSet.class ) ); @@ -150,10 +151,10 @@ public void testFinalName() throws Exception { List reactorProjects = createReactorProjects( "pom-with-finalname" ); - ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects ); - config.setGenerateReleasePoms( true ); + ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects ); + builder.setGenerateReleasePoms( true ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -164,12 +165,12 @@ public void testFinalName() * util.List) */ @Override - protected ReleaseDescriptor createDescriptorFromProjects( List reactorProjects ) + protected ReleaseDescriptorBuilder createDescriptorFromProjects( List reactorProjects ) { - ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setGenerateReleasePoms( true ); - return descriptor; + ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects ); + builder.setScmReleaseLabel( "release-label" ); + builder.setGenerateReleasePoms( true ); + return builder; } /* @@ -230,14 +231,10 @@ protected void verifyReactorProjects( String path, boolean copyFiles ) verifyNoMoreInteractions( scmProviderMock ); } - /* - * @see org.apache.maven.shared.release.phase.AbstractRewritingReleasePhaseTestCase#mapNextVersion(org.apache.maven. - * shared.release.config.ReleaseDescriptor, java.lang.String) - */ @Override - protected void mapNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, NEXT_VERSION ); + config.addReleaseVersion( projectId, NEXT_VERSION ); } /* @@ -246,9 +243,9 @@ protected void mapNextVersion( ReleaseDescriptor config, String projectId ) * maven.shared.release.config.ReleaseDescriptor, java.lang.String) */ @Override - protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION ); + config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION ); } /* @@ -257,7 +254,7 @@ protected void mapAlternateNextVersion( ReleaseDescriptor config, String project * shared.release.config.ReleaseDescriptor, java.lang.String) */ @Override - protected void unmapNextVersion( ReleaseDescriptor config, String projectId ) + protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId ) { // nothing to do } @@ -267,15 +264,15 @@ protected void unmapNextVersion( ReleaseDescriptor config, String projectId ) * createConfigurationForPomWithParentAlternateNextVersion(java.util.List) */ @Override - protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - return config; + return builder; } /* @@ -283,15 +280,15 @@ protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVers * createConfigurationForWithParentNextVersion(java.util.List) */ @Override - protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION ); - return config; + return builder; } /* diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java index 8342fbd67..6476f04e5 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/InputVariablesPhaseTest.java @@ -18,8 +18,10 @@ * specific language governing permissions and limitations * under the License. */ - -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.fail; import static org.mockito.Matchers.eq; import static org.mockito.Matchers.isA; import static org.mockito.Mockito.mock; @@ -35,7 +37,8 @@ import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.PlexusJUnit4TestCase; import org.apache.maven.shared.release.ReleaseExecutionException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.codehaus.plexus.components.interactivity.Prompter; import org.codehaus.plexus.components.interactivity.PrompterException; @@ -71,26 +74,26 @@ public void testInputVariablesInteractive() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); verify( mockPrompter, times( 2 ) ).prompt( isA( String.class ), eq( "artifactId-1.0" ) ); verifyNoMoreInteractions( mockPrompter ); @@ -102,11 +105,11 @@ public void testUnmappedVersion() { List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -115,11 +118,11 @@ public void testUnmappedVersion() assertNull( "check no cause", e.getCause() ); } - releaseDescriptor = new ReleaseDescriptor(); + builder = new ReleaseDescriptorBuilder(); try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -139,28 +142,28 @@ public void testInputVariablesNonInteractive() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "artifactId-1.0", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "artifactId-1.0", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // never use prompter verifyNoMoreInteractions( mockPrompter ); @@ -176,26 +179,26 @@ public void testInputVariablesNonInteractiveConfigured() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setScmReleaseLabel( "tag-value" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.setScmReleaseLabel( "tag-value" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.setScmReleaseLabel( "simulated-tag-value" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // never use prompter verifyNoMoreInteractions( mockPrompter ); @@ -211,24 +214,24 @@ public void testInputVariablesInteractiveConfigured() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmReleaseLabel( "tag-value" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmReleaseLabel( "tag-value" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmReleaseLabel( "simulated-tag-value" ); + builder = new ReleaseDescriptorBuilder(); + builder.setScmReleaseLabel( "simulated-tag-value" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "simulated-tag-value", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "simulated-tag-value", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // never use prompter verifyNoMoreInteractions( mockPrompter ); @@ -246,14 +249,14 @@ public void testPrompterException() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -263,14 +266,14 @@ public void testPrompterException() } // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -295,28 +298,28 @@ public void testCvsTag() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseConfiguration = new ReleaseDescriptor(); - releaseConfiguration.setInteractive( false ); - releaseConfiguration.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseConfiguration.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" ); // execute - phase.execute( releaseConfiguration, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "artifactId-1_0", releaseConfiguration.getScmReleaseLabel() ); + assertEquals( "Check tag", "artifactId-1_0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseConfiguration = new ReleaseDescriptor(); - releaseConfiguration.setInteractive( false ); - releaseConfiguration.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseConfiguration.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" ); // execute - phase.simulate( releaseConfiguration, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "artifactId-1_0", releaseConfiguration.getScmReleaseLabel() ); + assertEquals( "Check tag", "artifactId-1_0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // never use prompter verifyNoMoreInteractions( mockPrompter ); @@ -332,29 +335,29 @@ public void testCustomTagFormat() phase.setPrompter( mockPrompter ); List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "artifactId-1.0", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.mapReleaseVersion( "groupId:artifactId", "1.0" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); - releaseDescriptor.setScmTagNameFormat( "simulated-@{artifactId}-@{version}" ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addReleaseVersion( "groupId:artifactId", "1.0" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder.setScmTagNameFormat( "simulated-@{artifactId}-@{version}" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check tag", "simulated-artifactId-1.0", releaseDescriptor.getScmReleaseLabel() ); + assertEquals( "Check tag", "simulated-artifactId-1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getScmReleaseLabel() ); // never use prompter verifyNoMoreInteractions( mockPrompter ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java index 9f03a921a..bbd55208e 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapDevelopmentVersionPhaseIT.java @@ -24,7 +24,8 @@ import org.apache.maven.model.Model; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.codehaus.plexus.PlexusTestCase; @@ -38,7 +39,7 @@ protected void setUp() throws Exception { super.setUp(); - mapVersionsPhase = (MapVersionsPhase) lookup( ReleasePhase.class.getName(), "map-development-versions" ); + mapVersionsPhase = (MapVersionsPhase) lookup( ReleasePhase.class, "map-development-versions" ); } private static MavenProject createProject( String artifactId, String version ) @@ -52,13 +53,13 @@ private static MavenProject createProject( String artifactId, String version ) public void testNoUpdateWorkingCopyVersions() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setUpdateWorkingCopyVersions( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.setUpdateWorkingCopyVersions( false ); List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - mapVersionsPhase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + mapVersionsPhase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - assertEquals( "1.0", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + assertEquals( "1.0", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java index 8feb4aa90..36e98bb93 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/MapVersionsPhaseTest.java @@ -32,15 +32,14 @@ import java.util.ArrayList; import java.util.Collections; -import java.util.HashMap; import java.util.List; -import java.util.Map; import org.apache.maven.model.Model; import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.PlexusJUnit4TestCase; import org.apache.maven.shared.release.ReleaseExecutionException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.policy.PolicyException; import org.apache.maven.shared.release.versions.VersionParseException; @@ -103,14 +102,14 @@ public void testExecuteSnapshot_MapRelease() List reactorProjects = Collections.singletonList( project ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "2.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); verify( mockPrompter ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) ); @@ -130,14 +129,14 @@ public void testSimulateSnapshot_MapReleaseVersions() List reactorProjects = Collections.singletonList( project ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "2.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); verify( mockPrompter ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) ); } @@ -157,24 +156,24 @@ public void testMapReleaseVersionsInteractiveAddZeroIncremental() List reactorProjects = Collections.singletonList( project ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "1.0.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); // prepare - releaseDescriptor = new ReleaseDescriptor(); + builder = new ReleaseDescriptorBuilder(); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "1.0.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) ); @@ -197,24 +196,24 @@ public void testMapReleaseVersionsInteractiveWithSnaphotVersion() List reactorProjects = Collections.singletonList( project ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "2.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); // prepare - releaseDescriptor = new ReleaseDescriptor(); + builder = new ReleaseDescriptorBuilder(); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "2.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), @@ -233,28 +232,28 @@ public void testMapReleaseVersionsNonInteractiveWithExplicitVersion() MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.class, TEST_MAP_RELEASE_VERSIONS ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "2.0" ); phase.setPrompter( mockPrompter ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "2.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" ); + builder = new ReleaseDescriptorBuilder(); + builder.addReleaseVersion( "groupId:artifactId", "2.0" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "2.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); } @Test @@ -266,15 +265,15 @@ public void testExecuteSnapshotNonInteractive_MapRelease() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "1.0" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); } @Test @@ -286,15 +285,15 @@ public void testSimulateSnapshotNonInteractive_MapReleaseVersions() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check mapped versions", "1.0" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); } @Test @@ -311,24 +310,24 @@ public void testMapDevVersionsInteractive() List reactorProjects = Collections.singletonList( project ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "2.0-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); // prepare - releaseDescriptor = new ReleaseDescriptor(); + builder = new ReleaseDescriptorBuilder(); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "2.0-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) ); @@ -349,26 +348,26 @@ public void testMapDevVersionsInteractiveDoNotUpdateWorkingCopy() List reactorProjects = Collections.singletonList( project ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setUpdateWorkingCopyVersions( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setUpdateWorkingCopyVersions( false ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "1.0", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setUpdateWorkingCopyVersions( false ); + builder = new ReleaseDescriptorBuilder(); + builder.setUpdateWorkingCopyVersions( false ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "1.0" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -382,26 +381,26 @@ public void testMapDevVersionsNonInteractive() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "1.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "1.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } /** @@ -417,28 +416,28 @@ public void testMapDevVersionsNonInteractiveWithExplicitVersion() phase.setPrompter( mockPrompter ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" ); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); // prepare - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); + builder.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" ); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -454,12 +453,12 @@ public void testPrompterException() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -469,12 +468,12 @@ public void testPrompterException() } // prepare - releaseDescriptor = new ReleaseDescriptor(); + builder = new ReleaseDescriptorBuilder(); // execute try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -501,24 +500,24 @@ public void testAdjustVersionInteractive() List reactorProjects = Collections.singletonList( project ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); // execute - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "2.0-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); // prepare - releaseDescriptor = new ReleaseDescriptor(); + builder = new ReleaseDescriptorBuilder(); // execute - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertEquals( "Check mapped versions", "2.0-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) ); @@ -532,12 +531,12 @@ public void testAdjustVersionNonInteractive() List reactorProjects = Collections.singletonList( createProject( "artifactId", "foo" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -546,12 +545,12 @@ public void testAdjustVersionNonInteractive() assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() ); } - releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected an exception" ); } @@ -570,17 +569,17 @@ public void testExecuteSnapshotBranchCreation_DefaultDevelopmentVersion_MapDevel List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -592,17 +591,17 @@ public void testSimulateSnapshotBranchCreation_DefaultDevelopmentVersion_MapDeve List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -614,18 +613,18 @@ public void testExecuteSnapshotBranchCreation_DefaultDevelopmentVersion_NonInter List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -637,18 +636,18 @@ public void testSimulateSnapshotBranchCreation_DefaultDevelopmentVersion_NonInte List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -660,17 +659,17 @@ public void testExecuteSnapshotBranchCreation_NonInteractive_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -682,17 +681,17 @@ public void testSimulateSnapshotBranchCreation_NonInteractive_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -704,16 +703,16 @@ public void testExecuteSnapshotDefaultDevelopmentVersion_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -725,16 +724,16 @@ public void testSimulateSnapshotDefaultDevelopmentVersion_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -746,17 +745,17 @@ public void testExecuteSnapshotDefaultDevelopmentVersion_NonInteractive_MapDevel List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -768,17 +767,17 @@ public void testSimulateSnapshotDefaultDevelopmentVersion_NonInteractive_MapDeve List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.1.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -790,16 +789,16 @@ public void testExecuteSnapshotNonInteractive_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -811,16 +810,16 @@ public void testSimulateSnapshotNonInteractive_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -832,17 +831,17 @@ public void testExecuteSnapshotAutoVersionSubmodules_NotInteractive_MapDevelopme List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -854,17 +853,17 @@ public void testSimulateSnapshotAutoVersionSubmodules_NotInteractive_MapDevelopm List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); } @Test @@ -876,17 +875,17 @@ public void testExecuteReleaseAutoVersionSubmodules_NotInteractive_MapDevelopmen List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -898,17 +897,17 @@ public void testSimulateReleaseAutoVersionSubmodules_NotInteractive_MapDevelopme List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -920,18 +919,18 @@ public void testExecuteSnapshotAutoVersionSubmodules_NotInteractive_MapRelease() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -943,18 +942,18 @@ public void testSimulateSnapshotAutoVersionSubmodules_NotInteractive_MapRelease( List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -966,18 +965,18 @@ public void testExecuteReleaseAutoVersionSubmodules_NotInteractive_MapRelease() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -989,18 +988,18 @@ public void testSimulateReleaseAutoVersionSubmodules_NotInteractive_MapRelease() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1012,18 +1011,18 @@ public void testExecuteSnapshotAutoVersionSubmodules_BranchCreation_NotInteracti List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -1035,18 +1034,18 @@ public void testSimulateSnapshotAutoVersionSubmodules_BranchCreation_NotInteract List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -1058,18 +1057,18 @@ public void testExecuteReleaseAutoVersionSubmodules_BranchCreation_NotInteractiv List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); } @Test @@ -1081,18 +1080,18 @@ public void testSimulateReleaseAutoVersionSubmodules_BranchCreation_NotInteracti List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -1104,19 +1103,19 @@ public void testExecuteSnapshotAutoVersionSubmodules_BranchCreation_NotInteracti List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1128,19 +1127,19 @@ public void testSimulateSnapshotAutoVersionSubmodules_BranchCreation_NotInteract List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1152,13 +1151,13 @@ public void testExecuteReleaseAutoVersionSubmodules_BranchCreation_NotInteractiv List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify /* @@ -1166,10 +1165,10 @@ public void testExecuteReleaseAutoVersionSubmodules_BranchCreation_NotInteractiv * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep * '1.2' instead of '1.3-SNAPSHOT' until further investigation. */ - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1181,13 +1180,13 @@ public void testSimulateReleaseAutoVersionSubmodules_BranchCreation_NotInteracti List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setBranchCreation( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify /* @@ -1195,10 +1194,10 @@ public void testSimulateReleaseAutoVersionSubmodules_BranchCreation_NotInteracti * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep * '1.2' instead of '1.3-SNAPSHOT' until further investigation. */ - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1210,22 +1209,22 @@ public void testExecuteSnapshotBranchCreation_NonInteractive_UpdateBranchVersion List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setInteractive( false ); + builder.setUpdateBranchVersions( true ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1237,22 +1236,22 @@ public void testSimulateSnapshotBranchCreation_NonInteractive_UpdateBranchVersio List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setInteractive( false ); + builder.setUpdateBranchVersions( true ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.3-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1264,20 +1263,20 @@ public void testExecuteSnapshotBranchCreation_DefaultReleaseVersion_NonInteracti List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); + builder.setInteractive( false ); + builder.setUpdateBranchVersions( true ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "2.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1289,20 +1288,20 @@ public void testSimulateSnapshotBranchCreation_DefaultReleaseVersion_NonInteract List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); + builder.setInteractive( false ); + builder.setUpdateBranchVersions( true ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "2.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1314,19 +1313,19 @@ public void testExecuteSnapshotBranchCreation_DefaultReleaseVersion_UpdateBranch List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); + builder.setUpdateBranchVersions( true ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "2.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1338,19 +1337,19 @@ public void testSimulateSnapshotBranchCreation_DefaultReleaseVersion_UpdateBranc List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setDefaultReleaseVersion( "2.1-SNAPSHOT" ); + builder.setUpdateBranchVersions( true ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "2.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1362,9 +1361,9 @@ public void testExecuteSnapshotBranchCreation_UpdateBranchVersions_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1374,7 +1373,7 @@ public void testExecuteSnapshotBranchCreation_UpdateBranchVersions_MapBranch() phase.setPrompter( mockPrompter ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1391,9 +1390,9 @@ public void testSimulateSnapshotBranchCreation_UpdateBranchVersions_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1403,7 +1402,7 @@ public void testSimulateSnapshotBranchCreation_UpdateBranchVersions_MapBranch() phase.setPrompter( mockPrompter ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1420,10 +1419,10 @@ public void testExecuteReleaseBranchCreation_UpdateBranchVersions_UpdateVersions List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); - releaseDescriptor.setUpdateVersionsToSnapshot( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); + builder.setUpdateVersionsToSnapshot( true ); // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!) @@ -1433,16 +1432,16 @@ public void testExecuteReleaseBranchCreation_UpdateBranchVersions_UpdateVersions phase.setPrompter( mockPrompter ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!) // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ); - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "2.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1454,10 +1453,10 @@ public void testSimulateReleaseBranchCreation_UpdateBranchVersions_UpdateVersion List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); - releaseDescriptor.setUpdateVersionsToSnapshot( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); + builder.setUpdateVersionsToSnapshot( true ); // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!) @@ -1467,16 +1466,16 @@ public void testSimulateReleaseBranchCreation_UpdateBranchVersions_UpdateVersion phase.setPrompter( mockPrompter ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!) // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ); - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "2.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1488,10 +1487,10 @@ public void testExecuteSnapshotBranchCreation_UpdateBranchVersions_UpdateVersion List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); - releaseDescriptor.setUpdateVersionsToSnapshot( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); + builder.setUpdateVersionsToSnapshot( true ); // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1501,7 +1500,7 @@ public void testExecuteSnapshotBranchCreation_UpdateBranchVersions_UpdateVersion phase.setPrompter( mockPrompter ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1518,10 +1517,10 @@ public void testSimulateSnapshotBranchCreation_UpdateBranchVersions_UpdateVersio List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); - releaseDescriptor.setUpdateVersionsToSnapshot( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); + builder.setUpdateVersionsToSnapshot( true ); // updateBranchVersions is set to true, so suggest the next snapshot version // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1531,7 +1530,7 @@ public void testSimulateSnapshotBranchCreation_UpdateBranchVersions_UpdateVersio phase.setPrompter( mockPrompter ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT @@ -1548,11 +1547,11 @@ public void testExecuteReleaseBranchCreation_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify /* @@ -1560,10 +1559,10 @@ public void testExecuteReleaseBranchCreation_MapBranch() * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep * '1.2' instead of '1.3-SNAPSHOT' until further investigation. */ - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1575,11 +1574,11 @@ public void testSimulateReleaseBranchCreation_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify /* @@ -1587,10 +1586,10 @@ public void testSimulateReleaseBranchCreation_MapBranch() * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep * '1.2' instead of '1.3-SNAPSHOT' until further investigation. */ - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1602,17 +1601,17 @@ public void testExecuteReleaseBranchCreation_NonUpdateWorkingCopyVersions_MapDev List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateWorkingCopyVersions( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateWorkingCopyVersions( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -1624,17 +1623,17 @@ public void testSimulateReleaseBranchCreation_NonUpdateWorkingCopyVersions_MapDe List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateWorkingCopyVersions( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateWorkingCopyVersions( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -1646,17 +1645,17 @@ public void testExecuteReleaseBranchCreation_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); // org.apache.maven.release:maven-release-manager:(,2.4) > true // org.apache.maven.release:maven-release-manager:[2.4,) > false - releaseDescriptor.setInteractive( false ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + builder.setInteractive( false ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -1668,19 +1667,19 @@ public void testSimulateReleaseBranchCreation_MapDevelopment() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); // org.apache.maven.release:maven-release-manager:(,2.4) > true // org.apache.maven.release:maven-release-manager:[2.4,) > false - releaseDescriptor.setInteractive( false ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -1692,17 +1691,17 @@ public void testExecuteSnapshotBranchCreation_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1714,17 +1713,17 @@ public void testSimulateSnapshotBranchCreation_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); } @Test @@ -1736,17 +1735,17 @@ public void testExecuteSnapshotBranchCreation_NonUpdateWorkingCopyVersions_MapDe List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateWorkingCopyVersions( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateWorkingCopyVersions( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1758,17 +1757,17 @@ public void testSimulateSnapshotBranchCreation_NonUpdateWorkingCopyVersions_MapD List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateWorkingCopyVersions( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateWorkingCopyVersions( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "1.2-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); } @Test @@ -1780,21 +1779,21 @@ public void testExecuteReleaseBranchCreation_UpdateBranchVersions_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); // org.apache.maven.release:maven-release-manager:(,2.4) > true // org.apache.maven.release:maven-release-manager:[2.4,) > false - releaseDescriptor.setInteractive( false ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1806,21 +1805,21 @@ public void testSimulateReleaseBranchCreation_UpdateBranchVersions_MapBranch() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateBranchVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateBranchVersions( true ); // org.apache.maven.release:maven-release-manager:(,2.4) > true // org.apache.maven.release:maven-release-manager:[2.4,) > false - releaseDescriptor.setInteractive( false ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), - releaseDescriptor.getReleaseVersions() ); + assertEquals( "Check release versions", "1.2" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); assertNull( "Check development versions", - releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) ); + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) ); } @Test @@ -1832,16 +1831,16 @@ public void testExecuteSnapshotBranchCreation_UpdateWorkingCopyVersions_MapDevel List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateWorkingCopyVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateWorkingCopyVersions( true ); when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" ); phase.setPrompter( mockPrompter ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) ); @@ -1856,16 +1855,16 @@ public void testSimulateSnapshotBranchCreation_UpdateWorkingCopyVersions_MapDeve List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setBranchCreation( true ); - releaseDescriptor.setUpdateWorkingCopyVersions( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setBranchCreation( true ); + builder.setUpdateWorkingCopyVersions( true ); when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" ); phase.setPrompter( mockPrompter ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) ); @@ -1882,19 +1881,18 @@ public void testExecuteMultiModuleAutoVersionSubmodules__MapDevelopment() Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ), createProject( "module1", "2.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - Map developmentVersions = new HashMap<>(); - developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" ); - developmentVersions.put( "groupId:module1", "2.0" ); - assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() ); - assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertEquals( "Check development versions", "2.0" , ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:module1") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:module1") ); } @Test @@ -1908,19 +1906,18 @@ public void testSimulateMultiModuleAutoVersionSubmodules__MapDevelopment() Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ), createProject( "module1", "2.0" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - Map developmentVersions = new HashMap<>(); - developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" ); - developmentVersions.put( "groupId:module1", "2.0" ); - assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() ); - assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() ); + assertEquals( "Check development versions", "1.3-SNAPSHOT", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "2.0", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:module1") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:module1") ); } @Test @@ -1933,18 +1930,18 @@ public void testExecuteSnapshotAutoVersionSubmodules_DefaultReleaseVersion_NonIn List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setDefaultReleaseVersion( "3.0" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setDefaultReleaseVersion( "3.0" ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "3.1-SNAPSHOT" , + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) ); } @Test @@ -1957,18 +1954,18 @@ public void testSimulateSnapshotAutoVersionSubmodules_DefaultReleaseVersion_NonI List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setDefaultReleaseVersion( "3.0" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setDefaultReleaseVersion( "3.0" ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "3.1-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -1981,18 +1978,18 @@ public void testExecuteSnapshotAutoVersionSubmodules_DefaultDevelopmentVersion_N List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" ); + builder.setInteractive( false ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "3.0-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } @Test @@ -2005,18 +2002,18 @@ public void testSimulateSnapshotAutoVersionSubmodules_DefaultDevelopmentVersion_ List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setAutoVersionSubmodules( true ); - releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" ); - releaseDescriptor.setInteractive( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setAutoVersionSubmodules( true ); + builder.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" ); + builder.setInteractive( false ); // test - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify - assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) ); + assertEquals( "Check development versions", "3.0-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } // MRELEASE-511 @@ -2031,20 +2028,20 @@ public void testUnusualVersions1() List reactorProjects = Collections.singletonList( createProject( "artifactId", "MYB_200909-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setDefaultReleaseVersion( "PPX" ); - releaseDescriptor.setDefaultDevelopmentVersion( "MYB_200909-SNAPSHOT" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setDefaultReleaseVersion( "PPX" ); + builder.setDefaultDevelopmentVersion( "MYB_200909-SNAPSHOT" ); // test - mapReleasephase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); - mapDevelopmentphase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + mapReleasephase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); + mapDevelopmentphase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify assertEquals( "Check development versions", - Collections.singletonMap( "groupId:artifactId", "MYB_200909-SNAPSHOT" ), - releaseDescriptor.getDevelopmentVersions() ); - assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "PPX" ), - releaseDescriptor.getReleaseVersions() ); + "MYB_200909-SNAPSHOT", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") ); + assertEquals( "Check release versions", "PPX", + ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) ); } // MRELEASE-269 @@ -2057,7 +2054,7 @@ public void testContinuousSnapshotCheck() List reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); when( mockPrompter.prompt( startsWith( "What is the new development version for " ), eq( "1.12-SNAPSHOT" ) ) ).thenReturn( "2.0" ) // wrong, expected SNAPSHOT @@ -2065,7 +2062,7 @@ public void testContinuousSnapshotCheck() phase.setPrompter( mockPrompter ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for " ), @@ -2082,15 +2079,15 @@ public void testEmptyDefaultDevelopmentVersion() List reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setDefaultDevelopmentVersion( "" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setDefaultDevelopmentVersion( "" ); when( mockPrompter.prompt( startsWith( "What is the new development version for " ), eq( "1.12-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" ); phase.setPrompter( mockPrompter ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( mockPrompter ).prompt( startsWith( "What is the new development version for " ), @@ -2106,15 +2103,15 @@ public void testEmptyDefaultReleaseVersion() List reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setDefaultReleaseVersion( "" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setDefaultReleaseVersion( "" ); when( mockPrompter.prompt( startsWith( "What is the release version for " ), eq( "1.11" ) ) ).thenReturn( "2.0" ); phase.setPrompter( mockPrompter ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( mockPrompter ).prompt( startsWith( "What is the release version for " ), eq( "1.11" ) ); @@ -2136,11 +2133,11 @@ public void testNonExistentVersionPolicy() List reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setProjectVersionPolicyId( "UNKNOWN" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setProjectVersionPolicyId( "UNKNOWN" ); // test - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); } private static MavenProject createProject( String artifactId, String version ) diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java index 54caabea6..964a5cff9 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java @@ -46,7 +46,8 @@ import org.apache.maven.scm.provider.ScmProvider; import org.apache.maven.scm.repository.ScmRepository; import org.apache.maven.shared.release.ReleaseResult; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.util.ReleaseUtil; import org.codehaus.plexus.util.IOUtil; @@ -66,7 +67,7 @@ public void setUp() { super.setUp(); - phase = (ReleasePhase) lookup( ReleasePhase.class, "remove-release-poms" ); + phase = lookup( ReleasePhase.class, "remove-release-poms" ); } @Test @@ -74,12 +75,13 @@ public void testExecuteBasicPom() throws Exception { // prepare + File workingDirectory = getTestFile( "target/test/checkout" ); List reactorProjects = createReactorProjects( "basic-pom" ); - ReleaseDescriptor config = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( workingDirectory ); MavenProject project = ReleaseUtil.getRootProject( reactorProjects ); File releasePom = ReleaseUtil.getReleasePom( project ); - ScmFileSet fileSet = new ScmFileSet( new File( config.getWorkingDirectory() ), releasePom ); + ScmFileSet fileSet = new ScmFileSet( workingDirectory, releasePom ); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -91,7 +93,7 @@ public void testExecuteBasicPom() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -104,8 +106,9 @@ public void testExecutePomWithModules() throws Exception { // prepare + File workingDirectory = getTestFile( "target/test/checkout" ); List reactorProjects = createReactorProjects( "pom-with-modules" ); - ReleaseDescriptor config = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); List releasePoms = new ArrayList<>(); for ( Iterator iterator = reactorProjects.iterator(); iterator.hasNext(); ) @@ -115,7 +118,7 @@ public void testExecutePomWithModules() releasePoms.add( releasePom ); } - ScmFileSet fileSet = new ScmFileSet( new File( config.getWorkingDirectory() ), releasePoms ); + ScmFileSet fileSet = new ScmFileSet( workingDirectory, releasePoms ); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -127,7 +130,7 @@ public void testExecutePomWithModules() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -141,7 +144,7 @@ public void testSimulateBasicPom() { // prepare List reactorProjects = createReactorProjects( "basic-pom" ); - ReleaseDescriptor config = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmProvider scmProviderMock = mock( ScmProvider.class ); @@ -149,7 +152,7 @@ public void testSimulateBasicPom() stub.setScmProvider( scmProviderMock ); // execute - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // never invoke scmProviderMock verifyNoMoreInteractions( scmProviderMock ); @@ -161,9 +164,9 @@ public void testExecuteWithSuppressCommitBeforeTag() { // prepare List reactorProjects = createReactorProjects( "basic-pom" ); - ReleaseDescriptor config = createReleaseDescriptor(); - config.setSuppressCommitBeforeTagOrBranch( true ); - config.setGenerateReleasePoms( true ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); + builder.setSuppressCommitBeforeTagOrBranch( true ); + builder.setGenerateReleasePoms( true ); ScmProvider scmProviderMock = mock( ScmProvider.class ); @@ -171,7 +174,7 @@ public void testExecuteWithSuppressCommitBeforeTag() stub.setScmProvider( scmProviderMock ); // execute - ReleaseResult result = phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + ReleaseResult result = phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); BufferedReader reader = null; try @@ -197,9 +200,9 @@ public void testSimulateWithSuppressCommitBeforeTag() { // prepare List reactorProjects = createReactorProjects( "basic-pom" ); - ReleaseDescriptor config = createReleaseDescriptor(); - config.setSuppressCommitBeforeTagOrBranch( true ); - config.setGenerateReleasePoms( true ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); + builder.setSuppressCommitBeforeTagOrBranch( true ); + builder.setGenerateReleasePoms( true ); ScmProvider scmProviderMock = mock( ScmProvider.class ); @@ -207,7 +210,7 @@ public void testSimulateWithSuppressCommitBeforeTag() stub.setScmProvider( scmProviderMock ); // execute - ReleaseResult result = phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + ReleaseResult result = phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); BufferedReader reader = null; try @@ -236,11 +239,16 @@ protected List createReactorProjects( String path ) return createReactorProjects( dir, dir, null ); } - private ReleaseDescriptor createReleaseDescriptor() + private ReleaseDescriptorBuilder createReleaseDescriptorBuilder() { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setGenerateReleasePoms( true ); - descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); - return descriptor; + return createReleaseDescriptorBuilder( getTestFile( "target/test/checkout" ) ); + } + + private ReleaseDescriptorBuilder createReleaseDescriptorBuilder( File workingDirectory ) + { + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setGenerateReleasePoms( true ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + return builder; } } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java index e6ae37338..dacb66a67 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java @@ -22,11 +22,11 @@ import static org.junit.Assert.assertTrue; import java.io.File; -import java.util.Iterator; import java.util.List; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.util.ReleaseUtil; import org.codehaus.plexus.util.FileUtils; @@ -44,7 +44,7 @@ public class RestoreBackupPomsPhaseTest ReleasePhase getReleasePhase() throws Exception { - return (ReleasePhase) lookup( ReleasePhase.class, "restore-backup-poms" ); + return lookup( ReleasePhase.class, "restore-backup-poms" ); } @Test @@ -84,9 +84,9 @@ private void runExecuteOnProjects( String path ) { List projects = getReactorProjects( getTestPath( path ) ); - ReleaseDescriptor desc = new ReleaseDescriptor(); - desc.setScmSourceUrl( "scm:svn:http://myhost/myrepo" ); - phase.execute( desc, new DefaultReleaseEnvironment(), projects ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:http://myhost/myrepo" ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), projects ); testProjectIsRestored( projects ); } @@ -94,10 +94,8 @@ private void runExecuteOnProjects( String path ) private void testProjectIsRestored( List reactorProjects ) throws Exception { - for ( Iterator projects = reactorProjects.iterator(); projects.hasNext(); ) + for ( MavenProject project : reactorProjects ) { - MavenProject project = projects.next(); - File pomFile = project.getFile(); File expectedFile = new File( pomFile.getParentFile(), expectedPomFilename ); diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java index b9da08905..6eb74b299 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java @@ -25,12 +25,13 @@ import java.io.File; import java.io.IOException; -import java.util.Iterator; import java.util.List; import java.util.Objects; +import org.apache.maven.artifact.ArtifactUtils; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.util.ReleaseUtil; import org.junit.Test; @@ -78,12 +79,12 @@ public void testSimulateRewrite() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); String expected = readTestProjectFile( "basic-pom/pom.xml" ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); String actual = readTestProjectFile( "basic-pom/pom.xml" ); assertEquals( "Check the original POM untouched", expected, actual ); @@ -98,12 +99,12 @@ public void testRewriteWithDashedComments() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-dashes-in-comment" ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); String expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); String actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" ); assertEquals( "Check the original POM is untouched", expected, actual ); @@ -118,14 +119,14 @@ public void testClean() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); File testFile = getTestFile( "target/test-classes/projects/rewrite-for-branch/basic-pom/pom.xml.branch" ); testFile.delete(); assertFalse( testFile.exists() ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( testFile.exists() ); @@ -139,8 +140,8 @@ public void testCleanNotExists() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); File testFile = getTestFile( "target/test-classes/projects/rewrite-for-branch/basic-pom/pom.xml.branch" ); testFile.delete(); @@ -157,50 +158,50 @@ public void testScmOverridden() throws Exception { List reactorProjects = createReactorProjects( "pom-with-overridden-scm" ); - ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects ); - config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects ); + builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @Override - protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION ); + config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION ); } @Override - protected void mapNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, NEXT_VERSION ); + config.addReleaseVersion( projectId, NEXT_VERSION ); } @Override - protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - return config; + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + return builder; } @Override - protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", NEXT_VERSION ); - return config; + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION ); + return builder; } @Override - protected void unmapNextVersion( ReleaseDescriptor config, String projectId ) + protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId ) { // nothing to do } @@ -211,10 +212,10 @@ public void testRewriteBasicPomWithCvs() { List reactorProjects = createReactorProjects( "basic-pom-with-cvs" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -225,10 +226,10 @@ public void testRewriteBasicPomWithScmExpression() { List reactorProjects = createReactorProjects( "basic-pom-with-scm-expression" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -239,11 +240,11 @@ public void testRewriteBasicPomWithTagBase() { List reactorProjects = createReactorProjects( "basic-pom-with-tag-base" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.setScmBranchBase( "file://localhost/tmp/scm-repo/branches" ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.setScmBranchBase( "file://localhost/tmp/scm-repo/branches" ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -253,11 +254,11 @@ public void testRewriteBasicPomWithTagBaseAndVaryingScmUrls() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-tag-base-and-varying-scm-urls" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.setScmBranchBase( "file://localhost/tmp/scm-repo/allprojects/branches" ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.setScmBranchBase( "file://localhost/tmp/scm-repo/allprojects/branches" ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -267,10 +268,10 @@ public void testRewriteBasicPomWithCvsFromTag() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -280,10 +281,10 @@ public void testRewriteBasicPomWithEmptyScm() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-empty-scm" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -293,9 +294,9 @@ public void testRewriteInterpolatedVersions() throws Exception { List reactorProjects = createReactorProjects( "interpolated-versions" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -305,19 +306,17 @@ public void testRewriteInterpolatedVersionsDifferentVersion() throws Exception { List reactorProjects = createReactorProjects( "interpolated-versions" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject3", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject3", NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - for ( Iterator i = reactorProjects.iterator(); i.hasNext(); ) + for ( MavenProject project : reactorProjects ) { - MavenProject project = i.next(); - // skip subproject1 - we don't need to worry about its version mapping change, it has no deps of any kind if ( !"groupId".equals( project.getGroupId() ) || !"subproject1".equals( project.getArtifactId() ) ) { @@ -331,10 +330,10 @@ public void testRewriteBasicPomWithInheritedScm() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-inherited-scm" ); - ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects ); - config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects ); + builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -345,12 +344,12 @@ public void testRewritePomWithParentAndProperties() { List reactorProjects = createReactorProjects( "pom-with-parent-and-properties" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -362,12 +361,12 @@ public void testRewritePomWithDependencyPropertyCoordinate() { List reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -379,11 +378,11 @@ public void testRewritePomWithScmOfParentEndingWithASlash() { List reactorProjects = createReactorProjects( "pom-with-scm-of-parent-ending-with-a-slash" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -394,12 +393,12 @@ public void testRewritePomWithDeepSubprojects() { List reactorProjects = createReactorProjects( "multimodule-with-deep-subprojects" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -410,9 +409,9 @@ public void testRewritePomForFlatMultiModule() { List reactorProjects = createReactorProjects( "rewrite-for-branch/pom-with-parent-flat", "root-project" ); - ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); + ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -423,23 +422,23 @@ public void testRewritePomWithCDATASectionOnWindows() throws Exception { List reactorProjects = createReactorProjects( "cdata-section" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); AbstractRewritePomsPhase phase = (AbstractRewritePomsPhase) this.phase; phase.setLs( "\r\n" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // compare POMS without line ending normalization assertTrue( comparePomFiles( reactorProjects, false ) ); } @Override - protected ReleaseDescriptor createDescriptorFromProjects( List reactorProjects ) + protected ReleaseDescriptorBuilder createDescriptorFromProjects( List reactorProjects ) { - ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects ); - descriptor.setScmReleaseLabel( "release-label" ); - return descriptor; + ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects ); + builder.setScmReleaseLabel( "release-label" ); + return builder; } // MRELEASE-454 @@ -448,9 +447,9 @@ public void testRewritePomWithImportedDependencyManagementInReactor() throws Exception { List reactorProjects = createReactorProjects( "imported-dependency-management-in-reactor" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -460,10 +459,10 @@ public void testRewritePomWithDifferentVersionsAcrossModules() throws Exception { List reactorProjects = createReactorProjects( "modules-with-different-versions" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java index af94c55fe..cea16c5f7 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java @@ -26,7 +26,6 @@ import java.io.File; import java.io.IOException; -import java.util.Iterator; import java.util.LinkedList; import java.util.List; @@ -34,7 +33,8 @@ import org.apache.maven.model.Scm; import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.ReleaseExecutionException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.util.ReleaseUtil; import org.junit.Test; @@ -71,13 +71,13 @@ public void testSimulateRewrite() throws Exception { List reactorProjects = createReactorProjectsWhenSimulated( "basic-pom" ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); String expected = readTestProjectFile( "basic-pom/pom.xml" ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); String actual = readTestProjectFile( "basic-pom/pom.xml" ); assertEquals( "Check the original POM untouched", expected, actual ); @@ -100,15 +100,15 @@ public void testSimulateRewriteEjbClientDeps() List reactorProjects = new LinkedList<>( createReactorProjects( "basic-pom-ejb-client-dep/project" ) ); reactorProjects.addAll( createReactorProjects( "basic-pom-ejb-client-dep/ejb" ) ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); - config.addDevelopmentVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), NEXT_VERSION ); - config.addReleaseVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), RELEASE_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addDevelopmentVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), NEXT_VERSION ); + builder.addReleaseVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), RELEASE_VERSION ); String expected = readTestProjectFile( "basic-pom-ejb-client-dep/project/pom.xml" ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); String actual = readTestProjectFile( "basic-pom-ejb-client-dep/project/pom.xml" ); assertEquals( "Check the original POM untouched", expected, actual ); @@ -123,15 +123,15 @@ public void testClean() throws Exception { List reactorProjects = createReactorProjectsWhenSimulated( "basic-pom" ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); File testFile = getTestFile( "target/test-classes/projects/rewrite-for-development/basic-pom/pom.xml.next" ); testFile.delete(); assertFalse( testFile.exists() ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( testFile.exists() ); @@ -145,9 +145,6 @@ public void testCleanNotExists() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); File testFile = getTestFile( "target/test-classes/projects/rewrite-for-development/basic-pom/pom.xml.next" ); testFile.delete(); @@ -164,13 +161,19 @@ public void testRewriteBasicPomUnmappedScm() { List reactorProjects = prepareReactorProjects( "basic-pom", true ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder() { + public ReleaseDescriptorBuilder addOriginalScmInfo(String key, Scm value) { + // do nothing + return this; + }; + }; + builder = createDescriptorFromProjects( builder, reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + mapNextVersion( builder, "groupId:artifactId" ); try { - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Expected failure" ); } @@ -202,73 +205,73 @@ protected List prepareReactorProjects( String path, boolean copyFi } @Override - protected ReleaseDescriptor createDescriptorFromBasicPom( List reactorProjects ) + protected ReleaseDescriptorBuilder createDescriptorFromBasicPom( List reactorProjects ) throws Exception { - ReleaseDescriptor config = super.createDescriptorFromBasicPom( reactorProjects ); + ReleaseDescriptorBuilder builder = super.createDescriptorFromBasicPom( reactorProjects ); - mapScm( config ); + mapScm( builder ); - return config; + return builder; } - private void mapScm( ReleaseDescriptor config ) + private void mapScm( ReleaseDescriptorBuilder builder ) { Scm scm = new Scm(); scm.setConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk" ); scm.setDeveloperConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk" ); scm.setUrl( "file://localhost/tmp/scm-repo/trunk" ); - config.mapOriginalScmInfo( "groupId:artifactId", scm ); + builder.addOriginalScmInfo( "groupId:artifactId", scm ); } @Override - protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( projectId, ALTERNATIVE_NEXT_VERSION ); + config.addReleaseVersion( projectId, ALTERNATIVE_RELEASE_VERSION ); + config.addDevelopmentVersion( projectId, ALTERNATIVE_NEXT_VERSION ); } @Override - protected void mapNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, RELEASE_VERSION ); - config.mapDevelopmentVersion( projectId, NEXT_VERSION ); + config.addReleaseVersion( projectId, RELEASE_VERSION ); + config.addDevelopmentVersion( projectId, NEXT_VERSION ); } @Override - protected void unmapNextVersion( ReleaseDescriptor config, String projectId ) + protected void unmapNextVersion( ReleaseDescriptorBuilder builder, String projectId ) { - config.mapReleaseVersion( projectId, RELEASE_VERSION ); + builder.addReleaseVersion( projectId, RELEASE_VERSION ); } @Override - protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - mapScm( config ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + mapScm( builder ); - return config; + return builder; } @Override - protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject1", NEXT_VERSION ); - mapScm( config ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject1", NEXT_VERSION ); + mapScm( builder ); - return config; + return builder; } @Test @@ -277,16 +280,16 @@ public void testRewriteBasicPomWithCvs() { List reactorProjects = createReactorProjects( "basic-pom-with-cvs" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); Scm scm = new Scm(); scm.setConnection( "${scm.base}:pserver:anoncvs@localhost:/tmp/scm-repo:module" ); scm.setDeveloperConnection( "${scm.base}:ext:${username}@localhost:/tmp/scm-repo:module" ); scm.setUrl( "${baseUrl}/module" ); - config.mapOriginalScmInfo( "groupId:artifactId", scm ); + builder.addOriginalScmInfo( "groupId:artifactId", scm ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -297,17 +300,17 @@ public void testRewriteBasicPomWithCvsFromTag() { List reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); Scm scm = new Scm(); scm.setConnection( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" ); scm.setDeveloperConnection( "scm:cvs:ext:${username}@localhost:/tmp/scm-repo:module" ); scm.setUrl( "http://localhost/viewcvs.cgi/module" ); scm.setTag( "original-label" ); - config.mapOriginalScmInfo( "groupId:artifactId", scm ); + builder.addOriginalScmInfo( "groupId:artifactId", scm ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -318,24 +321,23 @@ public void testRewriteBasicPomWithInheritedScm() { List reactorProjects = createReactorProjects( "basic-pom-inherited-scm" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject1", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subsubproject", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subsubproject", NEXT_VERSION ); - config.mapOriginalScmInfo( "groupId:artifactId", null ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject1", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subsubproject", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subsubproject", NEXT_VERSION ); Scm scm = new Scm(); scm.setConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk/subproject1" ); scm.setDeveloperConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk/subproject1" ); // MRELEASE-107 scm.setUrl( "http://localhost/viewvc/mypath/trunk/subproject1" ); - config.mapOriginalScmInfo( "groupId:subproject1", scm ); - config.mapOriginalScmInfo( "groupId:subsubproject", null ); + builder.addOriginalScmInfo( "groupId:subproject1", scm ); + builder.addOriginalScmInfo( "groupId:subsubproject", null ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -368,17 +370,17 @@ private void performTestRewritePomWithParentAndProperties( String path ) { List reactorProjects = createReactorProjects( path ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - mapScm( config ); + mapScm( builder ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -390,22 +392,20 @@ public void testSimulateRewritePomWithParentAndProperties() // use the original ones since simulation didn't modify them List reactorProjects = createReactorProjects( "pom-with-parent-and-properties-sim" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - mapScm( config ); + mapScm( builder ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); - for ( Iterator i = reactorProjects.iterator(); i.hasNext(); ) + for ( MavenProject project : reactorProjects ) { - MavenProject project = i.next(); - File pomFile = project.getFile(); File actualFile = new File( pomFile.getParentFile(), pomFile.getName() + ".next" ); File expectedFile = new File( actualFile.getParentFile(), "expected-pom.xml" ); @@ -421,17 +421,17 @@ public void testRewritePomWithDependencyPropertyCoordinate() { List reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION ); - config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION ); + builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - mapScm( config ); + mapScm( builder ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -442,11 +442,11 @@ public void testRewritePomDependenciesWithoutDependenciesVersionUpdate() { List reactorProjects = createReactorProjects( "internal-snapshot-dependencies-without-dependencies-version-update" ); - ReleaseDescriptor config = createDefaultConfiguration( reactorProjects ); - config.setUpdateDependencies( false ); - mapNextVersion( config, "groupId:subsubproject" ); + ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects ); + builder.setUpdateDependencies( false ); + mapNextVersion( builder, "groupId:subsubproject" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java index a89ef576b..d81b7a569 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java @@ -30,7 +30,9 @@ import java.util.Objects; import org.apache.maven.project.MavenProject; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseStageVersions; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.util.ReleaseUtil; import org.junit.Test; @@ -78,12 +80,12 @@ public void testSimulateRewrite() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); String expected = readTestProjectFile( "basic-pom/pom.xml" ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); String actual = readTestProjectFile( "basic-pom/pom.xml" ); assertEquals( "Check the original POM untouched", expected, actual ); @@ -98,12 +100,12 @@ public void testRewriteWithDashedComments() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-dashes-in-comment" ); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); String expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); String actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" ); assertEquals( "Check the original POM is untouched", expected, actual ); @@ -118,14 +120,14 @@ public void testClean() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" ); testFile.delete(); assertFalse( testFile.exists() ); - phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( testFile.exists() ); @@ -139,8 +141,6 @@ public void testCleanNotExists() throws Exception { List reactorProjects = createReactorProjectsFromBasicPom(); - ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" ); testFile.delete(); @@ -157,50 +157,50 @@ public void testScmOverridden() throws Exception { List reactorProjects = createReactorProjects( "pom-with-overridden-scm" ); - ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects ); - config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects ); + builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @Override - protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION ); + config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION ); } @Override - protected void mapNextVersion( ReleaseDescriptor config, String projectId ) + protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId ) { - config.mapReleaseVersion( projectId, NEXT_VERSION ); + config.addReleaseVersion( projectId, NEXT_VERSION ); } @Override - protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - return config; + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + return builder; } @Override - protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List reactorProjects ) + protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List reactorProjects ) throws Exception { - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", NEXT_VERSION ); - return config; + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION ); + return builder; } @Override - protected void unmapNextVersion( ReleaseDescriptor config, String projectId ) + protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId ) { // nothing to do } @@ -211,10 +211,10 @@ public void testRewriteBasicPomWithCvs() { List reactorProjects = createReactorProjects( "basic-pom-with-cvs" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -225,10 +225,10 @@ public void testRewriteBasicPomWithScmExpression() { List reactorProjects = createReactorProjects( "basic-pom-with-scm-expression" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -239,11 +239,11 @@ public void testRewriteBasicPomWithTagBase() { List reactorProjects = createReactorProjects( "basic-pom-with-tag-base" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.setScmTagBase( "file://localhost/tmp/scm-repo/releases" ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.setScmTagBase( "file://localhost/tmp/scm-repo/releases" ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -253,11 +253,11 @@ public void testRewriteBasicPomWithTagBaseAndVaryingScmUrls() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-tag-base-and-varying-scm-urls" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.setScmTagBase( "file://localhost/tmp/scm-repo/allprojects/releases" ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.setScmTagBase( "file://localhost/tmp/scm-repo/allprojects/releases" ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -267,10 +267,10 @@ public void testRewriteBasicPomWithCvsFromTag() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -280,10 +280,10 @@ public void testRewriteBasicPomWithEmptyScm() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-with-empty-scm" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -293,9 +293,9 @@ public void testRewriteInterpolatedVersions() throws Exception { List reactorProjects = createReactorProjects( "interpolated-versions" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -305,14 +305,14 @@ public void testRewriteInterpolatedVersionsDifferentVersion() throws Exception { List reactorProjects = createReactorProjects( "interpolated-versions" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject3", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject3", NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); for ( Iterator i = reactorProjects.iterator(); i.hasNext(); ) { @@ -331,10 +331,10 @@ public void testRewriteBasicPomWithInheritedScm() throws Exception { List reactorProjects = createReactorProjects( "basic-pom-inherited-scm" ); - ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects ); - config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects ); + builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -345,12 +345,12 @@ public void testRewritePomWithParentAndProperties() { List reactorProjects = createReactorProjects( "pom-with-parent-and-properties" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -362,12 +362,12 @@ public void testRewritePomWithDependencyPropertyCoordinate() { List reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -379,11 +379,11 @@ public void testRewritePomWithScmOfParentEndingWithASlash() { List reactorProjects = createReactorProjects( "pom-with-scm-of-parent-ending-with-a-slash" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -394,12 +394,12 @@ public void testRewritePomWithDeepSubprojects() { List reactorProjects = createReactorProjects( "multimodule-with-deep-subprojects" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -410,9 +410,9 @@ public void testRewritePomForFlatMultiModule() { List reactorProjects = createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" ); - ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); + ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -423,23 +423,23 @@ public void testRewritePomWithCDATASectionOnWindows() throws Exception { List reactorProjects = createReactorProjects( "cdata-section" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - mapNextVersion( config, "groupId:artifactId" ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + mapNextVersion( builder, "groupId:artifactId" ); RewritePomsForReleasePhase phase = (RewritePomsForReleasePhase) this.phase; phase.setLs( "\r\n" ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // compare POMS without line ending normalization assertTrue( comparePomFiles( reactorProjects, false ) ); } @Override - protected ReleaseDescriptor createDescriptorFromProjects( List reactorProjects ) + protected ReleaseDescriptorBuilder createDescriptorFromProjects( List reactorProjects ) { - ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects ); - descriptor.setScmReleaseLabel( "release-label" ); - return descriptor; + ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects ); + builder.setScmReleaseLabel( "release-label" ); + return builder; } @Test @@ -448,11 +448,12 @@ public void testRewritePomWithExternallyReleasedParent() { List reactorProjects = createReactorProjects( "pom-with-externally-released-parent" ); - ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects ); - config.mapResolvedSnapshotDependencies( "external:parent-artifactId", "1", "2-SNAPSHOT" ); - config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects ); + builder.addDependencyReleaseVersion( "external:parent-artifactId", "1" ); + builder.addDependencyDevelopmentVersion( "external:parent-artifactId", "2-SNAPSHOT" ); + builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -463,9 +464,9 @@ public void testRewritePomWithImportedDependencyManagementInReactor() throws Exception { List reactorProjects = createReactorProjects( "imported-dependency-management-in-reactor" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } @@ -475,10 +476,10 @@ public void testRewritePomWithDifferentVersionsAcrossModules() throws Exception { List reactorProjects = createReactorProjects( "modules-with-different-versions" ); - ReleaseDescriptor config = createMappedConfiguration( reactorProjects ); - config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); + ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects ); + builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION ); - phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); assertTrue( comparePomFiles( reactorProjects ) ); } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java index 9710ddc65..ee520f37d 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java @@ -37,7 +37,8 @@ import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleaseResult; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.apache.maven.shared.release.exec.MavenExecutor; @@ -57,7 +58,7 @@ public class RunCompleteGoalsPhaseTest private MavenExecutorWrapper mavenExecutorWrapper; - private ReleaseEnvironment releaseEnvironment; + private DefaultReleaseEnvironment releaseEnvironment; @Override public void setUp() @@ -80,16 +81,16 @@ public void testExecute() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setCompletionGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletionGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); // execute - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); // verify verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ), @@ -105,16 +106,16 @@ public void testSimulate() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setCompletionGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletionGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); // execute - phase.simulate( config, releaseEnvironment, null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null ); // verify verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ), @@ -130,9 +131,9 @@ public void testExecuteException() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setCompletionGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletionGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); doThrow( new MavenExecutorException( "...", @@ -149,7 +150,7 @@ public void testExecuteException() // execute try { - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); fail( "Should have thrown an exception" ); } @@ -172,9 +173,9 @@ public void testSimulateException() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setCompletionGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletionGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); doThrow( new MavenExecutorException( "...", @@ -191,7 +192,7 @@ public void testSimulateException() // execute try { - phase.simulate( config, releaseEnvironment, null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null ); fail( "Should have thrown an exception" ); } @@ -214,16 +215,16 @@ public void testEmptyGoals() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setCompletionGoals( "" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setCompletionGoals( "" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); // execute - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); // verify // never invoke mock diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java index f7bcd648b..4b7ca8aa9 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java @@ -48,7 +48,8 @@ import org.apache.maven.shared.release.PlexusJUnit4TestCase; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseResult; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.apache.maven.shared.release.exec.MavenExecutor; @@ -67,7 +68,7 @@ public class RunPerformGoalsPhaseTest private MavenExecutorWrapper mavenExecutorWrapper; - private ReleaseEnvironment releaseEnvironment; + private DefaultReleaseEnvironment releaseEnvironment; @Override public void setUp() @@ -90,9 +91,9 @@ public void testExecuteException() // prepare File testFile = getTestFile( "target/checkout-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setPerformGoals( "goal1 goal2" ); - config.setCheckoutDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setPerformGoals( "goal1 goal2" ); + builder.setCheckoutDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); @@ -111,7 +112,7 @@ public void testExecuteException() // execute try { - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); fail( "Should have thrown an exception" ); } @@ -136,16 +137,16 @@ public void testCustomPomFile() throws Exception { //prepare File testFile = getTestFile( "target/checkout-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setPerformGoals( "goal1 goal2" ); - config.setPomFileName( "pom1.xml" ); - config.setCheckoutDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setPerformGoals( "goal1 goal2" ); + builder.setPomFileName( "pom1.xml" ); + builder.setCheckoutDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); verify( mock ).executeGoals( eq( testFile ), eq( "goal1 goal2" ), @@ -162,12 +163,12 @@ public void testReleasePerformWithArgumentsNoReleaseProfile() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" ); - releaseDescriptor.setPerformGoals( "goal1 goal2" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setAdditionalArguments( "-Dmaven.test.skip=true" ); + builder.setPerformGoals( "goal1 goal2" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); @@ -182,10 +183,10 @@ public void testReleasePerformWithArgumentsNoReleaseProfile() ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class ); stub.setScmProvider( scmProviderMock ); - releaseDescriptor.setUseReleaseProfile( false ); + builder.setUseReleaseProfile( false ); // execute - phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() ); // verify verify( mock ).executeGoals( eq( checkoutDirectory ), @@ -206,11 +207,11 @@ public void testReleasePerform() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setPerformGoals( "goal1 goal2" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setPerformGoals( "goal1 goal2" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); @@ -226,7 +227,7 @@ public void testReleasePerform() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() ); // verify verify( mock ).executeGoals( eq( checkoutDirectory ), @@ -247,11 +248,11 @@ public void testReleasePerformNoReleaseProfile() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setPerformGoals( "goal1 goal2" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setPerformGoals( "goal1 goal2" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); @@ -266,10 +267,10 @@ public void testReleasePerformNoReleaseProfile() ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class ); stub.setScmProvider( scmProviderMock ); - releaseDescriptor.setUseReleaseProfile( false ); + builder.setUseReleaseProfile( false ); // execute - phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() ); // verify verify( mock ).executeGoals( eq( checkoutDirectory ), @@ -290,12 +291,12 @@ public void testReleasePerformWithArguments() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" ); - releaseDescriptor.setPerformGoals( "goal1 goal2" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setAdditionalArguments( "-Dmaven.test.skip=true" ); + builder.setPerformGoals( "goal1 goal2" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); @@ -311,7 +312,7 @@ public void testReleasePerformWithArguments() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() ); // verify verify( mock ).executeGoals( eq( checkoutDirectory ), @@ -332,11 +333,11 @@ public void testReleasePerformWithReleasePropertiesCompleted() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setPerformGoals( "goal1 goal2" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setPerformGoals( "goal1 goal2" ); File checkoutDirectory = getTestFile( "target/checkout-directory" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); @@ -351,10 +352,10 @@ public void testReleasePerformWithReleasePropertiesCompleted() ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class ); stub.setScmProvider( scmProviderMock ); - releaseDescriptor.setCompletedPhase( "end-release" ); + builder.setCompletedPhase( "end-release" ); // execute - phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() ); // verify verify( mock ).executeGoals( eq( checkoutDirectory ), diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java index 6a84ff7ff..4222580cc 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java @@ -37,7 +37,8 @@ import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleaseResult; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.apache.maven.shared.release.exec.MavenExecutor; @@ -57,7 +58,7 @@ public class RunPrepareGoalsPhaseTest private MavenExecutorWrapper mavenExecutorWrapper; - private ReleaseEnvironment releaseEnvironment; + private DefaultReleaseEnvironment releaseEnvironment; @Override public void setUp() @@ -80,16 +81,16 @@ public void testExecute() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setPreparationGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setPreparationGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); // execute - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); // verify verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ), @@ -105,16 +106,16 @@ public void testSimulate() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setPreparationGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setPreparationGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); // execute - phase.simulate( config, releaseEnvironment, null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null ); // verify verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ), @@ -130,9 +131,9 @@ public void testExecuteException() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setPreparationGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setPreparationGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); doThrow( new MavenExecutorException( "...", @@ -149,7 +150,7 @@ public void testExecuteException() // execute try { - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); fail( "Should have thrown an exception" ); } @@ -172,9 +173,9 @@ public void testSimulateException() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setPreparationGoals( "clean integration-test" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setPreparationGoals( "clean integration-test" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); doThrow( new MavenExecutorException( "...", @@ -191,7 +192,7 @@ public void testSimulateException() // execute try { - phase.simulate( config, releaseEnvironment, null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null ); fail( "Should have thrown an exception" ); } @@ -215,16 +216,16 @@ public void testEmptyGoals() // prepare File testFile = getTestFile( "target/working-directory" ); - ReleaseDescriptor config = new ReleaseDescriptor(); - config.setPreparationGoals( "" ); - config.setWorkingDirectory( testFile.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setPreparationGoals( "" ); + builder.setWorkingDirectory( testFile.getAbsolutePath() ); MavenExecutor mock = mock( MavenExecutor.class ); mavenExecutorWrapper.setMavenExecutor( mock ); // execute - phase.execute( config, releaseEnvironment, (List) null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List) null ); // verify // no invocations of mock diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java index 748c2a629..9136cb299 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java @@ -52,7 +52,8 @@ import org.apache.maven.scm.repository.ScmRepositoryException; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.ReleaseScmCommandException; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; @@ -74,7 +75,7 @@ public void setUp() { super.setUp(); - phase = (ReleasePhase) lookup( ReleasePhase.class, "scm-branch" ); + phase = lookup( ReleasePhase.class, "scm-branch" ); } public static String getPath( File file ) @@ -88,13 +89,13 @@ public void testBranch() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() ); @@ -108,7 +109,7 @@ public void testBranch() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).branch( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -127,13 +128,13 @@ public void testCommitMultiModuleDeepFolders() createReactorProjects( dir, dir, null ); String sourceUrl = "http://svn.example.com/repos/project/trunk/"; String scmUrl = "scm:svn:" + sourceUrl; - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( scmUrl ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( scmUrl ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); - descriptor.setScmBranchBase( "http://svn.example.com/repos/project/branches/" ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); + builder.setScmBranchBase( "http://svn.example.com/repos/project/branches/" ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() ); @@ -152,7 +153,7 @@ public void testCommitMultiModuleDeepFolders() stub.addScmRepositoryForUrl( scmUrl, repository ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).branch( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -169,11 +170,11 @@ public void testCommitForFlatMultiModule() List reactorProjects = createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( rootProject.getScm().getConnection() ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( rootProject.getScm().getConnection() ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); // one directory up from root project ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile().getParentFile() ); @@ -193,7 +194,7 @@ public void testCommitForFlatMultiModule() stub.addScmRepositoryForUrl( "scm:svn:" + scmUrl, repository ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).branch( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -207,14 +208,14 @@ public void testCommitMultiModule() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); String dir = "scm-commit/multiple-poms"; List reactorProjects = createReactorProjects( dir, dir, null ); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() ); @@ -229,7 +230,7 @@ public void testCommitMultiModule() stub.setScmProvider( scmProviderMock ); // exeucte - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).branch( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -242,12 +243,12 @@ public void testCommitMultiModule() public void testBranchNoReleaseLabel() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); try { - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } catch ( ReleaseFailureException e ) @@ -260,12 +261,12 @@ public void testBranchNoReleaseLabel() public void testSimulateBranch() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); ScmProvider scmProviderMock = mock( ScmProvider.class ); @@ -273,7 +274,7 @@ public void testSimulateBranch() stub.setScmProvider( scmProviderMock ); // execute - phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // no scmProvider invocation @@ -284,12 +285,12 @@ public void testSimulateBranch() public void testSimulateBranchNoReleaseLabel() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); try { - phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } catch ( ReleaseFailureException e ) @@ -304,7 +305,7 @@ public void testNoSuchScmProviderExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new NoSuchScmProviderException( "..." ) ); @@ -312,7 +313,7 @@ public void testNoSuchScmProviderExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -329,7 +330,7 @@ public void testScmRepositoryExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new ScmRepositoryException( "..." ) ); @@ -337,7 +338,7 @@ public void testScmRepositoryExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -355,7 +356,7 @@ public void testScmExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.branch( isA( ScmRepository.class ), isA( ScmFileSet.class ), isA( String.class ), @@ -367,7 +368,7 @@ public void testScmExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -387,17 +388,17 @@ public void testScmResultFailure() throws Exception { List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); ScmProviderStub providerStub = - (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() ); + (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" ); providerStub.setBranchScmResult( new BranchScmResult( "", "", "", false ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Commit should have failed" ); } @@ -414,13 +415,13 @@ private List createReactorProjects() return createReactorProjects( dir, dir, null ); } - private static ReleaseDescriptor createReleaseDescriptor() + private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder() throws IOException { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( "scm-url" ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) ); - return descriptor; + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) ); + return builder; } } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java index e6fad03b4..bff49da14 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java @@ -51,7 +51,8 @@ import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleaseResult; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.ReleaseScmCommandException; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; @@ -82,9 +83,9 @@ public void testNoSuchScmProviderExceptionThrown() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new NoSuchScmProviderException( "..." ) ); @@ -92,7 +93,7 @@ public void testNoSuchScmProviderExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -103,7 +104,7 @@ public void testNoSuchScmProviderExceptionThrown() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -119,9 +120,9 @@ public void testScmRepositoryExceptionThrown() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new ScmRepositoryException( "..." ) ); @@ -129,7 +130,7 @@ public void testScmRepositoryExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -140,7 +141,7 @@ public void testScmRepositoryExceptionThrown() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -155,9 +156,9 @@ public void testScmExceptionThrown() throws Exception { // prepare - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.status( isA( ScmRepository.class ), @@ -169,7 +170,7 @@ public void testScmExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -180,7 +181,7 @@ public void testScmExceptionThrown() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -198,17 +199,17 @@ public void testScmExceptionThrown() public void testScmResultFailure() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); + ScmManager scmManager = lookup( ScmManager.class ); ScmProviderStub providerStub = - (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() ); + (ScmProviderStub) scmManager.getProviderByUrl( "scm:svn:file://localhost/tmp/scm-repo" ); providerStub.setStatusScmResult( new StatusScmResult( "", "", "", false ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -219,7 +220,7 @@ public void testScmResultFailure() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -233,13 +234,13 @@ public void testScmResultFailure() public void testNoModifications() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - setChangedFiles( releaseDescriptor, Collections.emptyList() ); + setChangedFiles( builder, Collections.emptyList() ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); // successful execution is verification enough assertTrue( true ); @@ -249,14 +250,14 @@ public void testNoModifications() public void testModificationsToExcludedFilesOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - setChangedFiles( releaseDescriptor, + setChangedFiles( builder, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", "pom.xml.next" ) ); - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); // successful execution is verification enough assertTrue( true ); @@ -267,32 +268,32 @@ public void testModificationsToExcludedFilesOnly() public void testModificationsToCustomExcludedFilesOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "**/keep.me" ) ); + builder.setCheckModificationExcludes( Collections.singletonList( "**/keep.me" ) ); - setChangedFiles( releaseDescriptor, + setChangedFiles( builder, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", "pom.xml.next", "keep.me", "src/app/keep.me", "config\\keep.me" ) ); assertEquals( ReleaseResult.SUCCESS, - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() ); assertEquals( ReleaseResult.SUCCESS, - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() ); } @Test public void testModificationsToPoms() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - setChangedFiles( releaseDescriptor, Arrays.asList( "pom.xml", "module/pom.xml" ) ); + setChangedFiles( builder, Arrays.asList( "pom.xml", "module/pom.xml" ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -303,7 +304,7 @@ public void testModificationsToPoms() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -317,13 +318,13 @@ public void testModificationsToPoms() public void testModificationsToIncludedFilesOnly() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - setChangedFiles( releaseDescriptor, Collections.singletonList( "something.txt" ) ); + setChangedFiles( builder, Collections.singletonList( "something.txt" ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -334,7 +335,7 @@ public void testModificationsToIncludedFilesOnly() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -348,14 +349,14 @@ public void testModificationsToIncludedFilesOnly() public void testModificationsToIncludedAndExcludedFiles() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - setChangedFiles( releaseDescriptor, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", + setChangedFiles( builder, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", "pom.xml.release", "something.txt" ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -366,7 +367,7 @@ public void testModificationsToIncludedAndExcludedFiles() try { - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ); fail( "Status check should have failed" ); } @@ -380,16 +381,16 @@ public void testModificationsToIncludedAndExcludedFiles() public void testModificationsToAdditionalExcludedFiles() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); - releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "something.*" ) ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); + builder.setCheckModificationExcludes( Collections.singletonList( "something.*" ) ); - setChangedFiles( releaseDescriptor, Collections.singletonList( "something.txt" ) ); + setChangedFiles( builder, Collections.singletonList( "something.txt" ) ); assertEquals( ReleaseResult.SUCCESS, - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() ); assertEquals( ReleaseResult.SUCCESS, - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() ); } // MRELEASE-775 @@ -397,25 +398,25 @@ public void testModificationsToAdditionalExcludedFiles() public void testMultipleExclusionPatternMatch() throws Exception { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "release.properties" ) ); + builder.setCheckModificationExcludes( Collections.singletonList( "release.properties" ) ); - setChangedFiles( releaseDescriptor, Arrays.asList( "release.properties" ) ); + setChangedFiles( builder, Arrays.asList( "release.properties" ) ); assertEquals( ReleaseResult.SUCCESS, - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() ); assertEquals( ReleaseResult.SUCCESS, - phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() ); } - private void setChangedFiles( ReleaseDescriptor releaseDescriptor, List changedFiles ) + private void setChangedFiles( ReleaseDescriptorBuilder builder, List changedFiles ) throws Exception { ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); ScmProviderStub providerStub = - (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() ); + (ScmProviderStub) scmManager.getProviderByUrl( "scm:svn:file://localhost/tmp/scm-repo" ); providerStub.setStatusScmResult( new StatusScmResult( "", createScmFiles( changedFiles ) ) ); } @@ -431,11 +432,11 @@ private static List createScmFiles( List changedFiles ) return files; } - private static ReleaseDescriptor createReleaseDescriptor() + private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder() { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); - releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); - return releaseDescriptor; + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + return builder; } } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java index fc67417ce..41c90f328 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java @@ -42,7 +42,8 @@ import org.apache.maven.scm.manager.ScmManagerStub; import org.apache.maven.scm.provider.ScmProvider; import org.apache.maven.scm.repository.ScmRepository; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.util.ReleaseUtil; import org.junit.Test; @@ -64,7 +65,7 @@ public class ScmCommitDevelopmentPhaseTest private MavenProject rootProject; - private ReleaseDescriptor descriptor; + private ReleaseDescriptorBuilder builder; private ScmProvider scmProviderMock; @@ -78,7 +79,7 @@ public void setUp() reactorProjects = createReactorProjects(); rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor = createReleaseDescriptor( rootProject ); + builder = createReleaseDescriptorBuilder( rootProject ); } @Test @@ -91,16 +92,16 @@ public void testIsCorrectImplementation() public void testNoCommitOrRollbackRequired() throws Exception { - ReleaseDescriptor descriptor = createReleaseDescriptor( rootProject ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( rootProject ); List reactorProjects = createReactorProjects(); - descriptor.setRemoteTagging( false ); - descriptor.setSuppressCommitBeforeTagOrBranch( true ); - descriptor.setUpdateWorkingCopyVersions( false ); + builder.setRemoteTagging( false ); + builder.setSuppressCommitBeforeTagOrBranch( true ); + builder.setUpdateWorkingCopyVersions( false ); prepareNoCheckin(); - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); verifyNoCheckin(); } @@ -109,11 +110,11 @@ public void testNoCommitOrRollbackRequired() public void testCommitsNextVersions() throws Exception { - descriptor.setUpdateWorkingCopyVersions( true ); + builder.setUpdateWorkingCopyVersions( true ); prepareCheckin( COMMIT_MESSAGE ); - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); verifyCheckin( COMMIT_MESSAGE ); } @@ -122,13 +123,13 @@ public void testCommitsNextVersions() public void testCommitsRollbackPrepare() throws Exception { - descriptor.setUpdateWorkingCopyVersions( false ); + builder.setUpdateWorkingCopyVersions( false ); - String message = ROLLBACK_PREFIX + descriptor.getScmReleaseLabel(); + String message = ROLLBACK_PREFIX + "release-label"; prepareCheckin( message ); - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); verifyCheckin( message ); } @@ -176,12 +177,12 @@ private List createReactorProjects() return createReactorProjects( dir, dir, null ); } - private static ReleaseDescriptor createReleaseDescriptor( MavenProject rootProject ) + private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder( MavenProject rootProject ) { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( "scm-url" ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); - return descriptor; + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); + return builder; } } \ No newline at end of file diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java index c1d562ecf..54c18601a 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java @@ -53,7 +53,8 @@ import org.apache.maven.scm.repository.ScmRepositoryException; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.ReleaseScmCommandException; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; @@ -99,11 +100,11 @@ public void testCommit() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( "scm-url" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile(), rootProject.getFile() ); @@ -119,7 +120,7 @@ public void testCommit() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -132,13 +133,13 @@ public void testCommitMultiModule() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); String dir = "scm-commit/multiple-poms"; List reactorProjects = createReactorProjects( dir, dir, null ); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); List poms = new ArrayList<>(); for ( Iterator i = reactorProjects.iterator(); i.hasNext(); ) @@ -159,7 +160,7 @@ public void testCommitMultiModule() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -174,12 +175,12 @@ public void testCommitDevelopment() // prepare phase = (ReleasePhase) lookup( ReleasePhase.class, "scm-commit-development" ); - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile(), rootProject.getFile() ); @@ -194,7 +195,7 @@ public void testCommitDevelopment() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -207,12 +208,12 @@ public void testCommitDevelopment() public void testCommitNoReleaseLabel() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); try { - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } catch ( ReleaseFailureException e ) @@ -227,12 +228,12 @@ public void testCommitGenerateReleasePoms() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( "scm-url" ); - descriptor.setGenerateReleasePoms( true ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setGenerateReleasePoms( true ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); List files = new ArrayList<>(); files.add( rootProject.getFile() ); @@ -251,7 +252,7 @@ public void testCommitGenerateReleasePoms() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -263,19 +264,19 @@ public void testCommitGenerateReleasePoms() public void testSimulateCommit() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() ); + builder.setScmReleaseLabel( "release-label" ); ScmProvider scmProviderMock = mock( ScmProvider.class ); ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class ); stub.setScmProvider( scmProviderMock ); - phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // never invoke scmProviderMock verifyNoMoreInteractions( scmProviderMock ); @@ -285,12 +286,12 @@ public void testSimulateCommit() public void testSimulateCommitNoReleaseLabel() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); try { - phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } catch ( ReleaseFailureException e ) @@ -305,14 +306,14 @@ public void testNoSuchScmProviderExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new NoSuchScmProviderException( "..." ) ); // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -329,7 +330,7 @@ public void testScmRepositoryExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new ScmRepositoryException( "..." ) ); @@ -337,7 +338,7 @@ public void testScmRepositoryExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -354,7 +355,7 @@ public void testScmExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.checkIn( isA( ScmRepository.class ), isA( ScmFileSet.class ), isNull( ScmVersion.class ), @@ -366,7 +367,7 @@ public void testScmExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -386,17 +387,17 @@ public void testScmResultFailure() throws Exception { List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); ScmProviderStub providerStub = - (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() ); + (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" ); providerStub.setCheckInScmResult( new CheckInScmResult( "", "", "", false ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Commit should have failed" ); } @@ -410,11 +411,11 @@ public void testScmResultFailure() public void testSuppressCommitWithRemoteTaggingFails() throws Exception { - ReleaseDescriptor descriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setRemoteTagging( true ); - descriptor.setSuppressCommitBeforeTagOrBranch( true ); + builder.setRemoteTagging( true ); + builder.setSuppressCommitBeforeTagOrBranch( true ); ScmProvider scmProviderMock = mock( ScmProvider.class ); @@ -423,7 +424,7 @@ public void testSuppressCommitWithRemoteTaggingFails() try { - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Commit should have failed with ReleaseFailureException" ); } @@ -440,19 +441,19 @@ public void testSuppressCommitWithRemoteTaggingFails() public void testSuppressCommitAfterBranch() throws Exception { - ReleaseDescriptor descriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setBranchCreation( true ); - descriptor.setRemoteTagging( false ); - descriptor.setSuppressCommitBeforeTagOrBranch( true ); + builder.setBranchCreation( true ); + builder.setRemoteTagging( false ); + builder.setSuppressCommitBeforeTagOrBranch( true ); ScmProvider scmProviderMock = mock( ScmProvider.class ); ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class ); stub.setScmProvider( scmProviderMock ); - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // never invoke scmProviderMock verifyNoMoreInteractions( scmProviderMock ); @@ -465,12 +466,12 @@ private List createReactorProjects() return createReactorProjects( dir, dir, null ); } - private static ReleaseDescriptor createReleaseDescriptor() + private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder() { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( "scm-url" ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); - return descriptor; + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() ); + return builder; } } \ No newline at end of file diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java index 8f3152620..1ac428b45 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java @@ -52,7 +52,8 @@ import org.apache.maven.scm.repository.ScmRepositoryException; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.scm.ReleaseScmCommandException; import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException; @@ -88,13 +89,13 @@ public void testTag() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() ); @@ -108,7 +109,7 @@ public void testTag() stub.setScmProvider( scmProviderMock ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).tag( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -126,13 +127,13 @@ public void testCommitMultiModuleDeepFolders() createReactorProjects( "scm-commit/multimodule-with-deep-subprojects", "" ); String sourceUrl = "http://svn.example.com/repos/project/trunk/"; String scmUrl = "scm:svn:" + sourceUrl; - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( scmUrl ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( scmUrl ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); - descriptor.setScmTagBase( "http://svn.example.com/repos/project/releases/" ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); + builder.setScmTagBase( "http://svn.example.com/repos/project/releases/" ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() ); @@ -151,7 +152,7 @@ public void testCommitMultiModuleDeepFolders() stub.addScmRepositoryForUrl( scmUrl, repository ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).tag( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -168,11 +169,11 @@ public void testCommitForFlatMultiModule() List reactorProjects = createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( rootProject.getScm().getConnection() ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( rootProject.getScm().getConnection() ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); // one directory up from root project ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile().getParentFile() ); @@ -192,7 +193,7 @@ public void testCommitForFlatMultiModule() stub.addScmRepositoryForUrl( "scm:svn:" + scmUrl, repository ); // execute - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).tag( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -206,14 +207,14 @@ public void testCommitMultiModule() throws Exception { // prepare - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); String dir = "scm-commit/multiple-poms"; List reactorProjects = createReactorProjects( dir, dir, null ); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setScmCommentPrefix( "[my prefix] " ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); + builder.setScmCommentPrefix( "[my prefix] " ); ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() ); @@ -228,7 +229,7 @@ public void testCommitMultiModule() stub.setScmProvider( scmProviderMock ); // exeucte - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify verify( scmProviderMock ).tag( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ), @@ -241,12 +242,12 @@ public void testCommitMultiModule() public void testTagNoReleaseLabel() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); try { - phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } catch ( ReleaseFailureException e ) @@ -259,12 +260,12 @@ public void testTagNoReleaseLabel() public void testSimulateTag() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); - descriptor.setScmSourceUrl( "scm-url" ); + builder.setScmSourceUrl( "scm-url" ); MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects ); - descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); - descriptor.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) ); + builder.setScmReleaseLabel( "release-label" ); ScmProvider scmProviderMock = mock( ScmProvider.class ); @@ -272,7 +273,7 @@ public void testSimulateTag() stub.setScmProvider( scmProviderMock ); // execute - phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); // verify // no scmProvider invocation @@ -283,12 +284,12 @@ public void testSimulateTag() public void testSimulateTagNoReleaseLabel() throws Exception { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); List reactorProjects = createReactorProjects(); try { - phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Should have thrown an exception" ); } catch ( ReleaseFailureException e ) @@ -303,7 +304,7 @@ public void testNoSuchScmProviderExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new NoSuchScmProviderException( "..." ) ); @@ -311,7 +312,7 @@ public void testNoSuchScmProviderExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -328,7 +329,7 @@ public void testScmRepositoryExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class ); scmManagerStub.setException( new ScmRepositoryException( "..." ) ); @@ -336,7 +337,7 @@ public void testScmRepositoryExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -353,7 +354,7 @@ public void testScmExceptionThrown() { // prepare List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); ScmProvider scmProviderMock = mock( ScmProvider.class ); when( scmProviderMock.tag( isA( ScmRepository.class ), isA( ScmFileSet.class ), isA( String.class ), @@ -365,7 +366,7 @@ public void testScmExceptionThrown() // execute try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Status check should have failed" ); } @@ -385,17 +386,17 @@ public void testScmResultFailure() throws Exception { List reactorProjects = createReactorProjects(); - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - ScmManager scmManager = (ScmManager) lookup( ScmManager.class ); + ScmManager scmManager = lookup( ScmManager.class ); ScmProviderStub providerStub = - (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() ); + (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" ); providerStub.setTagScmResult( new TagScmResult( "", "", "", false ) ); try { - phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects ); + phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects ); fail( "Commit should have failed" ); } @@ -411,13 +412,13 @@ private List createReactorProjects() return createReactorProjects( "scm-commit/single-pom", "" ); } - private static ReleaseDescriptor createReleaseDescriptor() + private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder() throws IOException { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - descriptor.setScmSourceUrl( "scm-url" ); - descriptor.setScmReleaseLabel( "release-label" ); - descriptor.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) ); - return descriptor; + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); + builder.setScmReleaseLabel( "release-label" ); + builder.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) ); + return builder; } } diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java index e57c23dab..985e6cf29 100644 --- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java +++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java @@ -27,7 +27,8 @@ import org.apache.maven.scm.repository.ScmRepositoryException; import org.apache.maven.settings.Server; import org.apache.maven.settings.Settings; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; +import org.apache.maven.shared.release.config.ReleaseUtils; import org.codehaus.plexus.PlexusTestCase; /** @@ -54,9 +55,9 @@ protected void setUp() public void testGetConfiguredRepository() throws ScmRepositoryException, NoSuchScmProviderException { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null ); + ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null ); assertEquals( "check provider", "cvs", repository.getProvider() ); assertEquals( "check username", "anoncvs", repository.getProviderRepository().getUser() ); @@ -66,9 +67,9 @@ public void testGetConfiguredRepository() public void testGetConfiguredRepositoryWithUsernameAndPassword() throws ScmRepositoryException, NoSuchScmProviderException { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor( "username", "password" ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( "username", "password" ); - ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null ); + ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null ); assertEquals( "check username", "username", repository.getProviderRepository().getUser() ); assertEquals( "check password", "password", repository.getProviderRepository().getPassword() ); @@ -77,11 +78,11 @@ public void testGetConfiguredRepositoryWithUsernameAndPassword() public void testGetConfiguredRepositoryWithTagBase() throws ScmRepositoryException, NoSuchScmProviderException { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm:svn:http://localhost/home/svn/module/trunk" ); - releaseDescriptor.setScmTagBase( "http://localhost/home/svn/module/tags" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:http://localhost/home/svn/module/trunk" ); + builder.setScmTagBase( "http://localhost/home/svn/module/tags" ); - ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null ); + ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null ); SvnScmProviderRepository providerRepository = (SvnScmProviderRepository) repository.getProviderRepository(); assertEquals( "check tag base", "http://localhost/home/svn/module/tags", providerRepository.getTagBase() ); @@ -99,10 +100,10 @@ public void testGetConfiguredRepositoryWithHost() server.setPassphrase( "settings-passphrase" ); settings.addServer( server ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" ); - ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings ); + ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), settings ); ScmProviderRepositoryWithHost providerRepository = (ScmProviderRepositoryWithHost) repository.getProviderRepository(); @@ -125,10 +126,10 @@ public void testGetConfiguredRepositoryWithEncryptedPasswords() server.setPassphrase( "{7zK9P8hNVeUHbTsjiA/vnOs0zUXbND+9MBNPvdvl+x4=}" ); settings.addServer( server ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm:svn:svn://localhost/repo" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:svn:svn://localhost/repo" ); - ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings ); + ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), settings ); ScmProviderRepositoryWithHost providerRepository = (ScmProviderRepositoryWithHost) repository.getProviderRepository(); @@ -141,12 +142,12 @@ public void testGetConfiguredRepositoryWithEncryptedPasswords() public void testGetConfiguredRepositoryInvalidScmUrl() throws Exception { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm-url" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm-url" ); try { - scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null ); + scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null ); fail( "Expected failure to get a repository with an invalid SCM URL" ); } @@ -159,12 +160,12 @@ public void testGetConfiguredRepositoryInvalidScmUrl() public void testGetConfiguredRepositoryInvalidScmProvider() throws ScmRepositoryException { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm:url:" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:url:" ); try { - scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null ); + scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null ); fail( "Expected failure to get a repository with an invalid SCM URL" ); } @@ -177,12 +178,12 @@ public void testGetConfiguredRepositoryInvalidScmProvider() public void testGetConfiguredRepositoryInvalidScmUrlParameters() throws NoSuchScmProviderException { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm:cvs:" ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:cvs:" ); try { - scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null ); + scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null ); fail( "Expected failure to get a repository with an invalid SCM URL" ); } @@ -195,26 +196,26 @@ public void testGetConfiguredRepositoryInvalidScmUrlParameters() public void testGetRepositoryProvider() throws ScmRepositoryException, NoSuchScmProviderException { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); - ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null ); + ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null ); ScmProvider provider = scmRepositoryConfigurator.getRepositoryProvider( repository ); assertEquals( "Check SCM provider", "cvs", provider.getScmType() ); } - private static ReleaseDescriptor createReleaseDescriptor() + private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder() { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" ); - return releaseDescriptor; + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" ); + return builder; } - private static ReleaseDescriptor createReleaseDescriptor( String username, String password ) + private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder( String username, String password ) { - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); - releaseDescriptor.setScmUsername( username ); - releaseDescriptor.setScmPassword( password ); - return releaseDescriptor; + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(); + builder.setScmUsername( username ); + builder.setScmPassword( password ); + return builder; } } diff --git a/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml b/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml index 95ed5b8ec..ff026270b 100644 --- a/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml +++ b/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml @@ -37,9 +37,4 @@ subproject1 - - scm:svn:file://localhost/tmp/scm-repo/tags/release-label - scm:svn:file://localhost/tmp/scm-repo/tags/release-label - file://localhost/tmp/scm-repo/tags/release-label - \ No newline at end of file diff --git a/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy b/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy index bc7b56bcb..a41f9c30e 100644 --- a/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy +++ b/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy @@ -22,4 +22,3 @@ File releaseProperties = new File( basedir, 'release.properties' ) assert releaseProperties.exists() assert 1 == releaseProperties.getText().count("scm.id=it-server") -assert 1 == releaseProperties.getText().count("project.scm.org.apache.maven.plugin.release.its\\:mrelease-420.id=it-server") diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java index f6242ed4c..7dda66266 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java @@ -23,6 +23,7 @@ import java.util.Iterator; import java.util.List; +import org.apache.maven.artifact.ArtifactUtils; import org.apache.maven.execution.MavenSession; import org.apache.maven.plugin.AbstractMojo; import org.apache.maven.plugins.annotations.Component; @@ -30,7 +31,7 @@ import org.apache.maven.project.MavenProject; import org.apache.maven.settings.Settings; import org.apache.maven.shared.release.ReleaseManager; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; import org.apache.maven.shared.release.env.DefaultReleaseEnvironment; import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.codehaus.plexus.util.StringUtils; @@ -149,16 +150,22 @@ protected ReleaseEnvironment getReleaseEnvironment() * * @return The release descriptor, never null. */ - protected ReleaseDescriptor createReleaseDescriptor() + protected ReleaseDescriptorBuilder createReleaseDescriptor() { - ReleaseDescriptor descriptor = new ReleaseDescriptor(); - + ReleaseDescriptorBuilder descriptor = new ReleaseDescriptorBuilder(); + descriptor.setInteractive( settings.isInteractiveMode() ); descriptor.setWorkingDirectory( basedir.getAbsolutePath() ); descriptor.setPomFileName( pomFileName ); + for ( MavenProject project : reactorProjects ) + { + String versionlessKey = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ); + descriptor.putOriginalVersion( versionlessKey, project.getVersion() ); + } + List profileIds = session.getRequest().getActiveProfiles(); String additionalProfiles = getAdditionalProfiles(); @@ -270,25 +277,4 @@ protected void addArgument( String argument ) arguments = argument; } } - - /** - * This method takes some of the release configuration picked up from the command line system properties and copies - * it into the release config object. - * - * @param config The release configuration to merge the system properties into, must not be null. - * @param sysPropertiesConfig The configuration from the system properties to merge in, must not be - * null. - */ - protected void mergeCommandLineConfig( ReleaseDescriptor config, ReleaseDescriptor sysPropertiesConfig ) - { - // If the user specifies versions, these should override the existing versions - if ( sysPropertiesConfig.getReleaseVersions() != null ) - { - config.getReleaseVersions().putAll( sysPropertiesConfig.getReleaseVersions() ); - } - if ( sysPropertiesConfig.getDevelopmentVersions() != null ) - { - config.getDevelopmentVersions().putAll( sysPropertiesConfig.getDevelopmentVersions() ); - } - } } diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java index b57aab4aa..d75064ea2 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java @@ -21,12 +21,15 @@ import java.util.Map; +import org.apache.maven.artifact.ArtifactUtils; +import org.apache.maven.model.Scm; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugins.annotations.Component; import org.apache.maven.plugins.annotations.Parameter; +import org.apache.maven.project.MavenProject; import org.apache.maven.scm.manager.ScmManager; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; /** * Abstract Mojo containing SCM parameters @@ -127,9 +130,9 @@ public void execute() } @Override - protected ReleaseDescriptor createReleaseDescriptor() + protected ReleaseDescriptorBuilder createReleaseDescriptor() { - ReleaseDescriptor descriptor = super.createReleaseDescriptor(); + ReleaseDescriptorBuilder descriptor = super.createReleaseDescriptor(); descriptor.setScmPassword( password ); descriptor.setScmReleaseLabel( tag ); @@ -139,7 +142,51 @@ protected ReleaseDescriptor createReleaseDescriptor() descriptor.setScmCommentPrefix( scmCommentPrefix ); descriptor.setPushChanges( pushChanges ); + + if ( project.getScm() != null ) + { + if ( project.getScm().getDeveloperConnection() != null ) + { + descriptor.setScmSourceUrl( project.getScm().getDeveloperConnection() ); + } + else if ( project.getScm().getConnection() != null ) + { + descriptor.setScmSourceUrl( project.getScm().getConnection() ); + } + } + + // As long as Scm.getId() does not exist, read it as a property + descriptor.setScmId( project.getProperties().getProperty( "project.scm.id" ) ); + + for ( MavenProject reactorProject : session.getProjects() ) + { + if ( reactorProject.getScm() != null ) + { + String projectId = + ArtifactUtils.versionlessKey( reactorProject.getGroupId(), reactorProject.getArtifactId() ); + + descriptor.addOriginalScmInfo( projectId, buildScm( project ) ); + } + } return descriptor; } + + protected Scm buildScm( MavenProject project ) + { + Scm scm; + if ( project.getOriginalModel().getScm() == null ) + { + scm = null; + } + else + { + scm = new Scm(); + scm.setConnection( project.getOriginalModel().getScm().getConnection() ); + scm.setDeveloperConnection( project.getOriginalModel().getScm().getDeveloperConnection() ); + scm.setTag( project.getOriginalModel().getScm().getTag() ); + scm.setUrl( project.getOriginalModel().getScm().getUrl() ); + } + return scm; + } } diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java index 14829ea37..4378d24fa 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java @@ -28,8 +28,7 @@ import org.apache.maven.shared.release.ReleaseBranchRequest; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; -import org.apache.maven.shared.release.config.ReleaseUtils; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; /** * Branch a project in SCM, using the same steps as the release:prepare goal, creating a branch instead of a @@ -217,7 +216,7 @@ public void execute() { super.execute(); - ReleaseDescriptor config = createReleaseDescriptor(); + final ReleaseDescriptorBuilder config = createReleaseDescriptor(); config.setAddSchema( addSchema ); config.setScmUseEditMode( useEditMode ); config.setUpdateDependencies( updateDependencies ); @@ -235,11 +234,6 @@ public void execute() config.setProjectVersionPolicyId( projectVersionPolicyId ); config.setProjectNamingPolicyId( projectBranchNamingPolicyId ); - // Create a config containing values from the session properties (ie command line properties with cli). - ReleaseDescriptor sysPropertiesConfig - = ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() ); - mergeCommandLineConfig( config, sysPropertiesConfig ); - if ( checkModificationExcludeList != null ) { checkModificationExcludes = checkModificationExcludeList.replaceAll( "\\s", "" ).split( "," ); @@ -253,10 +247,11 @@ public void execute() try { ReleaseBranchRequest branchRequest = new ReleaseBranchRequest(); - branchRequest.setReleaseDescriptor( config ); + branchRequest.setReleaseDescriptorBuilder( config ); branchRequest.setReleaseEnvironment( getReleaseEnvironment() ); branchRequest.setReactorProjects( getReactorProjects() ); branchRequest.setDryRun( dryRun ); + branchRequest.setUserProperties( session.getUserProperties() ); releaseManager.branch( branchRequest ); } diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java index 186785b69..3de5857a8 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java @@ -24,7 +24,7 @@ import org.apache.maven.plugins.annotations.Mojo; import org.apache.maven.shared.release.ReleaseCleanRequest; import org.apache.maven.shared.release.ReleaseFailureException; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; /** * Clean up after a release preparation. This is done automatically after a successful release:perform, @@ -44,11 +44,11 @@ public class CleanReleaseMojo public void execute() throws MojoExecutionException, MojoFailureException { - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); + ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder(); releaseDescriptor.setWorkingDirectory( getBasedir().getAbsolutePath() ); ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest(); - cleanRequest.setReleaseDescriptor( releaseDescriptor ); + cleanRequest.setReleaseDescriptorBuilder( releaseDescriptor ); cleanRequest.setReactorProjects( getReactorProjects() ); try diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java index 4826f781f..9abd94f61 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java @@ -31,7 +31,7 @@ import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleasePerformRequest; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; import org.codehaus.plexus.util.StringUtils; /** @@ -166,7 +166,7 @@ public void execute() { setDeploymentRepository(); // Note that the working directory here is not the same as in the release configuration, so don't reuse that - ReleaseDescriptor releaseDescriptor = createReleaseDescriptor(); + ReleaseDescriptorBuilder releaseDescriptor = createReleaseDescriptor(); if ( connectionUrl != null ) { releaseDescriptor.setScmSourceUrl( connectionUrl ); @@ -191,7 +191,7 @@ public void execute() releaseDescriptor.setPerformGoals( goals ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( releaseDescriptor ); performRequest.setReleaseEnvironment( getReleaseEnvironment() ); performRequest.setReactorProjects( getReactorProjects() ); performRequest.setDryRun( dryRun ); diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java index a73962d9b..196f7271f 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java @@ -28,8 +28,7 @@ import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleasePrepareRequest; -import org.apache.maven.shared.release.config.ReleaseDescriptor; -import org.apache.maven.shared.release.config.ReleaseUtils; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; /** * Prepare for a release in SCM. Steps through several phases to ensure the POM is ready to be released and then @@ -259,7 +258,7 @@ protected void prepareRelease( boolean generateReleasePoms ) // above super.execute(); - ReleaseDescriptor config = createReleaseDescriptor(); + final ReleaseDescriptorBuilder config = createReleaseDescriptor(); config.setAddSchema( addSchema ); config.setGenerateReleasePoms( generateReleasePoms ); config.setScmUseEditMode( useEditMode ); @@ -288,18 +287,14 @@ protected void prepareRelease( boolean generateReleasePoms ) { config.setCheckModificationExcludes( Arrays.asList( checkModificationExcludes ) ); } - - // Create a config containing values from the session properties (ie command line properties with cli). - ReleaseDescriptor sysPropertiesConfig = - ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() ); - mergeCommandLineConfig( config, sysPropertiesConfig ); ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest(); - prepareRequest.setReleaseDescriptor( config ); + prepareRequest.setReleaseDescriptorBuilder( config ); prepareRequest.setReleaseEnvironment( getReleaseEnvironment() ); prepareRequest.setReactorProjects( getReactorProjects() ); prepareRequest.setResume( resume ); prepareRequest.setDryRun( dryRun ); + prepareRequest.setUserProperties( session.getUserProperties() ); try { diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java index cefcbbeb4..970dad6fc 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java @@ -49,7 +49,7 @@ public void execute() try { ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest(); - rollbackRequest.setReleaseDescriptor( createReleaseDescriptor() ); + rollbackRequest.setReleaseDescriptorBuilder( createReleaseDescriptor() ); rollbackRequest.setReleaseEnvironment( getReleaseEnvironment() ); rollbackRequest.setReactorProjects( getReactorProjects() ); diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java index 242ed2b83..2aa1e8e98 100644 --- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java +++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java @@ -27,8 +27,7 @@ import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleaseUpdateVersionsRequest; -import org.apache.maven.shared.release.config.ReleaseDescriptor; -import org.apache.maven.shared.release.config.ReleaseUtils; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; /** * Update the POM versions for a project. This performs the normal version updates of the release:prepare goal @@ -98,7 +97,7 @@ public class UpdateVersionsMojo public void execute() throws MojoExecutionException, MojoFailureException { - ReleaseDescriptor config = createReleaseDescriptor(); + final ReleaseDescriptorBuilder config = createReleaseDescriptor(); config.setAddSchema( addSchema ); config.setAutoVersionSubmodules( autoVersionSubmodules ); config.setDefaultDevelopmentVersion( developmentVersion ); @@ -109,17 +108,13 @@ public void execute() config.addOriginalScmInfo( ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ), project.getScm() ); - // Create a config containing values from the session properties (ie command line properties with cli). - ReleaseDescriptor sysPropertiesConfig = - ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() ); - mergeCommandLineConfig( config, sysPropertiesConfig ); - try { ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest(); - updateVersionsRequest.setReleaseDescriptor( config ); + updateVersionsRequest.setReleaseDescriptorBuilder( config ); updateVersionsRequest.setReleaseEnvironment( getReleaseEnvironment() ); updateVersionsRequest.setReactorProjects( getReactorProjects() ); + updateVersionsRequest.setUserProperties( session.getUserProperties() ); releaseManager.updateVersions( updateVersionsRequest ); } diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java index 2a972c310..d80848a54 100644 --- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java +++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java @@ -68,8 +68,6 @@ public void testClean() // verify verify( mock ).clean( request.capture() ); - assertEquals( workingDirectory.getAbsolutePath(), - request.getValue().getReleaseDescriptor().getWorkingDirectory() ); assertEquals( mojo.getReactorProjects(), request.getValue().getReactorProjects() ); verifyNoMoreInteractions( mock ); diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java index 09b5a52b6..16fc0269a 100644 --- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java +++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java @@ -27,6 +27,7 @@ import java.io.File; import java.util.Arrays; +import java.util.List; import org.apache.maven.execution.MavenSession; import org.apache.maven.model.DistributionManagement; @@ -40,7 +41,7 @@ import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleaseManager; import org.apache.maven.shared.release.ReleasePerformRequest; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; import org.mockito.ArgumentCaptor; /** @@ -58,11 +59,11 @@ public void testPerform() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site-deploy" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site-deploy" ); ReleaseManager mock = mock( ReleaseManager.class ); mojo.setReleaseManager( mock ); @@ -73,9 +74,9 @@ public void testPerform() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); } @@ -85,12 +86,12 @@ public void testPerformWithFlatStructure() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-flat-structure.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy" ); - releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy" ); + builder.setScmSourceUrl( "scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project" ); ReleaseManager mock = mock( ReleaseManager.class ); mojo.setReleaseManager( mock ); @@ -101,9 +102,9 @@ public void testPerformWithFlatStructure() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); } @@ -120,11 +121,11 @@ public void testPerformWithoutSite() MavenProject project = (MavenProject) getVariableValueFromObject( mojo, "project" ); setVariableValueToObject( mojo, "session", newMavenSession( project ) ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy" ); ReleaseManager mock = mock( ReleaseManager.class ); mojo.setReleaseManager( mock ); @@ -135,9 +136,9 @@ public void testPerformWithoutSite() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); } @@ -163,11 +164,11 @@ public void testPerformWithExecutionException() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site-deploy" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site-deploy" ); ReleaseManager mock = mock( ReleaseManager.class ); doThrow( new ReleaseExecutionException( "..." ) ).when( mock ).perform( isA( ReleasePerformRequest.class ) ); @@ -188,9 +189,9 @@ public void testPerformWithExecutionException() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); @@ -201,11 +202,11 @@ public void testPerformWithExecutionFailure() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site-deploy" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site-deploy" ); ReleaseManager mock = mock( ReleaseManager.class ); ReleaseFailureException cause = new ReleaseFailureException( "..." ); @@ -228,9 +229,9 @@ public void testPerformWithExecutionFailure() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); @@ -241,12 +242,12 @@ public void testPerformWithScm() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-scm.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site-deploy" ); - releaseDescriptor.setScmSourceUrl( "scm-url" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site-deploy" ); + builder.setScmSourceUrl( "scm-url" ); ReleaseManager mock = mock( ReleaseManager.class ); mojo.setReleaseManager( mock ); @@ -257,9 +258,9 @@ public void testPerformWithScm() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); @@ -270,12 +271,12 @@ public void testPerformWithProfiles() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site-deploy" ); - releaseDescriptor.setAdditionalArguments( "-P prof1,2prof" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site-deploy" ); + builder.setAdditionalArguments( "-P prof1,2prof" ); MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session"); Profile profile1 = new Profile(); @@ -295,9 +296,9 @@ public void testPerformWithProfiles() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); @@ -308,12 +309,12 @@ public void testPerformWithProfilesAndArguments() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-args.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site-deploy" ); - releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true -P prof1,2prof" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site-deploy" ); + builder.setAdditionalArguments( "-Dmaven.test.skip=true -P prof1,2prof" ); MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session"); Profile profile1 = new Profile(); @@ -333,9 +334,9 @@ public void testPerformWithProfilesAndArguments() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); @@ -346,11 +347,11 @@ public void testPerformWithMultilineGoals() { PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-multiline-goals.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo ); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site-deploy" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site-deploy" ); ReleaseManager mock = mock( ReleaseManager.class ); mojo.setReleaseManager( mock ); @@ -361,14 +362,28 @@ public void testPerformWithMultilineGoals() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); } + private ReleaseDescriptorBuilder createReleaseDescriptorBuilder( PerformReleaseMojo mojo ) throws Exception + { + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + + @SuppressWarnings( "unchecked" ) + List reactorProjects = (List) getVariableValueFromObject( mojo, "reactorProjects" ); + + for ( MavenProject project : reactorProjects ) + { + builder.putOriginalVersion( project.getGroupId() + ':' + project.getArtifactId(), project.getVersion() ); + } + + return builder; + } protected void setUp() throws Exception diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java index deca8a5d7..876044b7a 100644 --- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java +++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java @@ -22,7 +22,7 @@ import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; +import static org.hamcrest.CoreMatchers.notNullValue; import static org.junit.Assert.assertThat; import static org.mockito.Matchers.isA; @@ -32,17 +32,20 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import java.io.File; +import java.util.Collections; +import java.util.List; import java.util.Properties; import org.apache.maven.execution.MavenSession; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugin.testing.AbstractMojoTestCase; +import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.ReleaseExecutionException; import org.apache.maven.shared.release.ReleaseFailureException; import org.apache.maven.shared.release.ReleaseManager; import org.apache.maven.shared.release.ReleasePrepareRequest; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; import org.apache.maven.shared.release.env.ReleaseEnvironment; import org.mockito.ArgumentCaptor; @@ -64,19 +67,26 @@ public void testPrepare() throws Exception { File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" ); - PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile ); + final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile ); setDefaults( mojo ); mojo.setBasedir( testFile.getParentFile() ); mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null ) { - public Properties getExecutionProperties(){ - return new Properties(); - }; + public Properties getExecutionProperties() + { + return new Properties(); + }; + + @Override + public List getProjects() + { + return Collections.singletonList( mojo.project ); + } }; - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() ); - releaseDescriptor.setUpdateDependencies( false ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() ); + builder.setUpdateDependencies( false ); ReleaseManager mock = mock( ReleaseManager.class ); mojo.setReleaseManager( mock ); @@ -89,9 +99,10 @@ public Properties getExecutionProperties(){ // verify verify( mock ).prepare( prepareRequest.capture() ); - assertThat( prepareRequest.getValue().getReleaseDescriptor(), is( releaseDescriptor ) ); - assertThat( prepareRequest.getValue().getReleaseEnvironment(), is(instanceOf( ReleaseEnvironment.class ) ) ); - assertThat( prepareRequest.getValue().getReactorProjects(), is( nullValue() ) ); + assertThat( prepareRequest.getValue().getReleaseDescriptorBuilder(), + is( instanceOf( ReleaseDescriptorBuilder.class ) ) ); + assertThat( prepareRequest.getValue().getReleaseEnvironment(), is( instanceOf( ReleaseEnvironment.class ) ) ); + assertThat( prepareRequest.getValue().getReactorProjects(), is( notNullValue() ) ); assertThat( prepareRequest.getValue().getResume(), is( true ) ); assertThat( prepareRequest.getValue().getDryRun(), is( false ) ); } @@ -100,7 +111,7 @@ public void testPrepareWithExecutionException() throws Exception { File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" ); - PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile ); + final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile ); setDefaults( mojo ); mojo.setBasedir( testFile.getParentFile() ); mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null ) @@ -108,11 +119,14 @@ public void testPrepareWithExecutionException() public Properties getExecutionProperties(){ return new Properties(); }; + + @Override + public List getProjects() + { + return Collections.singletonList( mojo.project ); + } }; - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() ); - releaseDescriptor.setUpdateDependencies( false ); - + ReleaseManager mock = mock( ReleaseManager.class ); doThrow( new ReleaseExecutionException( "..." ) ).when( mock ).prepare( isA( ReleasePrepareRequest.class ) ); mojo.setReleaseManager( mock ); @@ -138,7 +152,7 @@ public void testPrepareWithExecutionFailure() throws Exception { File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" ); - PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile ); + final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile ); setDefaults( mojo ); mojo.setBasedir( testFile.getParentFile() ); mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null ) @@ -146,10 +160,13 @@ public void testPrepareWithExecutionFailure() public Properties getExecutionProperties(){ return new Properties(); }; + + @Override + public List getProjects() + { + return Collections.singletonList( mojo.project ); + } }; - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() ); - releaseDescriptor.setUpdateDependencies( false ); ReleaseManager mock = mock( ReleaseManager.class ); ReleaseFailureException cause = new ReleaseFailureException( "..." ); diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java index 092d77e62..b88eb2414 100644 --- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java +++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java @@ -31,7 +31,7 @@ import org.apache.maven.project.MavenProject; import org.apache.maven.shared.release.ReleaseManager; import org.apache.maven.shared.release.ReleasePerformRequest; -import org.apache.maven.shared.release.config.ReleaseDescriptor; +import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder; import org.mockito.ArgumentCaptor; /** @@ -49,15 +49,15 @@ public void testStage() { StageReleaseMojo mojo = getMojoWithProjectSite( "stage.xml" ); - ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor(); - releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() ); + ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder(); + builder.setWorkingDirectory( workingDirectory.getAbsolutePath() ); File checkoutDirectory = getTestFile( "target/checkout" ); - releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); - releaseDescriptor.setPerformGoals( "deploy site:stage-deploy" ); - releaseDescriptor.setAdditionalArguments( "-DaltDeploymentRepository=\"staging\"" ); + builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() ); + builder.setPerformGoals( "deploy site:stage-deploy" ); + builder.setAdditionalArguments( "-DaltDeploymentRepository=\"staging\"" ); ReleasePerformRequest performRequest = new ReleasePerformRequest(); - performRequest.setReleaseDescriptor( releaseDescriptor ); + performRequest.setReleaseDescriptorBuilder( builder ); performRequest.setReleaseEnvironment( mojo.getReleaseEnvironment() ); performRequest.setReactorProjects( mojo.getReactorProjects() ); performRequest.setDryRun( false ); @@ -70,9 +70,9 @@ public void testStage() // verify ArgumentCaptor argument = ArgumentCaptor.forClass(ReleasePerformRequest.class); verify( mock ).perform( argument.capture() ); - assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() ); + assertNotNull( argument.getValue().getReleaseDescriptorBuilder() ); assertNotNull( argument.getValue().getReleaseEnvironment() ); - assertNull( argument.getValue().getReactorProjects() ); + assertNotNull( argument.getValue().getReactorProjects() ); assertEquals( Boolean.FALSE, argument.getValue().getDryRun() ); verifyNoMoreInteractions( mock ); } diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java index 99ee9e283..7617d4129 100644 --- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java +++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java @@ -82,5 +82,22 @@ public Scm getScm() return scm; } - + + @Override + public String getGroupId() + { + return "GROUPID"; + } + + @Override + public String getArtifactId() + { + return "ARTIFACTID"; + } + + @Override + public String getVersion() + { + return "VERSION"; + } } diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java index 44f654f64..63eefa4d0 100644 --- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java +++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java @@ -54,4 +54,22 @@ public DistributionManagement getDistributionManagement() { return getModel().getDistributionManagement(); } + + @Override + public String getGroupId() + { + return "GROUPID"; + } + + @Override + public String getArtifactId() + { + return "ARTIFACTID"; + } + + @Override + public String getVersion() + { + return "VERSION"; + } } diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml index 1ea3faa0d..14af0dca5 100644 --- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml +++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml @@ -26,6 +26,9 @@ + + + ${basedir}/target/checkout true deploy site-deploy diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml index 074acfe97..32e25fcb2 100644 --- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml +++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml @@ -26,6 +26,9 @@ + + + ${basedir}/target/checkout true scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml index ad13c4811..f54463988 100644 --- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml +++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml @@ -26,6 +26,9 @@ + + + ${basedir}/target/checkout true diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml index 02849c997..cb8a86603 100644 --- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml +++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml @@ -26,6 +26,9 @@ + + + ${basedir}/target/checkout true scm-url diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml index c4d826ab5..be9fcbb0b 100644 --- a/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml +++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml @@ -26,6 +26,9 @@ + + + ${basedir}/target/checkout deploy true diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform.xml index 87b529f2e..0580f0042 100644 --- a/maven-release-plugin/src/test/resources/mojos/perform/perform.xml +++ b/maven-release-plugin/src/test/resources/mojos/perform/perform.xml @@ -26,6 +26,9 @@ + + + ${basedir}/target/checkout deploy site-deploy true diff --git a/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml b/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml index bec7b4948..623ff2b86 100644 --- a/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml +++ b/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml @@ -26,6 +26,9 @@ + + + true diff --git a/maven-release-plugin/src/test/resources/mojos/stage/stage.xml b/maven-release-plugin/src/test/resources/mojos/stage/stage.xml index a8f5ea06f..d1ac5835e 100644 --- a/maven-release-plugin/src/test/resources/mojos/stage/stage.xml +++ b/maven-release-plugin/src/test/resources/mojos/stage/stage.xml @@ -26,6 +26,9 @@ + + + ${basedir}/target/checkout staging deploy site-deploy