You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by rf...@apache.org on 2018/02/10 16:22:10 UTC
[maven-release] branch master updated: [MRELEASE-998] Add ability
to create custom phases
This is an automated email from the ASF dual-hosted git repository.
rfscholte pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-release.git
The following commit(s) were added to refs/heads/master by this push:
new 419114d [MRELEASE-998] Add ability to create custom phases
419114d is described below
commit 419114d796c3dea8718f51606ff0482232184487
Author: rfscholte <rf...@apache.org>
AuthorDate: Sat Feb 10 17:21:50 2018 +0100
[MRELEASE-998] Add ability to create custom phases
---
maven-release-api/pom.xml | 12 +
.../shared/release/ReleaseExecutionException.java | 0
.../shared/release/ReleaseFailureException.java | 0
.../apache/maven/shared/release/ReleaseResult.java | 6 -
.../shared/release/config/ReleaseDescriptor.java | 158 +++
.../shared/release/env/ReleaseEnvironment.java | 18 -
.../maven/shared/release/phase/ReleasePhase.java | 0
.../shared/release/AbstractReleaseRequest.java | 12 +-
.../shared/release/DefaultReleaseManager.java | 98 +-
.../maven/shared/release/ReleaseBranchRequest.java | 13 +
.../shared/release/ReleasePrepareRequest.java | 14 +
.../release/ReleaseUpdateVersionsRequest.java | 14 +
.../config/PropertiesReleaseDescriptorStore.java | 53 +-
.../release/config/ReleaseDescriptorBuilder.java | 399 +++++++
.../release/config/ReleaseDescriptorStore.java | 2 +-
.../maven/shared/release/config/ReleaseUtils.java | 273 ++---
.../release/env/DefaultReleaseEnvironment.java | 18 +-
.../release/phase/AbstractRewritePomsPhase.java | 139 +--
.../phase/CheckDependencySnapshotsPhase.java | 104 +-
.../maven/shared/release/phase/CheckPomPhase.java | 19 +-
.../release/phase/CheckoutProjectFromScm.java | 13 +-
.../release/phase/GenerateReleasePomsPhase.java | 58 +-
.../shared/release/phase/InputVariablesPhase.java | 2 +-
.../shared/release/phase/MapVersionsPhase.java | 22 +-
.../release/phase/RewritePomVersionsPhase.java | 14 +-
.../release/phase/RewritePomsForBranchPhase.java | 31 +-
.../phase/RewritePomsForDevelopmentPhase.java | 32 +-
.../release/phase/RewritePomsForReleasePhase.java | 31 +-
.../maven/shared/release/util/ReleaseUtil.java | 10 +-
.../src/main/mdo/release-descriptor.mdo | 528 +++++-----
.../shared/release/DefaultReleaseManagerTest.java | 182 ++--
.../PropertiesReleaseDescriptorStoreTest.java | 250 ++---
.../release/config/ReleaseDescriptorStoreStub.java | 10 +-
.../shared/release/config/ReleaseUtilsTest.java | 345 +++---
.../release/exec/ForkedMavenExecutorTest.java | 3 +-
.../release/exec/InvokerMavenExecutorTest.java | 3 +-
...tractEditModeRewritingReleasePhaseTestCase.java | 45 +-
.../release/phase/AbstractReleaseTestCase.java | 11 +
.../AbstractRewritingReleasePhaseTestCase.java | 271 ++---
.../release/phase/AbstractScmCommitPhaseTest.java | 28 +-
.../phase/BranchInputVariablesPhaseTest.java | 121 +--
.../phase/CheckDependencySnapshotsPhaseTest.java | 323 +++---
.../shared/release/phase/CheckPomPhaseTest.java | 84 +-
.../release/phase/CheckoutProjectFromScmTest.java | 61 +-
.../shared/release/phase/EndReleasePhaseTest.java | 9 +-
.../phase/GenerateReleasePomsPhaseTest.java | 81 +-
.../release/phase/InputVariablesPhaseTest.java | 163 +--
.../phase/MapDevelopmentVersionPhaseIT.java | 15 +-
.../shared/release/phase/MapVersionsPhaseTest.java | 1099 ++++++++++----------
.../release/phase/RemoveReleasePomsPhaseTest.java | 54 +-
.../release/phase/RestoreBackupPomsPhaseTest.java | 16 +-
.../phase/RewritePomsForBranchPhaseTest.java | 195 ++--
.../phase/RewritePomsForDevelopmentPhaseTest.java | 212 ++--
.../phase/RewritePomsForReleasePhaseTest.java | 197 ++--
.../release/phase/RunCompleteGoalsPhaseTest.java | 45 +-
.../release/phase/RunPerformGoalsPhaseTest.java | 83 +-
.../release/phase/RunPrepareGoalsPhaseTest.java | 45 +-
.../shared/release/phase/ScmBranchPhaseTest.java | 103 +-
.../phase/ScmCheckModificationsPhaseTest.java | 127 +--
.../phase/ScmCommitDevelopmentPhaseTest.java | 39 +-
.../phase/ScmCommitPreparationPhaseTest.java | 111 +-
.../shared/release/phase/ScmTagPhaseTest.java | 103 +-
.../scm/DefaultScmRepositoryConfiguratorTest.java | 71 +-
.../basic-pom-inherited-scm/pom.xml | 5 -
.../it/projects/prepare/MRELEASE-420/verify.groovy | 1 -
.../maven/plugins/release/AbstractReleaseMojo.java | 36 +-
.../plugins/release/AbstractScmReleaseMojo.java | 53 +-
.../maven/plugins/release/BranchReleaseMojo.java | 13 +-
.../maven/plugins/release/CleanReleaseMojo.java | 6 +-
.../maven/plugins/release/PerformReleaseMojo.java | 6 +-
.../maven/plugins/release/PrepareReleaseMojo.java | 13 +-
.../maven/plugins/release/RollbackReleaseMojo.java | 2 +-
.../maven/plugins/release/UpdateVersionsMojo.java | 13 +-
.../plugins/release/CleanReleaseMojoTest.java | 2 -
.../plugins/release/PerformReleaseMojoTest.java | 133 +--
.../plugins/release/PrepareReleaseMojoTest.java | 59 +-
.../plugins/release/StageReleaseMojoTest.java | 18 +-
.../stubs/FlatMultiModuleMavenProjectStub.java | 19 +-
.../plugins/release/stubs/MavenProjectStub.java | 18 +
.../resources/mojos/perform/perform-with-args.xml | 3 +
.../mojos/perform/perform-with-flat-structure.xml | 3 +
.../mojos/perform/perform-with-multiline-goals.xml | 3 +
.../resources/mojos/perform/perform-with-scm.xml | 3 +
.../mojos/perform/perform-without-site.xml | 3 +
.../src/test/resources/mojos/perform/perform.xml | 3 +
.../src/test/resources/mojos/prepare/prepare.xml | 3 +
.../src/test/resources/mojos/stage/stage.xml | 3 +
87 files changed, 3760 insertions(+), 3259 deletions(-)
diff --git a/maven-release-api/pom.xml b/maven-release-api/pom.xml
index e96feff..03985e6 100644
--- a/maven-release-api/pom.xml
+++ b/maven-release-api/pom.xml
@@ -41,6 +41,18 @@
<artifactId>maven-artifact</artifactId>
</dependency>
<dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-core</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-model</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-settings</artifactId>
+ </dependency>
+ <dependency>
<groupId>org.eclipse.aether</groupId>
<artifactId>aether-util</artifactId>
<version>1.0.0.v20140518</version>
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 088e820..04547ed 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 @@ public class ReleaseResult
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 0000000..d9aa16a
--- /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<String> 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 dbbf86c..88ef9e2 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 8e7070e..470c6c2 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 @@ package org.apache.maven.shared.release;
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 @@ import org.apache.maven.shared.release.config.ReleaseDescriptor;
*/
public abstract class AbstractReleaseRequest
{
- private ReleaseDescriptor releaseDescriptor;
+ private ReleaseDescriptorBuilder releaseDescriptorBuilder;
private List<MavenProject> 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 ad93daa..1cbcb89 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 java.util.Set;
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 class DefaultReleaseManager
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 @@ public class DefaultReleaseManager
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 class DefaultReleaseManager
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 @@ public class DefaultReleaseManager
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 class DefaultReleaseManager
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 @@ public class DefaultReleaseManager
}
}
- 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 @@ public class DefaultReleaseManager
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 class DefaultReleaseManager
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 9900a17..45b69c8 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 @@ package org.apache.maven.shared.release;
* 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 class ReleaseBranchRequest extends AbstractReleaseRequest
{
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 1ab4a2b..7ac6915 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 @@ package org.apache.maven.shared.release;
* 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 class ReleasePrepareRequest
{
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 ba87ad0..81c768c 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 @@ package org.apache.maven.shared.release;
* 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 class ReleaseUpdateVersionsRequest
{
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 7256ce3..259d9a3 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.Map;
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 class PropertiesReleaseDescriptorStore
"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 class PropertiesReleaseDescriptorStore
}
}
- 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 class PropertiesReleaseDescriptorStore
// others boolean properties are not written to the properties file because the value from the caller is always
// used
- for ( Map.Entry<String, String> entry : config.getReleaseVersions().entrySet() )
- {
- properties.setProperty( "project.rel." + entry.getKey(), entry.getValue() );
- }
-
- for ( Map.Entry<String, String> entry : config.getDevelopmentVersions().entrySet() )
+
+ for ( Map.Entry<String, ReleaseStageVersions> 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<String, Scm> entry : config.getOriginalScmInfo().entrySet() )
@@ -290,16 +299,16 @@ public class PropertiesReleaseDescriptorStore
}
}
- private void processResolvedDependencies( Properties prop, Map<String, Map<String, String>> resolvedDependencies )
+ private void processResolvedDependencies( Properties prop, Map<String, ReleaseStageVersions> resolvedDependencies )
{
- for ( Map.Entry<String, Map<String, String>> currentEntry : resolvedDependencies.entrySet() )
+ for ( Map.Entry<String, ReleaseStageVersions> currentEntry : resolvedDependencies.entrySet() )
{
- Map<String, String> 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 0000000..c2ed277
--- /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<String> 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 5b1e8c4..69092c1 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 743b062..36504c2 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 @@ package org.apache.maven.shared.release.config;
* 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 @@ import org.apache.maven.shared.release.scm.IdentifiedScm;
*/
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
- * <code>workingDirectory</code> field. The <code>completedPhase</code> 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 class ReleaseUtils
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 @@ public class ReleaseUtils
{
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 @@ public class ReleaseUtils
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<String, Map<String, String>> resolvedDependencies = new HashMap<>();
-
Set entries = prop.entrySet();
Iterator<Entry<String, String>> iterator = entries.iterator();
String propertyName;
@@ -245,23 +208,20 @@ public class ReleaseUtils
if ( propertyName.startsWith( "dependency." ) )
{
- Map<String, String> 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 @@ public class ReleaseUtils
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 6b5659e..3305756 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 class DefaultReleaseEnvironment
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 class DefaultReleaseEnvironment
return mavenExecutorId;
}
- @Override
- public ReleaseEnvironment setMavenExecutorId( String mavenExecutorId )
+ public DefaultReleaseEnvironment setMavenExecutorId( String mavenExecutorId )
{
this.mavenExecutorId = mavenExecutorId;
return this;
@@ -88,8 +85,7 @@ public class DefaultReleaseEnvironment
return javaHome;
}
- @Override
- public ReleaseEnvironment setJavaHome( File javaHome )
+ public DefaultReleaseEnvironment setJavaHome( File javaHome )
{
this.javaHome = javaHome;
return this;
@@ -108,8 +104,7 @@ public class DefaultReleaseEnvironment
return localRepo;
}
- @Override
- public ReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory )
+ public DefaultReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory )
{
this.localRepositoryDirectory = localRepositoryDirectory;
return this;
@@ -121,8 +116,7 @@ public class DefaultReleaseEnvironment
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 6fd4cb6..ac6a682 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.Model;
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.ReleaseFailureException;
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 @@ public abstract class AbstractRewritePomsPhase
ReleaseResult result, boolean simulate )
throws ReleaseExecutionException, ReleaseFailureException
{
- Map<String, String> mappedVersions = getNextVersionMap( releaseDescriptor );
- Map<String, String> originalVersions = getOriginalVersionMap( releaseDescriptor, reactorProjects, simulate );
- Map<String, Map<String, String>> 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 @@ public abstract class AbstractRewritePomsPhase
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 @@ public abstract class AbstractRewritePomsPhase
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 @@ public abstract class AbstractRewritePomsPhase
commonBasedir );
}
- private void rewriteVersion( Model modelTarget, Map<String, String> 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 @@ public abstract class AbstractRewritePomsPhase
modelTarget.setVersion( version );
}
- private String rewriteParent( MavenProject project, Model targetModel, Map<String, String> mappedVersions,
- Map<String, Map<String, String>> resolvedSnapshotDependencies,
- Map<String, String> originalVersions )
+ private String rewriteParent( MavenProject project, Model targetModel,
+ ReleaseDescriptor releaseDescriptor, boolean simulate )
throws ReleaseFailureException
{
String parentVersion = null;
@@ -383,15 +364,16 @@ public abstract class AbstractRewritePomsPhase
{
MavenProject parent = project.getParent();
String key = ArtifactUtils.versionlessKey( parent.getGroupId(), parent.getArtifactId() );
- parentVersion = mappedVersions.get( key );
+ parentVersion = getNextVersion( releaseDescriptor, key );
if ( parentVersion == null )
{
//MRELEASE-317
- parentVersion = getResolvedSnapshotVersion( key, resolvedSnapshotDependencies );
+ parentVersion = getResolvedSnapshotVersion( key, releaseDescriptor );
}
if ( parentVersion == null )
{
- if ( parent.getVersion().equals( originalVersions.get( key ) ) )
+ String original = getOriginalVersion( releaseDescriptor, key, simulate );
+ if ( parent.getVersion().equals( original ) )
{
throw new ReleaseFailureException( "Version for parent '" + parent.getName() + "' was not mapped" );
}
@@ -404,11 +386,9 @@ public abstract class AbstractRewritePomsPhase
return parentVersion;
}
- private void rewriteArtifactVersions( Collection<MavenCoordinate> elements, Map<String, String> mappedVersions,
- Map<String, Map<String, String>> resolvedSnapshotDependencies,
- Map<String, String> originalVersions, Model projectModel,
+ private void rewriteArtifactVersions( Collection<MavenCoordinate> elements, Model projectModel,
Properties properties, ReleaseResult result,
- ReleaseDescriptor releaseDescriptor )
+ ReleaseDescriptor releaseDescriptor, boolean simulate )
throws ReleaseExecutionException, ReleaseFailureException
{
if ( elements == null )
@@ -449,12 +429,12 @@ public abstract class AbstractRewritePomsPhase
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 @@ public abstract class AbstractRewritePomsPhase
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 @@ public abstract class AbstractRewritePomsPhase
protected abstract String getResolvedSnapshotVersion( String artifactVersionlessKey,
- Map<String, Map<String, String>> resolvedSnapshots );
+ ReleaseDescriptor releaseDscriptor );
- protected abstract Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
- List<MavenProject> reactorProjects,
- boolean simulate );
+ protected abstract String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey,
+ boolean simulate );
- protected abstract Map<String, String> 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 @@ public abstract class AbstractRewritePomsPhase
}
protected String getOriginalResolvedSnapshotVersion( String artifactVersionlessKey,
- Map<String, Map<String, String>> resolvedSnapshots )
+ ReleaseDescriptor releaseDescriptor )
{
- Map<String, String> 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 cc762c9..4dd43b7 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 @@ package org.apache.maven.shared.release.phase;
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<Artifact> usedSnapshotDependencies = new HashSet<>();
- private Set<Artifact> usedSnapshotReports = new HashSet<>();
- private Set<Artifact> usedSnapshotExtensions = new HashSet<>();
- private Set<Artifact> usedSnapshotPlugins = new HashSet<>();
// Don't prompt for every project in reactor, remember state of questions
private String resolveSnapshot;
@@ -99,11 +94,9 @@ public class CheckDependencySnapshotsPhase
{
logInfo( result, "Checking dependencies and plugins for snapshots ..." );
- Map<String, String> originalVersions = releaseDescriptor.getOriginalVersions( reactorProjects );
-
for ( MavenProject project : reactorProjects )
{
- checkProject( project, originalVersions, releaseDescriptor );
+ checkProject( project, releaseDescriptor );
}
}
else
@@ -115,35 +108,36 @@ public class CheckDependencySnapshotsPhase
return result;
}
- private void checkProject( MavenProject project, Map<String, String> originalVersions,
- ReleaseDescriptor releaseDescriptor )
+ private void checkProject( MavenProject project, ReleaseDescriptor releaseDescriptor )
throws ReleaseFailureException, ReleaseExecutionException
{
Map<String, Artifact> artifactMap = ArtifactUtils.artifactMapByVersionlessId( project.getArtifacts() );
+
+ Set<Artifact> 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<Artifact> dependencyArtifacts = project.getArtifacts();
- checkDependencies( originalVersions, releaseDescriptor, artifactMap, dependencyArtifacts );
+ usedSnapshotDependencies.addAll( checkDependencies( releaseDescriptor, artifactMap, dependencyArtifacts ) );
//@todo check dependencyManagement
Set<Artifact> pluginArtifacts = project.getPluginArtifacts();
- checkPlugins( originalVersions, releaseDescriptor, artifactMap, pluginArtifacts );
+ Set<Artifact> usedSnapshotPlugins = checkPlugins( releaseDescriptor, artifactMap, pluginArtifacts );
//@todo check pluginManagement
Set<Artifact> reportArtifacts = project.getReportArtifacts();
- checkReports( originalVersions, releaseDescriptor, artifactMap, reportArtifacts );
+ Set<Artifact> usedSnapshotReports = checkReports( releaseDescriptor, artifactMap, reportArtifacts );
Set<Artifact> extensionArtifacts = project.getExtensionArtifacts();
- checkExtensions( originalVersions, releaseDescriptor, artifactMap, extensionArtifacts );
+ Set<Artifact> usedSnapshotExtensions = checkExtensions( releaseDescriptor, artifactMap, extensionArtifacts );
//@todo check profiles
@@ -173,13 +167,14 @@ public class CheckDependencySnapshotsPhase
}
}
- private void checkPlugins( Map<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
+ private Set<Artifact> checkPlugins( ReleaseDescriptor releaseDescriptor,
Map<String, Artifact> artifactMap, Set<Artifact> pluginArtifacts )
throws ReleaseExecutionException
{
+ Set<Artifact> usedSnapshotPlugins = new HashSet<>();
for ( Artifact artifact : pluginArtifacts )
{
- if ( checkArtifact( artifact, originalVersions, artifactMap, releaseDescriptor ) )
+ if ( checkArtifact( artifact, artifactMap, releaseDescriptor ) )
{
boolean addToFailures;
@@ -212,7 +207,6 @@ public class CheckDependencySnapshotsPhase
if ( result.toLowerCase( Locale.ENGLISH ).startsWith( "y" ) )
{
addToFailures = false;
- releaseDescriptor.setSnapshotReleasePluginAllowed( true );
}
else
{
@@ -240,52 +234,60 @@ public class CheckDependencySnapshotsPhase
}
}
}
+ return usedSnapshotPlugins;
}
- private void checkDependencies( Map<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
- Map<String, Artifact> artifactMap, Set<Artifact> dependencyArtifacts )
+ private Set<Artifact> checkDependencies( ReleaseDescriptor releaseDescriptor,
+ Map<String, Artifact> artifactMap,
+ Set<Artifact> dependencyArtifacts )
{
+ Set<Artifact> 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<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
+ private Set<Artifact> checkReports( ReleaseDescriptor releaseDescriptor,
Map<String, Artifact> artifactMap, Set<Artifact> reportArtifacts )
{
+ Set<Artifact> 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<String, String> originalVersions, ReleaseDescriptor releaseDescriptor,
+ private Set<Artifact> checkExtensions( ReleaseDescriptor releaseDescriptor,
Map<String, Artifact> artifactMap, Set<Artifact> extensionArtifacts )
{
+ Set<Artifact> 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<String, String> originalVersions,
+ private static boolean checkArtifact( Artifact artifact,
Map<String, Artifact> artifactMapByVersionlessId,
ReleaseDescriptor releaseDescriptor )
{
Artifact checkArtifact = getArtifactFromMap( artifact, artifactMapByVersionlessId );
- return checkArtifact( checkArtifact, originalVersions, releaseDescriptor );
+ return checkArtifact( checkArtifact, releaseDescriptor );
}
private static Artifact getArtifactFromMap( Artifact artifact, Map<String, Artifact> artifactMapByVersionlessId )
@@ -300,16 +302,14 @@ public class CheckDependencySnapshotsPhase
return checkArtifact;
}
- private static boolean checkArtifact( Artifact artifact, Map<String, String> 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 @@ public class CheckDependencySnapshotsPhase
if ( resolveSnapshot.toLowerCase( Locale.ENGLISH ).startsWith( "y" ) )
{
- Map<String, Map<String, String>> resolvedSnapshots = null;
-
if ( resolveSnapshotType == null )
{
prompter.showMessage( RESOLVE_SNAPSHOT_TYPE_MESSAGE );
@@ -381,36 +379,34 @@ public class CheckDependencySnapshotsPhase
{
// 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 @@ public class CheckDependencySnapshotsPhase
}
}
- private Map<String, Map<String, String>> processSnapshot( Set<Artifact> snapshotSet )
+ private void processSnapshot( Set<Artifact> snapshotSet, ReleaseDescriptor releaseDescriptor )
throws PrompterException, VersionParseException
{
- Map<String, Map<String, String>> resolvedSnapshots = new HashMap<>();
Iterator<Artifact> iterator = snapshotSet.iterator();
while ( iterator.hasNext() )
@@ -430,15 +425,15 @@ public class CheckDependencySnapshotsPhase
Artifact currentArtifact = iterator.next();
String versionlessKey = ArtifactUtils.versionlessKey( currentArtifact );
- Map<String, String> 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 @@ public class CheckDependencySnapshotsPhase
}
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 b5066d2..128721f 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.config.ReleaseDescriptor;
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 class CheckPomPhase
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 eec0f2c..33f9537 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 @@ public class CheckoutProjectFromScm
}
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 fbb0749..455f9b4 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 @@ public class GenerateReleasePomsPhase
ReleaseResult result )
throws ReleaseFailureException, ReleaseExecutionException
{
- Map<String, String> originalVersions = getOriginalVersionMap( releaseDescriptor, reactorProjects );
- Map<String, String> mappedVersions = getNextVersionMap( releaseDescriptor );
-
MavenProject releaseProject = project.clone();
Model releaseModel = releaseProject.getModel();
@@ -232,7 +229,7 @@ public class GenerateReleasePomsPhase
// 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 @@ public class GenerateReleasePomsPhase
}
// 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 class GenerateReleasePomsPhase
return execute( releaseDescriptor, releaseEnvironment, reactorProjects, true );
}
- protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
- List<MavenProject> reactorProjects )
- {
- return releaseDescriptor.getOriginalVersions( reactorProjects );
- }
-
- protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
- {
- return releaseDescriptor.getReleaseVersions();
- }
-
- private String getNextVersion( Map<String, String> mappedVersions, String groupId, String artifactId,
+ private String getNextVersion( ReleaseDescriptor releaseDescriptor, String groupId, String artifactId,
String version )
throws ReleaseFailureException
{
@@ -438,7 +424,7 @@ public class GenerateReleasePomsPhase
String id = ArtifactUtils.versionlessKey( groupId, artifactId );
- String nextVersion = mappedVersions.get( id );
+ String nextVersion = releaseDescriptor.getProjectReleaseVersion( id );
if ( nextVersion == null )
{
@@ -489,8 +475,8 @@ public class GenerateReleasePomsPhase
return releaseScm;
}
- private List<Dependency> createReleaseDependencies( Map<String, String> originalVersions,
- Map<String, String> mappedVersions, MavenProject project )
+ private List<Dependency> createReleaseDependencies( ReleaseDescriptor releaseDescriptor,
+ MavenProject project )
throws ReleaseFailureException
{
Set<Artifact> artifacts = project.getArtifacts();
@@ -513,7 +499,7 @@ public class GenerateReleasePomsPhase
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 @@ public class GenerateReleasePomsPhase
return releaseDependencies;
}
- private String getReleaseVersion( Map<String, String> originalVersions, Map<String, String> 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 @@ public class GenerateReleasePomsPhase
return version;
}
- private List<Plugin> createReleasePlugins( Map<String, String> originalVersions,
- Map<String, String> mappedVersions, MavenProject project )
+ private List<Plugin> createReleasePlugins( ReleaseDescriptor releaseDescriptor,
+ MavenProject project )
throws ReleaseFailureException
{
List<Plugin> releasePlugins = null;
@@ -583,7 +569,7 @@ public class GenerateReleasePomsPhase
{
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 @@ public class GenerateReleasePomsPhase
return releasePlugins;
}
- private List<ReportPlugin> createReleaseReportPlugins( Map<String, String> originalVersions,
- Map<String, String> mappedVersions, MavenProject project )
+ private List<ReportPlugin> createReleaseReportPlugins( ReleaseDescriptor releaseDescriptor,
+ MavenProject project )
throws ReleaseFailureException
{
List<ReportPlugin> releaseReportPlugins = null;
@@ -629,7 +615,7 @@ public class GenerateReleasePomsPhase
{
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 @@ public class GenerateReleasePomsPhase
return releaseReportPlugins;
}
- private List<Extension> createReleaseExtensions( Map<String, String> originalVersions,
- Map<String, String> mappedVersions, MavenProject project )
+ private List<Extension> createReleaseExtensions( ReleaseDescriptor releaseDescriptor,
+ MavenProject project )
throws ReleaseFailureException
{
List<Extension> releaseExtensions = null;
@@ -668,7 +654,7 @@ public class GenerateReleasePomsPhase
{
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 985b9cf..c155e3c 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 class InputVariablesPhase
{
// 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 eedf50a..1b585ab 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 class MapVersionsPhase
{
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 class MapVersionsPhase
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 class MapVersionsPhase
{
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 @@ public class MapVersionsPhase
String defaultVersion = releaseDescriptor.getDefaultDevelopmentVersion();
if ( StringUtils.isEmpty( defaultVersion ) )
{
- defaultVersion = releaseDescriptor.getDevelopmentVersions().get( projectId );
+ defaultVersion = releaseDescriptor.getProjectDevelopmentVersion( projectId );
}
return defaultVersion;
}
@@ -343,7 +343,7 @@ public class MapVersionsPhase
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 2ed4376..0ef834e 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 @@ package org.apache.maven.shared.release.phase;
* 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 @@ public class RewritePomVersionsPhase
}
@Override
- protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
- List<MavenProject> reactorProjects, boolean simulate )
+ protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate )
{
- return releaseDescriptor.getOriginalVersions( reactorProjects );
+ return releaseDescriptor.getProjectOriginalVersion( projectKey );
}
@Override
- protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+ protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
{
- return releaseDescriptor.getDevelopmentVersions();
+ return releaseDescriptor.getProjectDevelopmentVersion( key );
}
@Override
protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
- Map<String, Map<String, String>> 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 1907e6a..586e97d 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 @@ package org.apache.maven.shared.release.phase;
*/
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 @@ public class RewritePomsForBranchPhase
if ( scmRoot != null )
{
- Scm scm = buildScm( project );
- releaseDescriptor.mapOriginalScmInfo( projectId, scm );
-
try
{
translateScm( project, releaseDescriptor, scmRoot, scmRepository, result, commonBasedir );
@@ -78,15 +73,13 @@ public class RewritePomsForBranchPhase
}
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 @@ public class RewritePomsForBranchPhase
}
@Override
- protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
- List<MavenProject> reactorProjects, boolean simulate )
+ protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate )
{
- return releaseDescriptor.getOriginalVersions( reactorProjects );
+ return releaseDescriptor.getProjectOriginalVersion( projectKey );
}
@Override
- protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+ protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
{
- return releaseDescriptor.getReleaseVersions();
+ return releaseDescriptor.getProjectReleaseVersion( key );
}
@Override
protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
- Map<String, Map<String, String>> resolvedSnapshotsMap )
+ ReleaseDescriptor releaseDescriptor )
{
- Map<String, String> 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 01bd7ef..cb65866 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 @@ package org.apache.maven.shared.release.phase;
* 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 @@ public class RewritePomsForDevelopmentPhase
Scm scmRoot = modelTarget.getScm();
if ( scmRoot != null )
{
- Map<String, Scm> 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 @@ public class RewritePomsForDevelopmentPhase
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 @@ public class RewritePomsForDevelopmentPhase
}
@Override
- protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
- List<MavenProject> 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<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+ protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
{
- return releaseDescriptor.getDevelopmentVersions();
+ return releaseDescriptor.getProjectDevelopmentVersion( key );
}
@Override
protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
- Map<String, Map<String, String>> resolvedSnapshotsMap )
+ ReleaseDescriptor releaseDescriptor )
{
- Map<String, String> 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 6e2b47e..dc774a1 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 @@ package org.apache.maven.shared.release.phase;
*/
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 @@ public class RewritePomsForReleasePhase
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 @@ public class RewritePomsForReleasePhase
}
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 @@ public class RewritePomsForReleasePhase
}
@Override
- protected Map<String, String> getOriginalVersionMap( ReleaseDescriptor releaseDescriptor,
- List<MavenProject> reactorProjects, boolean simulate )
+ protected String getOriginalVersion( ReleaseDescriptor releaseDescriptor, String projectKey, boolean simulate )
{
- return releaseDescriptor.getOriginalVersions( reactorProjects );
+ return releaseDescriptor.getProjectOriginalVersion( projectKey );
}
@Override
- protected Map<String, String> getNextVersionMap( ReleaseDescriptor releaseDescriptor )
+ protected String getNextVersion( ReleaseDescriptor releaseDescriptor, String key )
{
- return releaseDescriptor.getReleaseVersions();
+ return releaseDescriptor.getProjectReleaseVersion( key );
}
@Override
protected String getResolvedSnapshotVersion( String artifactVersionlessKey,
- Map<String, Map<String, String>> resolvedSnapshotsMap )
+ ReleaseDescriptor releaseDescriptor )
{
- Map<String, String> 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 ea76dba..00f2c1e 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.model.Model;
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 class ReleaseUtil
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<MavenProject> reactorProjects )
diff --git a/maven-release-manager/src/main/mdo/release-descriptor.mdo b/maven-release-manager/src/main/mdo/release-descriptor.mdo
index 6191087..4123d12 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 @@
</defaults>
<classes>
<class rootElement="true">
- <name>ReleaseDescriptor</name>
+ <name>ModelloReleaseDescriptor</name>
<version>1.0.0+</version>
<fields>
<!-- Descriptive Information -->
@@ -241,6 +241,7 @@
<name>checkoutDirectory</name>
<version>1.0.0+</version>
<type>String</type>
+ <defaultValue>target/checkout</defaultValue>
<description>
The directory where the tag will be checked out.
</description>
@@ -534,71 +535,50 @@
<codeSegment>
<version>2.1.0+</version>
<code><![CDATA[
- public static final String DEVELOPMENT_KEY = "dev";
-
- public static final String RELEASE_KEY = "rel";
-
- public static final String ORIGINAL_VERSION = "original";
-
/**
* Field resolvedSnapshotDependencies.
*/
- private java.util.Map<String, java.util.Map<String, String>> resolvedSnapshotDependencies;
-
- /**
- * Field releaseVersions.
- */
- private java.util.Map<String, String> releaseVersions;
+ private java.util.Map<String, ReleaseStageVersions> resolvedSnapshotDependencies = new java.util.HashMap<>();
/**
- * Field developmentVersions.
+ * Field projectVersions
*/
- private java.util.Map<String, String> developmentVersions;
+ private java.util.Map<String, ReleaseStageVersions> projectVersions = new java.util.HashMap<>();
/**
* Field originalScmInfo.
*/
- private java.util.Map<String, org.apache.maven.model.Scm> originalScmInfo;
+ private java.util.Map<String, org.apache.maven.model.Scm> originalScmInfo = new java.util.HashMap<>();
- /**
- * Method getResolvedSnapshotDependencies.
- *
- * @return Map
- */
- public java.util.Map<String, java.util.Map<String, String>> getResolvedSnapshotDependencies()
+
+ java.util.Map<String, ReleaseStageVersions> getProjectVersions()
{
- if ( this.resolvedSnapshotDependencies == null )
- {
- this.resolvedSnapshotDependencies = new java.util.HashMap<>();
- }
-
- return this.resolvedSnapshotDependencies;
- } //-- java.util.Map<String, java.util.Map<String, String>> getResolvedSnapshotDependencies()
+ return projectVersions;
+ }
- /**
- * Set a map of resolved snapshot dependencies versions.
- *
- * @param resolvedSnapshotDependencies
- */
- public void setResolvedSnapshotDependencies( java.util.Map<String, java.util.Map<String, String>> resolvedSnapshotDependencies )
+ java.util.Map<String, org.apache.maven.model.Scm> getOriginalScmInfo()
{
- this.resolvedSnapshotDependencies = resolvedSnapshotDependencies;
- } //-- void setResolvedSnapshotDependencies( java.util.Map<String, java.util.Map<String, String>> )
-
+ return originalScmInfo;
+ }
+
/**
- * Method getReleaseVersions.
+ * Method getResolvedSnapshotDependencies.
*
* @return Map
*/
- public java.util.Map<String, String> getReleaseVersions()
+ java.util.Map<String, ReleaseStageVersions> getResolvedSnapshotDependencies()
{
- if ( this.releaseVersions == null )
- {
- this.releaseVersions = new java.util.HashMap<>();
- }
+ return this.resolvedSnapshotDependencies;
+ } //-- java.util.Map<String, ReleaseStageVersions> getResolvedSnapshotDependencies()
- return this.releaseVersions;
- } //-- java.util.Map<String, String> 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<String, String> getDevelopmentVersions()
+ public String getProjectDevelopmentVersion( String projectId )
{
- if ( this.developmentVersions == null )
- {
- this.developmentVersions = new java.util.HashMap<>();
- }
-
- return this.developmentVersions;
- } //-- java.util.Map<String, String> 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<String, org.apache.maven.model.Scm> 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<Object, String> 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<String, String> getOriginalVersions( java.util.List<org.apache.maven.project.MavenProject> 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<String, String> 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<String, String> 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<String, ReleaseStageVersions> 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<String, org.apache.maven.model.Scm> 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<java.util.Map.Entry<String, org.apache.maven.model.Scm>> i = originalScmInfo.entrySet().iterator(); i.hasNext(); )
{
- java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
+ java.util.Map.Entry<String, org.apache.maven.model.Scm> 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 @@
</codeSegment>
</codeSegments>
</class>
+ <class>
+ <name>ReleaseStageVersions</name>
+ <fields>
+ <field>
+ <name>original</name>
+ <version>3.0.0+</version>
+ <type>String</type>
+ </field>
+ <field>
+ <name>release</name>
+ <version>3.0.0+</version>
+ <type>String</type>
+ </field>
+ <field>
+ <name>development</name>
+ <version>3.0.0+</version>
+ <type>String</type>
+ </field>
+ </fields>
+ <codeSegments>
+ <codeSegment>
+ <version>2.1.0+</version>
+ <code><![CDATA[
+ @Override
+ public boolean equals( Object obj )
+ {
+ if ( this == obj )
+ {
+ return true;
+ }
+ if ( obj == null || getClass() != obj.getClass() )
+ {
+ return false;
+ }
+
+ ReleaseStageVersions that = (ReleaseStageVersions) obj;
+ if ( !java.util.Objects.equals( original, that.original ) )
+ {
+ return false;
+ }
+ if ( !java.util.Objects.equals( release, that.release ) )
+ {
+ return false;
+ }
+ if ( !java.util.Objects.equals( development, that.development ) )
+ {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ int result = java.util.Objects.hashCode( original );
+ result = 29 * result + java.util.Objects.hashCode( release );
+ result = 29 * result + java.util.Objects.hashCode( development );
+ return result;
+ }
+
+]]></code>
+ </codeSegment>
+ </codeSegments>
+ </class>
</classes>
</model>
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 d68f9f6..142d49b 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.File;
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.ScmProvider;
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
}
// verify
- verify( configStoreMock ).read( releaseDescriptor );
+ verify( configStoreMock ).read( builder );
verifyNoMoreInteractions( configStoreMock );
}
@@ -372,22 +385,24 @@ public class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
}
// verify
- verify( configStoreMock ).write( releaseDescriptor ) ;
+ verify( configStoreMock ).write( any( ReleaseDescriptor.class ) ) ;
verifyNoMoreInteractions( configStoreMock );
}
@@ -410,9 +425,9 @@ public class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
releaseManager.setConfigStore( configStoreMock );
ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
- cleanRequest.setReleaseDescriptor( releaseDescriptor );
+ cleanRequest.setReleaseDescriptorBuilder( builder );
// execute
releaseManager.clean( cleanRequest );
@@ -439,7 +454,7 @@ public class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
}
// 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 class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
// 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 class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
{
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 class DefaultReleaseManagerTest
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 class DefaultReleaseManagerTest
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 0b93bbf..35903ce 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 @@ public class PropertiesReleaseDescriptorStoreTest
{
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 class PropertiesReleaseDescriptorStoreTest
{
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
{
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 class PropertiesReleaseDescriptorStoreTest
{
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 class PropertiesReleaseDescriptorStoreTest
{
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 class PropertiesReleaseDescriptorStoreTest
{
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 @@ public class PropertiesReleaseDescriptorStoreTest
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 @@ public class PropertiesReleaseDescriptorStoreTest
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 class PropertiesReleaseDescriptorStoreTest
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 @@ public class PropertiesReleaseDescriptorStoreTest
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 @@ public class PropertiesReleaseDescriptorStoreTest
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 7470bd2..1352d28 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 class ReleaseDescriptorStoreStub
{
}
- 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 ea85a18..4cff313 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 junit.framework.TestCase;
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 @@ import java.util.Properties;
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 class ReleaseUtilsTest
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<String, String> 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 class ReleaseUtilsTest
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<String, String> 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 class ReleaseUtilsTest
{
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 @@ public class ReleaseUtilsTest
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 @@ public class ReleaseUtilsTest
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 7ef8d6e..8b65593 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.Settings;
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 class ForkedMavenExecutorTest
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 3f4789d..57327e2 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.DefaultInvocationRequest;
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 class InvokerMavenExecutorTest
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 9d510cc..9bc40d8 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.provider.ScmProviderStub;
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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
{
// prepare
List<MavenProject> 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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
// 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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractEditModeRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 2deaf8b..96eadcd 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.ProjectBuildingResult;
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 @@ public abstract class AbstractReleaseTestCase
{
return createReactorProjects( path, path, subpath );
}
+
+ protected ReleaseDescriptorBuilder createReleaseDescriptorBuilder( List<MavenProject> 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 903cf93..427371c 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.provider.ScmProvider;
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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
super.setUp();
- phase = (ReleasePhase) lookup( ReleasePhase.class, getRoleHint() );
+ phase = lookup( ReleasePhase.class, getRoleHint() );
if( phase instanceof AbstractRewritePomsPhase)
{
@@ -96,10 +97,10 @@ public abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
{
List<MavenProject> 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<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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<MavenProject> reactorProjects )
+ protected abstract ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
throws Exception;
@Test
@@ -233,10 +234,10 @@ public abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
{
String path = "basic-pom";
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
{
// prepare
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
{
// prepare
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
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 abstract class AbstractRewritingReleasePhaseTestCase
{
// prepare
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
// 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 abstract class AbstractRewritingReleasePhaseTestCase
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.<MavenProject>emptyList() );
-
- assertTrue( true );
}
- protected ReleaseDescriptor createUnmappedConfiguration( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createUnmappedConfiguration( List<MavenProject> 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<MavenProject> createReactorProjects( String path )
@@ -679,31 +674,31 @@ public abstract class AbstractRewritingReleasePhaseTestCase
return prepareReactorProjects( path, true );
}
- protected ReleaseDescriptor createDefaultConfiguration( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDefaultConfiguration( List<MavenProject> 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<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createMappedConfiguration( List<MavenProject> 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<MavenProject> reactorProjects )
+ private ReleaseDescriptorBuilder createDifferingVersionConfiguration( List<MavenProject> 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<MavenProject> createReactorProjectsFromBasicPom()
@@ -712,14 +707,14 @@ public abstract class AbstractRewritingReleasePhaseTestCase
return createReactorProjects( "basic-pom" );
}
- protected abstract ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+ protected abstract ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> 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<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
throws Exception
{
return createDescriptorFromProjects( reactorProjects );
@@ -733,9 +728,9 @@ public abstract class AbstractRewritingReleasePhaseTestCase
throws Exception
{
List<MavenProject> 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 @@ public abstract class AbstractRewritingReleasePhaseTestCase
{
}
- protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
+ {
+ return createDescriptorFromProjects( new ReleaseDescriptorBuilder(), reactorProjects );
+ }
+
+ protected ReleaseDescriptorBuilder createDescriptorFromProjects( ReleaseDescriptorBuilder builder, List<MavenProject> 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 087ea96..3a6bbae 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 java.util.List;
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 class AbstractScmCommitPhaseTest
throws Exception
{
List<File> 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 class AbstractScmCommitPhaseTest
public void testCreatePomFilesSuppressCommitBeforeTag()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setSuppressCommitBeforeTagOrBranch( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setSuppressCommitBeforeTagOrBranch( true );
List<File> 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 class AbstractScmCommitPhaseTest
public void testCreatePomFilesWithReleasePom()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setGenerateReleasePoms( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setGenerateReleasePoms( true );
List<File> 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 class AbstractScmCommitPhaseTest
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<File> 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 d0e69f8..1ff575f 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.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.codehaus.plexus.components.interactivity.Prompter;
import org.codehaus.plexus.components.interactivity.PrompterException;
@@ -71,26 +72,26 @@ public class BranchInputVariablesPhaseTest
List<MavenProject> 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 class BranchInputVariablesPhaseTest
{
List<MavenProject> 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 class BranchInputVariablesPhaseTest
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 class BranchInputVariablesPhaseTest
List<MavenProject> 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 class BranchInputVariablesPhaseTest
List<MavenProject> 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 class BranchInputVariablesPhaseTest
List<MavenProject> 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 class BranchInputVariablesPhaseTest
}
// 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 class BranchInputVariablesPhaseTest
List<MavenProject> 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 class BranchInputVariablesPhaseTest
}
// 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 class BranchInputVariablesPhaseTest
@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<MavenProject> 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 81466d8..2b0edf6 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 static org.mockito.Mockito.when;
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 class CheckDependencySnapshotsPhaseTest
{
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<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotDependenciesInProjectOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotReleasePluginNonInteractive()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotManagedDependenciesInProjectOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotUnusedInternalManagedDependency()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotUnusedExternalManagedDependency()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotExternalManagedDependency()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotDependenciesOutsideProjectOnlyNonInteractive()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
public void testRangeSnapshotDependenciesOutsideProjectOnlyNonInteractive()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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<String, String> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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<String, String> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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<String, String> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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<String, String> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-all" );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( reactorProjects );
Prompter mockPrompter =
createMockPrompter( YES, "0",
@@ -595,14 +592,13 @@ public class CheckDependencySnapshotsPhaseTest
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<String, String> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
createMockPrompter( "yes", "1", Arrays.asList( pair, pair ), Arrays.asList( defaultPair, defaultPair ) );
phase.setPrompter( mockPrompter );
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
-
- Map<String, Map<String, String>> resolvedDependencies = releaseDescriptor.getResolvedSnapshotDependencies();
-
- assertNotNull( resolvedDependencies );
- assertEquals( 2, resolvedDependencies.size() );
-
- assertTrue( resolvedDependencies.containsKey( "external:artifactId" ) );
- assertTrue( resolvedDependencies.containsKey( "external:artifactId2" ) );
-
- Map<String, String> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
public void testNoSnapshotReportPlugins()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotReportPluginsInProjectOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
public void testNoSnapshotPlugins()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotPluginsInProjectOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotManagedPluginInProjectOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotUnusedInternalManagedPlugin()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotUnusedExternalManagedPlugin()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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<String, String> 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<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
CheckDependencySnapshotsPhase phase =
(CheckDependencySnapshotsPhase) lookup( ReleasePhase.class, "check-dependency-snapshots" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
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 class CheckDependencySnapshotsPhaseTest
public void testSnapshotInternalExtension()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testReleaseExternalExtension()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();;
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
public void testAllowTimestampedSnapshots()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
List<MavenProject> 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 class CheckDependencySnapshotsPhaseTest
}
// 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 3e3eac4..84e78d7 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.Model;
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 @@ public class CheckPomPhaseTest
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 class CheckPomPhaseTest
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 class CheckPomPhaseTest
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 class CheckPomPhaseTest
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 class CheckPomPhaseTest
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 class CheckPomPhaseTest
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 class CheckPomPhaseTest
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 class CheckPomPhaseTest
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 8f714aa..defcb17 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.provider.svn.repository.SvnScmProviderRepository;
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 class CheckoutProjectFromScmTest
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 class CheckoutProjectFromScmTest
List<MavenProject> 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 class CheckoutProjectFromScmTest
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 class CheckoutProjectFromScmTest
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 class CheckoutProjectFromScmTest
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 class CheckoutProjectFromScmTest
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 class CheckoutProjectFromScmTest
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 class CheckoutProjectFromScmTest
// 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 class CheckoutProjectFromScmTest
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 class CheckoutProjectFromScmTest
// 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 1c17c64..990bd41 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.PlexusJUnit4TestCase;
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 class EndReleasePhaseTest
{
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 class EndReleasePhaseTest
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 d261323..744e143 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.ScmManager;
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 class GenerateReleasePomsPhaseTest
throws Exception
{
List<MavenProject> 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 class GenerateReleasePomsPhaseTest
throws Exception
{
List<MavenProject> 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 class GenerateReleasePomsPhaseTest
throws Exception
{
List<MavenProject> 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 class GenerateReleasePomsPhaseTest
throws Exception
{
List<MavenProject> 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 class GenerateReleasePomsPhaseTest
* util.List)
*/
@Override
- protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> 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 @@ public class GenerateReleasePomsPhaseTest
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 @@ public class GenerateReleasePomsPhaseTest
* 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 @@ public class GenerateReleasePomsPhaseTest
* 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 @@ public class GenerateReleasePomsPhaseTest
* createConfigurationForPomWithParentAlternateNextVersion(java.util.List)
*/
@Override
- protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> 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 @@ public class GenerateReleasePomsPhaseTest
* createConfigurationForWithParentNextVersion(java.util.List)
*/
@Override
- protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> 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 8342fbd..6476f04 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 @@ package org.apache.maven.shared.release.phase;
* 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.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.codehaus.plexus.components.interactivity.Prompter;
import org.codehaus.plexus.components.interactivity.PrompterException;
@@ -71,26 +74,26 @@ public class InputVariablesPhaseTest
List<MavenProject> 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 class InputVariablesPhaseTest
{
List<MavenProject> 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 class InputVariablesPhaseTest
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 class InputVariablesPhaseTest
List<MavenProject> 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 class InputVariablesPhaseTest
List<MavenProject> 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 class InputVariablesPhaseTest
List<MavenProject> 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 class InputVariablesPhaseTest
List<MavenProject> 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 class InputVariablesPhaseTest
}
// 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 class InputVariablesPhaseTest
List<MavenProject> 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 class InputVariablesPhaseTest
phase.setPrompter( mockPrompter );
List<MavenProject> 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 9f03a92..bbd5520 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 java.util.List;
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 @@ public class MapDevelopmentVersionPhaseIT
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 @@ public class MapDevelopmentVersionPhaseIT
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<MavenProject> 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 8feb4aa..36e98bb 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 static org.mockito.Mockito.when;
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
}
// 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
* 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
* 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
* 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
* 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> 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 class MapVersionsPhaseTest
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setBranchCreation( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setBranchCreation( true );
... 4934 lines suppressed ...
--
To stop receiving notification emails like this one, please contact
rfscholte@apache.org.