[MRELEASE-998] Add ability to create custom phases
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 @@
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 @@
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 @@
import java.util.List;
import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
/**
*
@@ -31,7 +31,7 @@
*/
public abstract class AbstractReleaseRequest
{
- private ReleaseDescriptor releaseDescriptor;
+ private ReleaseDescriptorBuilder releaseDescriptorBuilder;
private List<MavenProject> reactorProjects;
@@ -40,17 +40,17 @@
/**
* @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 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 @@
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 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 @@
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 void branch( ReleaseBranchRequest branchRequest )
throws ReleaseExecutionException, ReleaseFailureException
{
- ReleaseDescriptor releaseDescriptor = loadReleaseDescriptor( branchRequest.getReleaseDescriptor(),
- branchRequest.getReleaseManagerListener() );
+ final ReleaseDescriptorBuilder builder = branchRequest.getReleaseDescriptorBuilder();
+
+ ReleaseUtils.copyPropertiesToReleaseDescriptor( branchRequest.getUserProperties(),
+ new ReleaseDescriptorBuilder()
+ {
+ public ReleaseDescriptorBuilder addDevelopmentVersion( String key,
+ String value )
+ {
+ builder.addDevelopmentVersion( key, value );
+ return this;
+ }
+
+ public ReleaseDescriptorBuilder addReleaseVersion( String key,
+ String value )
+ {
+ builder.addReleaseVersion( key, value );
+ return this;
+ };
+ } );
+
+ ReleaseDescriptor releaseDescriptor =
+ loadReleaseDescriptor( builder, branchRequest.getReleaseManagerListener() );
boolean dryRun = BooleanUtils.isTrue( branchRequest.getDryRun() );
@@ -369,8 +415,29 @@
public void 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 @@
}
}
- 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 @@
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 @@
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 @@
* under the License.
*/
+import java.util.Properties;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
/**
@@ -32,6 +33,8 @@
private Boolean dryRun;
private ReleaseEnvironment releaseEnvironment;
+
+ private Properties userProperties;
/**
* @return the dryRun
@@ -64,4 +67,14 @@
{
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 @@
* under the License.
*/
+import java.util.Properties;
+
import org.apache.maven.shared.release.env.ReleaseEnvironment;
/**
@@ -36,6 +38,8 @@
private Boolean resume;
private ReleaseEnvironment releaseEnvironment;
+
+ private Properties userProperties;
/**
* @return the dryRun
@@ -84,4 +88,14 @@
{
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 @@
* under the License.
*/
+import java.util.Properties;
+
import org.apache.maven.shared.release.env.ReleaseEnvironment;
/**
@@ -30,6 +32,8 @@
extends AbstractReleaseRequest
{
private ReleaseEnvironment releaseEnvironment;
+
+ private Properties userProperties;
/**
* @return the releaseEnvironment
@@ -46,4 +50,14 @@
{
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.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 @@
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 @@
"Error reading properties file '" + file.getName() + "': " + e.getMessage(), e );
}
- ReleaseDescriptor releaseDescriptor = ReleaseUtils.copyPropertiesToReleaseDescriptor( properties );
-
+ ReleaseDescriptorBuilder builder;
if ( mergeDescriptor != null )
{
- releaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
+ builder = mergeDescriptor;
}
+ else
+ {
+ builder = new ReleaseDescriptorBuilder();
+ }
+
+ ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder );
- return releaseDescriptor;
+ return builder;
}
@Override
public void write( ReleaseDescriptor config )
throws ReleaseDescriptorStoreException
{
- write( config, getDefaultReleasePropertiesFile( config ) );
+ write( (BuilderReleaseDescriptor) config, getDefaultReleasePropertiesFile( config ) );
}
@Override
@@ -119,7 +125,7 @@
}
}
- public void write( ReleaseDescriptor config, File file )
+ public void write( BuilderReleaseDescriptor config, File file )
throws ReleaseDescriptorStoreException
{
Properties properties = new Properties();
@@ -226,14 +232,17 @@
// 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() )
+
+ for ( Map.Entry<String, ReleaseStageVersions> entry : config.getProjectVersions().entrySet() )
{
- properties.setProperty( "project.rel." + entry.getKey(), entry.getValue() );
- }
-
- for ( Map.Entry<String, String> entry : config.getDevelopmentVersions().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 @@
}
}
- 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 @@
* 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 @@
* under the License.
*/
-import java.util.HashMap;
import java.util.Iterator;
-import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor;
import org.apache.maven.shared.release.scm.IdentifiedScm;
/**
@@ -35,152 +34,119 @@
*/
public class ReleaseUtils
{
+ private static final String DEVELOPMENT_KEY = "dev";
+
+ private static final String RELEASE_KEY = "rel";
+
private ReleaseUtils()
{
// nothing to see here
}
- /**
- * Merge two descriptors together. All SCM settings are overridden by the merge descriptor, as is the
- * <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" ) ) );
}
- // These must be overridden, as they are not stored
- mergeInto.setWorkingDirectory(
- mergeOverride( mergeInto.getWorkingDirectory(), toBeMerged.getWorkingDirectory() ) );
- mergeInto.setCheckoutDirectory(
- mergeOverride( mergeInto.getCheckoutDirectory(), toBeMerged.getCheckoutDirectory() ) );
+ 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 ) );
+ }
- // 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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
return mavenExecutorId;
}
- @Override
- public ReleaseEnvironment setMavenExecutorId( String mavenExecutorId )
+ public DefaultReleaseEnvironment setMavenExecutorId( String mavenExecutorId )
{
this.mavenExecutorId = mavenExecutorId;
return this;
@@ -88,8 +85,7 @@
return javaHome;
}
- @Override
- public ReleaseEnvironment setJavaHome( File javaHome )
+ public DefaultReleaseEnvironment setJavaHome( File javaHome )
{
this.javaHome = javaHome;
return this;
@@ -108,8 +104,7 @@
return localRepo;
}
- @Override
- public ReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory )
+ public DefaultReleaseEnvironment setLocalRepositoryDirectory( File localRepositoryDirectory )
{
this.localRepositoryDirectory = localRepositoryDirectory;
return this;
@@ -121,8 +116,7 @@
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.ModelBase;
import org.apache.maven.model.Plugin;
import org.apache.maven.model.Profile;
-import org.apache.maven.model.Scm;
import org.apache.maven.project.MavenProject;
import org.apache.maven.scm.ScmException;
import org.apache.maven.scm.ScmFileSet;
@@ -49,7 +48,6 @@
import org.apache.maven.shared.release.ReleaseResult;
import org.apache.maven.shared.release.config.ReleaseDescriptor;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
-import org.apache.maven.shared.release.scm.IdentifiedScm;
import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
@@ -239,51 +237,42 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
// 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 @@
{
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 @@
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 @@
}
}
- 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 @@
if ( result.toLowerCase( Locale.ENGLISH ).startsWith( "y" ) )
{
addToFailures = false;
- releaseDescriptor.setSnapshotReleasePluginAllowed( true );
}
else
{
@@ -240,52 +234,60 @@
}
}
}
+ 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 @@
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 @@
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 @@
{
// all
case 0:
- resolvedSnapshots = processSnapshot( projectDependencies );
- resolvedSnapshots.putAll( processSnapshot( pluginDependencies ) );
- resolvedSnapshots.putAll( processSnapshot( reportDependencies ) );
- resolvedSnapshots.putAll( processSnapshot( extensionDependencies ) );
+ processSnapshot( projectDependencies, releaseDescriptor );
+ processSnapshot( pluginDependencies, releaseDescriptor );
+ processSnapshot( reportDependencies, releaseDescriptor );
+ processSnapshot( extensionDependencies, releaseDescriptor );
break;
// project dependencies
case 1:
- resolvedSnapshots = processSnapshot( projectDependencies );
+ processSnapshot( projectDependencies, releaseDescriptor );
break;
// plugins
case 2:
- resolvedSnapshots = processSnapshot( pluginDependencies );
+ processSnapshot( pluginDependencies, releaseDescriptor );
break;
// reports
case 3:
- resolvedSnapshots = processSnapshot( reportDependencies );
+ processSnapshot( reportDependencies, releaseDescriptor );
break;
// extensions
case 4:
- resolvedSnapshots = processSnapshot( extensionDependencies );
+ processSnapshot( extensionDependencies, releaseDescriptor );
break;
default:
}
-
- releaseDescriptor.getResolvedSnapshotDependencies().putAll( resolvedSnapshots );
}
}
catch ( PrompterException | VersionParseException e )
@@ -419,10 +415,9 @@
}
}
- private 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 @@
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 @@
}
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.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 @@
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 @@
}
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 @@
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 @@
// 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 @@
}
// 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 @@
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 @@
String id = ArtifactUtils.versionlessKey( groupId, artifactId );
- String nextVersion = mappedVersions.get( id );
+ String nextVersion = releaseDescriptor.getProjectReleaseVersion( id );
if ( nextVersion == null )
{
@@ -489,8 +475,8 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
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 @@
{
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 @@
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 @@
{
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 @@
{
// 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 @@
{
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 @@
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 @@
{
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 @@
String defaultVersion = releaseDescriptor.getDefaultDevelopmentVersion();
if ( StringUtils.isEmpty( defaultVersion ) )
{
- defaultVersion = releaseDescriptor.getDevelopmentVersions().get( projectId );
+ defaultVersion = releaseDescriptor.getProjectDevelopmentVersion( projectId );
}
return defaultVersion;
}
@@ -343,7 +343,7 @@
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 @@
* 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 @@
}
@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 @@
*/
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 @@
if ( scmRoot != null )
{
- Scm scm = buildScm( project );
- releaseDescriptor.mapOriginalScmInfo( projectId, scm );
-
try
{
translateScm( project, releaseDescriptor, scmRoot, scmRepository, result, commonBasedir );
@@ -78,15 +73,13 @@
}
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 @@
}
@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 @@
* 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 @@
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 @@
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 @@
}
@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 @@
*/
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 @@
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 @@
}
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 @@
}
@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.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 @@
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;
+ private java.util.Map<String, ReleaseStageVersions> resolvedSnapshotDependencies = new java.util.HashMap<>();
/**
- * Field releaseVersions.
+ * Field projectVersions
*/
- private java.util.Map<String, String> releaseVersions;
-
- /**
- * Field developmentVersions.
- */
- 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<>();
+
+
+ java.util.Map<String, ReleaseStageVersions> getProjectVersions()
+ {
+ return projectVersions;
+ }
+
+ java.util.Map<String, org.apache.maven.model.Scm> getOriginalScmInfo()
+ {
+ return originalScmInfo;
+ }
/**
* Method getResolvedSnapshotDependencies.
*
* @return Map
*/
- public java.util.Map<String, java.util.Map<String, String>> getResolvedSnapshotDependencies()
+ java.util.Map<String, ReleaseStageVersions> getResolvedSnapshotDependencies()
{
- if ( this.resolvedSnapshotDependencies == null )
- {
- this.resolvedSnapshotDependencies = new java.util.HashMap<>();
- }
-
return this.resolvedSnapshotDependencies;
- } //-- java.util.Map<String, java.util.Map<String, String>> getResolvedSnapshotDependencies()
-
- /**
- * Set a map of resolved snapshot dependencies versions.
- *
- * @param resolvedSnapshotDependencies
- */
- public void setResolvedSnapshotDependencies( java.util.Map<String, java.util.Map<String, String>> resolvedSnapshotDependencies )
- {
- this.resolvedSnapshotDependencies = resolvedSnapshotDependencies;
- } //-- void setResolvedSnapshotDependencies( java.util.Map<String, java.util.Map<String, String>> )
+ } //-- java.util.Map<String, ReleaseStageVersions> getResolvedSnapshotDependencies()
- /**
- * Method getReleaseVersions.
- *
- * @return Map
- */
- public java.util.Map<String, String> getReleaseVersions()
+ public String getProjectReleaseVersion( String projectId )
{
- if ( this.releaseVersions == null )
- {
- this.releaseVersions = new java.util.HashMap<>();
- }
-
- return this.releaseVersions;
- } //-- java.util.Map<String, String> getReleaseVersions()
+ 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,104 +632,18 @@
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 );
- }
-
- /**
- * Map a given project to a specified version from when it is incremented and placed back into development.
- *
- * @param projectId the project's group and artifact ID
- * @param nextVersion the version to map to
- */
- public void mapDevelopmentVersion( String projectId, String nextVersion )
- {
- if ( developmentVersions == null )
- {
- developmentVersions = new java.util.HashMap<>();
- }
-
- developmentVersions.put( projectId, nextVersion );
- }
-
- /**
- * Map a given project to a specified set of SCM information.
- *
- * @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 )
- {
- if ( originalScmInfo == null )
- {
- originalScmInfo = new java.util.HashMap<>();
- }
- else
- {
- assert !originalScmInfo.containsKey( projectId );
- }
-
- originalScmInfo.put( projectId, scm );
- }
-
- /**
- * 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.
- *
- * @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 )
- {
- if ( originalVersions == null )
- {
- 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() );
- }
- }
- return originalVersions;
+ computeIfAbsent( projectVersions, projectId ).setOriginal( version );
}
/**
@@ -769,10 +652,10 @@
*/
public String getDependencyDevelopmentVersion( String artifactConflictId )
{
- if ( ( resolvedSnapshotDependencies == null ) && ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) )
+ if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) )
{
- java.util.Map<String, String> versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
- return versionMap.get( DEVELOPMENT_KEY );
+ ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
+ return versionMap.getDevelopment();
}
return null;
}
@@ -783,19 +666,55 @@
*/
public String getDependencyReleaseVersion( String artifactConflictId )
{
- if ( ( resolvedSnapshotDependencies == null ) && ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) ) )
+ if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) )
{
- java.util.Map<String, String> versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
- return versionMap.get( RELEASE_KEY );
+ ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
+ return versionMap.getRelease();
}
return null;
}
- boolean safeEquals( String a, String b )
+ /**
+ * Retrieve the original version for the resolved snapshot dependency.
+ *
+ */
+ public String getDependencyOriginalVersion( String artifactConflictId )
{
- return a != null ? a.equals( b ) : b == null;
+ if ( resolvedSnapshotDependencies.containsKey( artifactConflictId ) )
+ {
+ ReleaseStageVersions versionMap = resolvedSnapshotDependencies.get( artifactConflictId );
+ return versionMap.getOriginal();
+ }
+ return null;
+ }
+
+ public void addDependencyOriginalVersion( String dependencyKey, String version )
+ {
+ computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setOriginal( version );
}
+ public void addDependencyReleaseVersion( String dependencyKey, String version )
+ {
+ computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setRelease( version );
+ }
+
+ public void addDependencyDevelopmentVersion( String dependencyKey, String version )
+ {
+ computeIfAbsent( resolvedSnapshotDependencies, dependencyKey ).setDevelopment( version );
+ }
+
+ private static ReleaseStageVersions computeIfAbsent( java.util.Map<String, ReleaseStageVersions> map, String key )
+ {
+ 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) ) )
+ ( that.getCheckModificationExcludes() == null || ( that.getCheckModificationExcludes() != null && that.getCheckModificationExcludes().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) ) )
- {
- // 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 ) ) )
- {
- // Do nothing. This is a Modello workaround
- }
- else
- {
- if ( releaseVersions != null ? !releaseVersions.equals( that.releaseVersions ) : that.releaseVersions != null )
- {
- return false;
- }
- }
- if ( !safeEquals( additionalArguments, that.additionalArguments ) )
+ if ( !java.util.Objects.equals( additionalArguments, that.getAdditionalArguments() ) )
{
return false;
}
- if ( !safeEquals( preparationGoals, that.preparationGoals ) )
+ if ( !java.util.Objects.equals( preparationGoals, that.getPreparationGoals() ) )
{
return false;
}
- if ( !safeEquals( completionGoals, that.completionGoals ) )
+ if ( !java.util.Objects.equals( completionGoals, that.getCompletionGoals() ) )
{
return false;
}
- if ( !safeEquals( pomFileName, that.pomFileName ) )
+ if ( !java.util.Objects.equals( pomFileName, that.getPomFileName() ) )
{
return false;
}
- if ( !safeEquals( scmPrivateKeyPassPhrase, that.scmPrivateKeyPassPhrase ) )
+ if ( !java.util.Objects.equals( scmPrivateKeyPassPhrase, that.getScmPrivateKeyPassPhrase() ) )
{
return false;
}
- if ( !safeEquals( scmPassword, that.scmPassword ) )
+ if ( !java.util.Objects.equals( scmPassword, that.getScmPassword() ) )
{
return false;
}
- if ( !safeEquals( scmPrivateKey, that.scmPrivateKey ) )
+ if ( !java.util.Objects.equals( scmPrivateKey, that.getScmPrivateKey() ) )
{
return false;
}
- if ( !safeEquals( scmReleaseLabel, that.scmReleaseLabel ) )
+ if ( !java.util.Objects.equals( scmReleaseLabel, that.getScmReleaseLabel() ) )
{
return false;
}
- if ( !safeEquals( scmTagBase, that.scmTagBase ) )
+ if ( !java.util.Objects.equals( scmTagBase, that.getScmTagBase() ) )
{
return false;
}
- if ( !safeEquals( scmBranchBase, that.scmBranchBase ) )
+ if ( !java.util.Objects.equals( scmBranchBase, that.getScmBranchBase() ) )
{
return false;
}
- if ( !safeEquals( scmId, that.scmId ) )
+ if ( !java.util.Objects.equals( scmId, that.getScmId() ) )
{
return false;
}
- if ( !safeEquals( scmSourceUrl, that.scmSourceUrl ) )
+ if ( !java.util.Objects.equals( scmSourceUrl, that.getScmSourceUrl() ) )
{
return false;
}
- if ( !safeEquals( scmUsername, that.scmUsername ) )
+ if ( !java.util.Objects.equals( scmUsername, that.getScmUsername() ) )
{
return false;
}
- if ( !safeEquals( workingDirectory, that.workingDirectory ) )
+ if ( !java.util.Objects.equals( workingDirectory, that.getWorkingDirectory() ) )
{
return false;
}
- if ( !safeEquals( scmTagNameFormat, that.scmTagNameFormat ) )
+ if ( !java.util.Objects.equals( scmTagNameFormat, that.getScmTagNameFormat() ) )
+ {
+ return false;
+ }
+ if ( !java.util.Objects.equals( scmTagNameFormat, that.getScmTagNameFormat() ) )
+ {
+ return false;
+ }
+ 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.IOException;
import java.util.Collections;
import java.util.List;
+import java.util.Properties;
import org.apache.maven.project.MavenProject;
import org.apache.maven.scm.CommandParameters;
@@ -45,6 +46,7 @@
import org.apache.maven.scm.provider.ScmProviderStub;
import org.apache.maven.scm.repository.ScmRepository;
import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
import org.apache.maven.shared.release.config.ReleaseDescriptorStore;
import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
import org.apache.maven.shared.release.config.ReleaseDescriptorStoreStub;
@@ -80,12 +82,13 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
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 @@
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 @@
}
// verify
- verify( configStoreMock ).read( releaseDescriptor );
+ verify( configStoreMock ).read( builder );
verifyNoMoreInteractions( configStoreMock );
}
@@ -372,22 +385,24 @@
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 @@
}
// verify
- verify( configStoreMock ).write( releaseDescriptor ) ;
+ verify( configStoreMock ).write( any( ReleaseDescriptor.class ) ) ;
verifyNoMoreInteractions( configStoreMock );
}
@@ -410,9 +425,9 @@
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 @@
releaseManager.setConfigStore( configStoreMock );
ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
- cleanRequest.setReleaseDescriptor( releaseDescriptor );
+ cleanRequest.setReleaseDescriptorBuilder( builder );
// execute
releaseManager.clean( cleanRequest );
@@ -439,7 +454,7 @@
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 @@
{
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 @@
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 @@
}
// 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 @@
ReleaseManagerListener managerListener = mock( ReleaseManagerListener.class );
performRequest.setReleaseManagerListener( managerListener );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
- performRequest.setReleaseDescriptor( releaseDescriptor );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
+ performRequest.setReleaseDescriptorBuilder( builder );
ReleaseManager releaseManager = lookup( ReleaseManager.class, "test" );
@@ -581,18 +596,18 @@
public void 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 @@
// 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 @@
stub.setScmProvider( scmProviderMock );
ReleasePerformRequest performRequest = new ReleasePerformRequest();
- performRequest.setReleaseDescriptor( releaseDescriptor );
+ performRequest.setReleaseDescriptorBuilder( builder );
performRequest.setReleaseEnvironment( new DefaultReleaseEnvironment() );
performRequest.setReactorProjects( createReactorProjects() );
@@ -653,19 +668,19 @@
{
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 @@
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 @@
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 @@
{
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 @@
{
File file = getTestFile( "target/test-classes/release.properties" );
- ReleaseDescriptor config = store.read( file );
+ ReleaseDescriptor config = store.read( file ).build();
- ReleaseDescriptor expected = createExpectedReleaseConfiguration();
+ ReleaseDescriptor expected = createExpectedReleaseConfiguration().build();
assertEquals( "check matches", expected, config );
}
@@ -63,14 +65,14 @@
public void 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 @@
{
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 @@
{
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 @@
{
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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" );
+ 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" );
- config.mapReleaseVersion( "groupId:artifactId", "1.0" );
- config.mapDevelopmentVersion( "groupId:artifactId", "1.1-SNAPSHOT" );
+ 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/**
* 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 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 org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.model.Scm;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder.BuilderReleaseDescriptor;
import org.apache.maven.shared.release.phase.AbstractReleaseTestCase;
import java.io.File;
import java.io.IOException;
-import java.util.Map;
import java.util.Properties;
/**
@@ -38,220 +38,171 @@
public class ReleaseUtilsTest
extends TestCase
{
- public void testMergeConfigurationSourceEmpty()
- throws IOException
- {
- ReleaseDescriptor mergeDescriptor = createReleaseDescriptor();
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
- ReleaseDescriptor mergedMergeDescriptor = ReleaseUtils.merge( mergeDescriptor, releaseDescriptor );
-
- assertEquals( "Check merge", mergedReleaseDescriptor, mergedMergeDescriptor );
- }
-
- public void testMergeEqualsWithUpdateWorkingCopyTrue()
- throws IOException
- {
- ReleaseDescriptor mergeDescriptor = createReleaseDescriptor();
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
-
- ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
- ReleaseDescriptor mergedMergeDescriptor = ReleaseUtils.merge( mergeDescriptor, releaseDescriptor );
-
- assertEquals( "Check merge", mergedReleaseDescriptor, mergedMergeDescriptor );
- }
-
- public void testMergeConfigurationDestEmpty()
- throws IOException
- {
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
- ReleaseDescriptor mergedReleaseDescriptor = ReleaseUtils.merge( releaseDescriptor, new ReleaseDescriptor() );
- ReleaseDescriptor expectedDescriptor = copyReleaseDescriptor( mergedReleaseDescriptor );
-
- assertEquals( "Check merge", expectedDescriptor, releaseDescriptor );
- }
-
- public void testMergeConfiguration()
- throws IOException
- {
- File workingDirectory = new File( "." );
-
- ReleaseDescriptor mergeDescriptor =
- createMergeDescriptor( AbstractReleaseTestCase.getPath( workingDirectory ), "completed-phase-merge" );
-
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
- releaseDescriptor = ReleaseUtils.merge( releaseDescriptor, mergeDescriptor );
-
- ReleaseDescriptor expected =
- createMergeDescriptor( releaseDescriptor.getWorkingDirectory(), releaseDescriptor.getCompletedPhase() );
- assertEquals( "Check merge", expected, releaseDescriptor );
- }
-
public void testEquals()
throws IOException
{
- ReleaseDescriptor originalReleaseDescriptor = createReleaseDescriptor();
- ReleaseDescriptor releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
- doEqualsAssertions( releaseDescriptor, originalReleaseDescriptor, "other", new File( "f" ) );
+ ReleaseDescriptorBuilder originalReleaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+ doEqualsAssertions( builder, originalReleaseDescriptor, "other", new File( "f" ) );
originalReleaseDescriptor = createReleaseDescriptor();
- releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
- doEqualsAssertions( originalReleaseDescriptor, releaseDescriptor, "other", new File( "f" ) );
+ builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+ doEqualsAssertions( originalReleaseDescriptor, builder, "other", new File( "f" ) );
originalReleaseDescriptor = createReleaseDescriptor();
- releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
- doEqualsAssertions( releaseDescriptor, originalReleaseDescriptor, null, null );
+ builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+ doEqualsAssertions( builder, originalReleaseDescriptor, null, null );
originalReleaseDescriptor = createReleaseDescriptor();
- releaseDescriptor = copyReleaseDescriptor( originalReleaseDescriptor );
- doEqualsAssertions( originalReleaseDescriptor, releaseDescriptor, null, null );
+ builder = copyReleaseDescriptor( originalReleaseDescriptor.build() );
+ doEqualsAssertions( originalReleaseDescriptor, builder, null, null );
- assertEquals( "test ==", releaseDescriptor, releaseDescriptor );
+ assertEquals( "test ==", builder, builder );
Object obj = this;
- assertFalse( "test class instance", releaseDescriptor.equals( obj ) );
+ assertFalse( "test class instance", builder.equals( obj ) );
}
- private static void doEqualsAssertions( ReleaseDescriptor releaseDescriptor,
- ReleaseDescriptor originalReleaseDescriptor, String other, File otherFile )
+ private static void doEqualsAssertions( ReleaseDescriptorBuilder releaseDescriptor,
+ ReleaseDescriptorBuilder originalReleaseDescriptor, String other, File otherFile )
throws IOException
{
- ReleaseDescriptor origConfig = originalReleaseDescriptor;
- ReleaseDescriptor config = releaseDescriptor;
- assertEquals( "Check original comparison", config, origConfig );
+ BuilderReleaseDescriptor origConfig = originalReleaseDescriptor.build();
+ ReleaseDescriptorBuilder configBuilder = releaseDescriptor;
+ assertEquals( "Check original comparison", configBuilder.build(), origConfig );
- config.setScmSourceUrl( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmSourceUrl( origConfig.getScmSourceUrl() );
+ configBuilder.setScmSourceUrl( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmSourceUrl( origConfig.getScmSourceUrl() );
- config.setAdditionalArguments( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setAdditionalArguments( origConfig.getAdditionalArguments() );
+ configBuilder.setAdditionalArguments( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setAdditionalArguments( origConfig.getAdditionalArguments() );
- config.setAddSchema( !origConfig.isAddSchema() );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setAddSchema( origConfig.isAddSchema() );
+ configBuilder.setAddSchema( !origConfig.isAddSchema() );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setAddSchema( origConfig.isAddSchema() );
- config.setGenerateReleasePoms( !origConfig.isAddSchema() );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setGenerateReleasePoms( origConfig.isGenerateReleasePoms() );
+ configBuilder.setGenerateReleasePoms( !origConfig.isAddSchema() );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setGenerateReleasePoms( origConfig.isGenerateReleasePoms() );
- config.setScmUseEditMode( !origConfig.isScmUseEditMode() );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmUseEditMode( origConfig.isScmUseEditMode() );
+ configBuilder.setScmUseEditMode( !origConfig.isScmUseEditMode() );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmUseEditMode( origConfig.isScmUseEditMode() );
- config.setInteractive( !origConfig.isInteractive() );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setInteractive( origConfig.isInteractive() );
+ configBuilder.setInteractive( !origConfig.isInteractive() );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setInteractive( origConfig.isInteractive() );
- config.setCommitByProject( !origConfig.isCommitByProject() );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setCommitByProject( origConfig.isCommitByProject() );
+ configBuilder.setCommitByProject( !origConfig.isCommitByProject() );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setCommitByProject( origConfig.isCommitByProject() );
- config.setCompletedPhase( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setCompletedPhase( origConfig.getCompletedPhase() );
+ configBuilder.setCompletedPhase( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setCompletedPhase( origConfig.getCompletedPhase() );
- config.setScmPrivateKeyPassPhrase( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmPrivateKeyPassPhrase( origConfig.getScmPrivateKeyPassPhrase() );
+ configBuilder.setScmPrivateKeyPassPhrase( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmPrivateKeyPassPhrase( origConfig.getScmPrivateKeyPassPhrase() );
- config.setScmPassword( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmPassword( origConfig.getScmPassword() );
+ configBuilder.setScmPassword( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmPassword( origConfig.getScmPassword() );
- config.setScmUsername( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmUsername( origConfig.getScmUsername() );
+ configBuilder.setScmUsername( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmUsername( origConfig.getScmUsername() );
- config.setScmPrivateKey( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmPrivateKey( origConfig.getScmPrivateKey() );
+ configBuilder.setScmPrivateKey( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmPrivateKey( origConfig.getScmPrivateKey() );
- config.setPomFileName( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setPomFileName( origConfig.getPomFileName() );
+ configBuilder.setPomFileName( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setPomFileName( origConfig.getPomFileName() );
- config.setPreparationGoals( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setPreparationGoals( origConfig.getPreparationGoals() );
+ configBuilder.setPreparationGoals( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setPreparationGoals( origConfig.getPreparationGoals() );
- config.setScmReleaseLabel( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmReleaseLabel( origConfig.getScmReleaseLabel() );
+ configBuilder.setScmReleaseLabel( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmReleaseLabel( origConfig.getScmReleaseLabel() );
- config.setScmTagBase( other );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config.setScmTagBase( origConfig.getScmTagBase() );
+ configBuilder.setScmTagBase( other );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder.setScmTagBase( origConfig.getScmTagBase() );
if ( otherFile != null )
{
- config.setWorkingDirectory( AbstractReleaseTestCase.getPath( otherFile ) );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
+ configBuilder.setWorkingDirectory( AbstractReleaseTestCase.getPath( otherFile ) );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
}
- config.setWorkingDirectory( origConfig.getWorkingDirectory() );
+ configBuilder.setWorkingDirectory( origConfig.getWorkingDirectory() );
// sanity check the test was resetting correctly
- assertEquals( "Check original comparison", config, origConfig );
+ assertEquals( "Check original comparison", configBuilder.build(), origConfig );
- config.mapDevelopmentVersion( "groupId:artifactId", "1.0-SNAPSHOT" );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config = copyReleaseDescriptor( origConfig );
+ configBuilder.addDevelopmentVersion( "groupId:artifactId", "1.0-SNAPSHOT" );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder = copyReleaseDescriptor( origConfig );
- config.mapReleaseVersion( "groupId:artifactId", "1.0" );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config = copyReleaseDescriptor( origConfig );
+ configBuilder.addReleaseVersion( "groupId:artifactId", "1.0" );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder = copyReleaseDescriptor( origConfig );
- config.mapOriginalScmInfo( "groupId:artifactId", new Scm() );
- assertFalse( "Check original comparison", config.equals( origConfig ) );
- config = copyReleaseDescriptor( origConfig );
+ configBuilder.addOriginalScmInfo( "groupId:artifactId", new Scm() );
+ assertFalse( "Check original comparison", configBuilder.build().equals( origConfig ) );
+ configBuilder = 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 );
+ 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 );
- config.mapOriginalScmInfo( "groupId:artifactId", new Scm() );
- origConfig.mapOriginalScmInfo( "groupId:artifactId", new Scm() );
- assertEquals( "Check original comparison", config, origConfig );
- origConfig = createReleaseDescriptor();
- config = 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 );
- 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 );
+ 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 );
- 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 );
+ 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 );
- 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 );
+ 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 );
- 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 );
+ 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 );
- config.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "-" ) );
- origConfig.mapOriginalScmInfo( "groupId:artifactId", getScm( "conn", "dev", "url", "tag" ) );
- assertFalse( "Check original comparison", config.equals( 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 @@
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 @@
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 );
+
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ ReleaseUtils.copyPropertiesToReleaseDescriptor( properties, builder );
+ ReleaseDescriptor descriptor = builder.build();
- Map<String, String> versionMap = descriptor.getResolvedSnapshotDependencies().get( relDependencyKey );
- assertEquals( "1.3", versionMap.get( ReleaseDescriptor.RELEASE_KEY ) );
-
- 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 @@
{
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 @@
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 @@
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.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 @@
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.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 @@
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.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 @@
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 @@
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 @@
{
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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.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 @@
{
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.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 @@
throws Exception
{
super.setUp();
- phase = (ReleasePhase) lookup( ReleasePhase.class, getRoleHint() );
+ phase = lookup( ReleasePhase.class, getRoleHint() );
if( phase instanceof AbstractRewritePomsPhase)
{
@@ -96,10 +97,10 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
{
// 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 @@
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 @@
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 @@
{
// 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 @@
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 @@
{
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
}
- protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ return createDescriptorFromProjects( new ReleaseDescriptorBuilder(), reactorProjects );
+ }
+
+ protected ReleaseDescriptorBuilder createDescriptorFromProjects( ReleaseDescriptorBuilder builder, List<MavenProject> reactorProjects )
+ {
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 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 @@
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 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 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 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.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 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
}
// 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 @@
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 @@
}
// 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 @@
@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 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 @@
{
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 @@
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 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 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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -160,14 +161,14 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -197,12 +198,12 @@
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 @@
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 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -268,8 +269,8 @@
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 @@
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -293,7 +294,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -310,14 +311,14 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -344,12 +345,12 @@
public void 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 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 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 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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -423,14 +424,14 @@
public void 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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -455,14 +456,14 @@
public void 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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -490,26 +491,25 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
createMockPrompter( "yes", "1", Arrays.asList( pair, pair ), Arrays.asList( defaultPair, defaultPair ) );
phase.setPrompter( mockPrompter );
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
- Map<String, Map<String, String>> resolvedDependencies = releaseDescriptor.getResolvedSnapshotDependencies();
+ ReleaseDescriptor descriptor = ReleaseUtils.buildReleaseDescriptor( builder );
- assertNotNull( resolvedDependencies );
- assertEquals( 2, resolvedDependencies.size() );
+ assertEquals( "1.0", descriptor.getDependencyReleaseVersion( "external:artifactId" ) );
+ assertEquals( "1.1-SNAPSHOT", descriptor.getDependencyDevelopmentVersion( "external:artifactId" ) );
- assertTrue( resolvedDependencies.containsKey( "external:artifactId" ) );
- assertTrue( resolvedDependencies.containsKey( "external:artifactId2" ) );
-
- Map<String, String> versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
-
- assertNotNull( versionsMap );
- assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
- assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
-
- versionsMap = releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId2" );
-
- 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 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -688,12 +672,12 @@
public void 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 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 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -758,15 +742,15 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -793,12 +777,12 @@
public void 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 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 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 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 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 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -908,14 +892,14 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -945,14 +929,14 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -982,14 +966,14 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -1019,33 +1003,32 @@
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 @@
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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have failed execution" );
}
@@ -1092,12 +1075,12 @@
public void 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 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 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 @@
}
// 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.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 void testCorrectlyConfigured()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" );
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
// successful execution is verification enough
assertTrue( true );
@@ -66,73 +67,66 @@
public void testGetUrlFromProjectConnection()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" );
+
MavenProject project = createProject( "1.0-SNAPSHOT" );
- Scm scm = new Scm();
- scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
- project.setScm( scm );
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
- assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+ assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
}
public void testGetUrlFromProjectConnectionSimulate()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/repo" );
+
MavenProject project = createProject( "1.0-SNAPSHOT" );
- Scm scm = new Scm();
- scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
- project.setScm( scm );
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
- assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+ assertEquals( "Check URL", "scm:svn:file://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
}
public void testGetUrlFromProjectDevConnection()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:https://localhost/tmp/repo" );
+
MavenProject project = createProject( "1.0-SNAPSHOT" );
- Scm scm = new Scm();
- scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
- scm.setDeveloperConnection( "scm:svn:https://localhost/tmp/repo" );
- project.setScm( scm );
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
- assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+ assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
}
public void testGetUrlFromProjectDevConnectionSimulate()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:https://localhost/tmp/repo" );
+
MavenProject project = createProject( "1.0-SNAPSHOT" );
- Scm scm = new Scm();
- scm.setConnection( "scm:svn:file://localhost/tmp/repo" );
- scm.setDeveloperConnection( "scm:svn:https://localhost/tmp/repo" );
- project.setScm( scm );
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
- assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", releaseDescriptor.getScmSourceUrl() );
+ assertEquals( "Check URL", "scm:svn:https://localhost/tmp/repo", ReleaseUtils.buildReleaseDescriptor( builder ).getScmSourceUrl() );
}
public void testGetInvalidUrl()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:cvs:" );
+
MavenProject project = createProject( "1.0-SNAPSHOT" );
- Scm scm = new Scm();
- scm.setConnection( "scm:cvs:" );
- project.setScm( scm );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
fail( "Should have thrown an exception" );
}
@@ -145,7 +139,7 @@
public void 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 @@
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( project ) );
fail( "Should have thrown an exception" );
}
@@ -166,11 +160,11 @@
public void 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 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), Collections.singletonList( createProject( "1.0-SNAPSHOT" ) ) );
fail( "Should have failed to simulate" );
}
@@ -194,12 +188,12 @@
public void 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 @@
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.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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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.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 @@
{
super.setUp();
- phase = (ReleasePhase) lookup( ReleasePhase.class, "end-release" );
+ phase = lookup( ReleasePhase.class, "end-release" );
}
@Test
public void testExecute()
throws ReleaseExecutionException, ReleaseFailureException
{
- ReleaseResult result = phase.execute( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
+ ReleaseResult result = phase.execute( ReleaseUtils.buildReleaseDescriptor( new ReleaseDescriptorBuilder() ), new DefaultReleaseEnvironment(), null );
assertEquals( ReleaseResult.SUCCESS, result.getResultCode() );
}
@@ -61,7 +62,7 @@
public void 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.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 @@
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 @@
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 @@
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 @@
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 @@
* 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 @@
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 @@
* 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 @@
* 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 @@
* 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 @@
* 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 @@
* specific language governing permissions and limitations
* under the License.
*/
-
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.mock;
@@ -35,7 +37,8 @@
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.release.PlexusJUnit4TestCase;
import org.apache.maven.shared.release.ReleaseExecutionException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.codehaus.plexus.components.interactivity.Prompter;
import org.codehaus.plexus.components.interactivity.PrompterException;
@@ -71,26 +74,26 @@
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
// 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 @@
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 @@
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 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 @@
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 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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
* 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 @@
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 @@
* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
* 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 @@
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 @@
* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
- releaseDescriptor.getReleaseVersions() );
+ assertEquals( "Check release versions", "1.2-SNAPSHOT",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
assertNull( "Check development versions",
- releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
}
@Test
@@ -1736,17 +1735,17 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setBranchCreation( true );
- releaseDescriptor.setUpdateWorkingCopyVersions( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setBranchCreation( true );
+ builder.setUpdateWorkingCopyVersions( false );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
- assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
- releaseDescriptor.getDevelopmentVersions() );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+ assertEquals( "Check development versions", "1.2-SNAPSHOT",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
}
@Test
@@ -1758,17 +1757,17 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setBranchCreation( true );
- releaseDescriptor.setUpdateWorkingCopyVersions( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setBranchCreation( true );
+ builder.setUpdateWorkingCopyVersions( false );
// test
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
- assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
- releaseDescriptor.getDevelopmentVersions() );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
+ assertEquals( "Check development versions", "1.2-SNAPSHOT",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
}
@Test
@@ -1780,21 +1779,21 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setBranchCreation( true );
- releaseDescriptor.setUpdateBranchVersions( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setBranchCreation( true );
+ builder.setUpdateBranchVersions( true );
// org.apache.maven.release:maven-release-manager:(,2.4) > true
// org.apache.maven.release:maven-release-manager:[2.4,) > false
- releaseDescriptor.setInteractive( false );
+ builder.setInteractive( false );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
- releaseDescriptor.getReleaseVersions() );
+ assertEquals( "Check release versions", "1.2",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
assertNull( "Check development versions",
- releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
}
@Test
@@ -1806,21 +1805,21 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setBranchCreation( true );
- releaseDescriptor.setUpdateBranchVersions( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setBranchCreation( true );
+ builder.setUpdateBranchVersions( true );
// org.apache.maven.release:maven-release-manager:(,2.4) > true
// org.apache.maven.release:maven-release-manager:[2.4,) > false
- releaseDescriptor.setInteractive( false );
+ builder.setInteractive( false );
// test
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
- releaseDescriptor.getReleaseVersions() );
+ assertEquals( "Check release versions", "1.2" ,
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
assertNull( "Check development versions",
- releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId" ) );
}
@Test
@@ -1832,16 +1831,16 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setBranchCreation( true );
- releaseDescriptor.setUpdateWorkingCopyVersions( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setBranchCreation( true );
+ builder.setUpdateWorkingCopyVersions( true );
when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ),
eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
phase.setPrompter( mockPrompter );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) );
@@ -1856,16 +1855,16 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setBranchCreation( true );
- releaseDescriptor.setUpdateWorkingCopyVersions( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setBranchCreation( true );
+ builder.setUpdateWorkingCopyVersions( true );
when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ),
eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
phase.setPrompter( mockPrompter );
// test
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) );
@@ -1882,19 +1881,18 @@
Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ),
createProject( "module1", "2.0" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setAutoVersionSubmodules( true );
- releaseDescriptor.setInteractive( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setAutoVersionSubmodules( true );
+ builder.setInteractive( false );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- Map<String, String> developmentVersions = new HashMap<>();
- developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" );
- developmentVersions.put( "groupId:module1", "2.0" );
- assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() );
- assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() );
+ assertEquals( "Check development versions", "1.3-SNAPSHOT", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+ assertEquals( "Check development versions", "2.0" , ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:module1") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:module1") );
}
@Test
@@ -1908,19 +1906,18 @@
Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ),
createProject( "module1", "2.0" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setAutoVersionSubmodules( true );
- releaseDescriptor.setInteractive( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setAutoVersionSubmodules( true );
+ builder.setInteractive( false );
// test
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- Map<String, String> developmentVersions = new HashMap<>();
- developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" );
- developmentVersions.put( "groupId:module1", "2.0" );
- assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() );
- assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() );
+ assertEquals( "Check development versions", "1.3-SNAPSHOT", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion( "groupId:artifactId" ) );
+ assertEquals( "Check development versions", "2.0", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:module1") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:module1") );
}
@Test
@@ -1933,18 +1930,18 @@
List<MavenProject> reactorProjects =
Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setAutoVersionSubmodules( true );
- releaseDescriptor.setDefaultReleaseVersion( "3.0" );
- releaseDescriptor.setInteractive( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setAutoVersionSubmodules( true );
+ builder.setDefaultReleaseVersion( "3.0" );
+ builder.setInteractive( false );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ),
- releaseDescriptor.getDevelopmentVersions() );
- assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+ assertEquals( "Check development versions", "3.1-SNAPSHOT" ,
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion("groupId:artifactId" ) );
}
@Test
@@ -1957,18 +1954,18 @@
List<MavenProject> reactorProjects =
Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setAutoVersionSubmodules( true );
- releaseDescriptor.setDefaultReleaseVersion( "3.0" );
- releaseDescriptor.setInteractive( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setAutoVersionSubmodules( true );
+ builder.setDefaultReleaseVersion( "3.0" );
+ builder.setInteractive( false );
// test
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ),
- releaseDescriptor.getDevelopmentVersions() );
- assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+ assertEquals( "Check development versions", "3.1-SNAPSHOT",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
}
@Test
@@ -1981,18 +1978,18 @@
List<MavenProject> reactorProjects =
Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setAutoVersionSubmodules( true );
- releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
- releaseDescriptor.setInteractive( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setAutoVersionSubmodules( true );
+ builder.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
+ builder.setInteractive( false );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ),
- releaseDescriptor.getDevelopmentVersions() );
- assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+ assertEquals( "Check development versions", "3.0-SNAPSHOT",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
}
@Test
@@ -2005,18 +2002,18 @@
List<MavenProject> reactorProjects =
Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setAutoVersionSubmodules( true );
- releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
- releaseDescriptor.setInteractive( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setAutoVersionSubmodules( true );
+ builder.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
+ builder.setInteractive( false );
// test
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
- assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ),
- releaseDescriptor.getDevelopmentVersions() );
- assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
+ assertEquals( "Check development versions", "3.0-SNAPSHOT",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+ assertNull( "Check release versions", ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
}
// MRELEASE-511
@@ -2031,20 +2028,20 @@
List<MavenProject> reactorProjects =
Collections.singletonList( createProject( "artifactId", "MYB_200909-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setDefaultReleaseVersion( "PPX" );
- releaseDescriptor.setDefaultDevelopmentVersion( "MYB_200909-SNAPSHOT" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setDefaultReleaseVersion( "PPX" );
+ builder.setDefaultDevelopmentVersion( "MYB_200909-SNAPSHOT" );
// test
- mapReleasephase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
- mapDevelopmentphase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ mapReleasephase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
+ mapDevelopmentphase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
assertEquals( "Check development versions",
- Collections.singletonMap( "groupId:artifactId", "MYB_200909-SNAPSHOT" ),
- releaseDescriptor.getDevelopmentVersions() );
- assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "PPX" ),
- releaseDescriptor.getReleaseVersions() );
+ "MYB_200909-SNAPSHOT",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectDevelopmentVersion("groupId:artifactId") );
+ assertEquals( "Check release versions", "PPX",
+ ReleaseUtils.buildReleaseDescriptor( builder ).getProjectReleaseVersion( "groupId:artifactId" ) );
}
// MRELEASE-269
@@ -2057,7 +2054,7 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
when( mockPrompter.prompt( startsWith( "What is the new development version for " ),
eq( "1.12-SNAPSHOT" ) ) ).thenReturn( "2.0" ) // wrong, expected SNAPSHOT
@@ -2065,7 +2062,7 @@
phase.setPrompter( mockPrompter );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for " ),
@@ -2082,15 +2079,15 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setDefaultDevelopmentVersion( "" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setDefaultDevelopmentVersion( "" );
when( mockPrompter.prompt( startsWith( "What is the new development version for " ),
eq( "1.12-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
phase.setPrompter( mockPrompter );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( mockPrompter ).prompt( startsWith( "What is the new development version for " ),
@@ -2106,15 +2103,15 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setDefaultReleaseVersion( "" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setDefaultReleaseVersion( "" );
when( mockPrompter.prompt( startsWith( "What is the release version for " ),
eq( "1.11" ) ) ).thenReturn( "2.0" );
phase.setPrompter( mockPrompter );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( mockPrompter ).prompt( startsWith( "What is the release version for " ), eq( "1.11" ) );
@@ -2136,11 +2133,11 @@
List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setProjectVersionPolicyId( "UNKNOWN" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setProjectVersionPolicyId( "UNKNOWN" );
// test
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
}
private static MavenProject createProject( String artifactId, String version )
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java
index 54caabe..964a5cf 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RemoveReleasePomsPhaseTest.java
@@ -46,7 +46,8 @@
import org.apache.maven.scm.provider.ScmProvider;
import org.apache.maven.scm.repository.ScmRepository;
import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.util.ReleaseUtil;
import org.codehaus.plexus.util.IOUtil;
@@ -66,7 +67,7 @@
{
super.setUp();
- phase = (ReleasePhase) lookup( ReleasePhase.class, "remove-release-poms" );
+ phase = lookup( ReleasePhase.class, "remove-release-poms" );
}
@Test
@@ -74,12 +75,13 @@
throws Exception
{
// prepare
+ File workingDirectory = getTestFile( "target/test/checkout" );
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
- ReleaseDescriptor config = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( workingDirectory );
MavenProject project = ReleaseUtil.getRootProject( reactorProjects );
File releasePom = ReleaseUtil.getReleasePom( project );
- ScmFileSet fileSet = new ScmFileSet( new File( config.getWorkingDirectory() ), releasePom );
+ ScmFileSet fileSet = new ScmFileSet( workingDirectory, releasePom );
ScmProvider scmProviderMock = mock( ScmProvider.class );
when( scmProviderMock.remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -91,7 +93,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -104,8 +106,9 @@
throws Exception
{
// prepare
+ File workingDirectory = getTestFile( "target/test/checkout" );
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-modules" );
- ReleaseDescriptor config = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
List<File> releasePoms = new ArrayList<>();
for ( Iterator<MavenProject> iterator = reactorProjects.iterator(); iterator.hasNext(); )
@@ -115,7 +118,7 @@
releasePoms.add( releasePom );
}
- ScmFileSet fileSet = new ScmFileSet( new File( config.getWorkingDirectory() ), releasePoms );
+ ScmFileSet fileSet = new ScmFileSet( workingDirectory, releasePoms );
ScmProvider scmProviderMock = mock( ScmProvider.class );
when( scmProviderMock.remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -127,7 +130,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).remove( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -141,7 +144,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
- ReleaseDescriptor config = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmProvider scmProviderMock = mock( ScmProvider.class );
@@ -149,7 +152,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// never invoke scmProviderMock
verifyNoMoreInteractions( scmProviderMock );
@@ -161,9 +164,9 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
- ReleaseDescriptor config = createReleaseDescriptor();
- config.setSuppressCommitBeforeTagOrBranch( true );
- config.setGenerateReleasePoms( true );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+ builder.setSuppressCommitBeforeTagOrBranch( true );
+ builder.setGenerateReleasePoms( true );
ScmProvider scmProviderMock = mock( ScmProvider.class );
@@ -171,7 +174,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- ReleaseResult result = phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ ReleaseResult result = phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
BufferedReader reader = null;
try
@@ -197,9 +200,9 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
- ReleaseDescriptor config = createReleaseDescriptor();
- config.setSuppressCommitBeforeTagOrBranch( true );
- config.setGenerateReleasePoms( true );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+ builder.setSuppressCommitBeforeTagOrBranch( true );
+ builder.setGenerateReleasePoms( true );
ScmProvider scmProviderMock = mock( ScmProvider.class );
@@ -207,7 +210,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- ReleaseResult result = phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ ReleaseResult result = phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
BufferedReader reader = null;
try
@@ -236,11 +239,16 @@
return createReactorProjects( dir, dir, null );
}
- private ReleaseDescriptor createReleaseDescriptor()
+ private ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setGenerateReleasePoms( true );
- descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
- return descriptor;
+ return createReleaseDescriptorBuilder( getTestFile( "target/test/checkout" ) );
+ }
+
+ private ReleaseDescriptorBuilder createReleaseDescriptorBuilder( File workingDirectory )
+ {
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setGenerateReleasePoms( true );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ return builder;
}
}
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java
index e6ae373..dacb66a 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RestoreBackupPomsPhaseTest.java
@@ -22,11 +22,11 @@
import static org.junit.Assert.assertTrue;
import java.io.File;
-import java.util.Iterator;
import java.util.List;
import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.util.ReleaseUtil;
import org.codehaus.plexus.util.FileUtils;
@@ -44,7 +44,7 @@
ReleasePhase getReleasePhase()
throws Exception
{
- return (ReleasePhase) lookup( ReleasePhase.class, "restore-backup-poms" );
+ return lookup( ReleasePhase.class, "restore-backup-poms" );
}
@Test
@@ -84,9 +84,9 @@
{
List<MavenProject> projects = getReactorProjects( getTestPath( path ) );
- ReleaseDescriptor desc = new ReleaseDescriptor();
- desc.setScmSourceUrl( "scm:svn:http://myhost/myrepo" );
- phase.execute( desc, new DefaultReleaseEnvironment(), projects );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:http://myhost/myrepo" );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), projects );
testProjectIsRestored( projects );
}
@@ -94,10 +94,8 @@
private void testProjectIsRestored( List<MavenProject> reactorProjects )
throws Exception
{
- for ( Iterator<MavenProject> projects = reactorProjects.iterator(); projects.hasNext(); )
+ for ( MavenProject project : reactorProjects )
{
- MavenProject project = projects.next();
-
File pomFile = project.getFile();
File expectedFile = new File( pomFile.getParentFile(), expectedPomFilename );
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java
index b9da089..6eb74b2 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForBranchPhaseTest.java
@@ -25,12 +25,13 @@
import java.io.File;
import java.io.IOException;
-import java.util.Iterator;
import java.util.List;
import java.util.Objects;
+import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.util.ReleaseUtil;
import org.junit.Test;
@@ -78,12 +79,12 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
String expected = readTestProjectFile( "basic-pom/pom.xml" );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
String actual = readTestProjectFile( "basic-pom/pom.xml" );
assertEquals( "Check the original POM untouched", expected, actual );
@@ -98,12 +99,12 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-dashes-in-comment" );
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
String expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
String actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
assertEquals( "Check the original POM is untouched", expected, actual );
@@ -118,14 +119,14 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
File testFile = getTestFile( "target/test-classes/projects/rewrite-for-branch/basic-pom/pom.xml.branch" );
testFile.delete();
assertFalse( testFile.exists() );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( testFile.exists() );
@@ -139,8 +140,8 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
File testFile = getTestFile( "target/test-classes/projects/rewrite-for-branch/basic-pom/pom.xml.branch" );
testFile.delete();
@@ -157,50 +158,50 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-overridden-scm" );
- ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
- config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+ builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@Override
- protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
+ protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
- config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
+ config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
}
@Override
- protected void mapNextVersion( ReleaseDescriptor config, String projectId )
+ protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
- config.mapReleaseVersion( projectId, NEXT_VERSION );
+ config.addReleaseVersion( projectId, NEXT_VERSION );
}
@Override
- protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<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 );
- return config;
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ return builder;
}
@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 );
- return config;
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION );
+ return builder;
}
@Override
- protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
+ protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
// nothing to do
}
@@ -211,10 +212,10 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -225,10 +226,10 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-scm-expression" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -239,11 +240,11 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.setScmBranchBase( "file://localhost/tmp/scm-repo/branches" );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.setScmBranchBase( "file://localhost/tmp/scm-repo/branches" );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -253,11 +254,11 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base-and-varying-scm-urls" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.setScmBranchBase( "file://localhost/tmp/scm-repo/allprojects/branches" );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.setScmBranchBase( "file://localhost/tmp/scm-repo/allprojects/branches" );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -267,10 +268,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -280,10 +281,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-empty-scm" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -293,9 +294,9 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
- ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+ ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -305,19 +306,17 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject3", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject3", NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
- for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
+ for ( MavenProject project : reactorProjects )
{
- MavenProject project = i.next();
-
// skip subproject1 - we don't need to worry about its version mapping change, it has no deps of any kind
if ( !"groupId".equals( project.getGroupId() ) || !"subproject1".equals( project.getArtifactId() ) )
{
@@ -331,10 +330,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-inherited-scm" );
- ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
- config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+ builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -345,12 +344,12 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent-and-properties" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -362,12 +361,12 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -379,11 +378,11 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-scm-of-parent-ending-with-a-slash" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -394,12 +393,12 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "multimodule-with-deep-subprojects" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -410,9 +409,9 @@
{
List<MavenProject> reactorProjects =
createReactorProjects( "rewrite-for-branch/pom-with-parent-flat", "root-project" );
- ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+ ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -423,23 +422,23 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "cdata-section" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
AbstractRewritePomsPhase phase = (AbstractRewritePomsPhase) this.phase;
phase.setLs( "\r\n" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// compare POMS without line ending normalization
assertTrue( comparePomFiles( reactorProjects, false ) );
}
@Override
- protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
{
- ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects );
- descriptor.setScmReleaseLabel( "release-label" );
- return descriptor;
+ ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects );
+ builder.setScmReleaseLabel( "release-label" );
+ return builder;
}
// MRELEASE-454
@@ -448,9 +447,9 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "imported-dependency-management-in-reactor" );
- ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+ ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -460,10 +459,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "modules-with-different-versions" );
- ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java
index af94c55..cea16c5 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForDevelopmentPhaseTest.java
@@ -26,7 +26,6 @@
import java.io.File;
import java.io.IOException;
-import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
@@ -34,7 +33,8 @@
import org.apache.maven.model.Scm;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.release.ReleaseExecutionException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.util.ReleaseUtil;
import org.junit.Test;
@@ -71,13 +71,13 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsWhenSimulated( "basic-pom" );
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
String expected = readTestProjectFile( "basic-pom/pom.xml" );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
String actual = readTestProjectFile( "basic-pom/pom.xml" );
assertEquals( "Check the original POM untouched", expected, actual );
@@ -100,15 +100,15 @@
List<MavenProject> reactorProjects =
new LinkedList<>( createReactorProjects( "basic-pom-ejb-client-dep/project" ) );
reactorProjects.addAll( createReactorProjects( "basic-pom-ejb-client-dep/ejb" ) );
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
- config.addDevelopmentVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), NEXT_VERSION );
- config.addReleaseVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), RELEASE_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addDevelopmentVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), NEXT_VERSION );
+ builder.addReleaseVersion( ArtifactUtils.versionlessKey( "groupId", "artifactId1" ), RELEASE_VERSION );
String expected = readTestProjectFile( "basic-pom-ejb-client-dep/project/pom.xml" );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
String actual = readTestProjectFile( "basic-pom-ejb-client-dep/project/pom.xml" );
assertEquals( "Check the original POM untouched", expected, actual );
@@ -123,15 +123,15 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsWhenSimulated( "basic-pom" );
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
File testFile = getTestFile( "target/test-classes/projects/rewrite-for-development/basic-pom/pom.xml.next" );
testFile.delete();
assertFalse( testFile.exists() );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( testFile.exists() );
@@ -145,9 +145,6 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
File testFile = getTestFile( "target/test-classes/projects/rewrite-for-development/basic-pom/pom.xml.next" );
testFile.delete();
@@ -164,13 +161,19 @@
{
List<MavenProject> reactorProjects = prepareReactorProjects( "basic-pom", true );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder() {
+ public ReleaseDescriptorBuilder addOriginalScmInfo(String key, Scm value) {
+ // do nothing
+ return this;
+ };
+ };
+ builder = createDescriptorFromProjects( builder, reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ mapNextVersion( builder, "groupId:artifactId" );
try
{
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Expected failure" );
}
@@ -202,73 +205,73 @@
}
@Override
- protected ReleaseDescriptor createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
throws Exception
{
- ReleaseDescriptor config = super.createDescriptorFromBasicPom( reactorProjects );
+ ReleaseDescriptorBuilder builder = super.createDescriptorFromBasicPom( reactorProjects );
- mapScm( config );
+ mapScm( builder );
- return config;
+ return builder;
}
- private void mapScm( ReleaseDescriptor config )
+ private void mapScm( ReleaseDescriptorBuilder builder )
{
Scm scm = new Scm();
scm.setConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
scm.setDeveloperConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
scm.setUrl( "file://localhost/tmp/scm-repo/trunk" );
- config.mapOriginalScmInfo( "groupId:artifactId", scm );
+ builder.addOriginalScmInfo( "groupId:artifactId", scm );
}
@Override
- protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
+ protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
- config.mapReleaseVersion( projectId, ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( projectId, ALTERNATIVE_NEXT_VERSION );
+ config.addReleaseVersion( projectId, ALTERNATIVE_RELEASE_VERSION );
+ config.addDevelopmentVersion( projectId, ALTERNATIVE_NEXT_VERSION );
}
@Override
- protected void mapNextVersion( ReleaseDescriptor config, String projectId )
+ protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
- config.mapReleaseVersion( projectId, RELEASE_VERSION );
- config.mapDevelopmentVersion( projectId, NEXT_VERSION );
+ config.addReleaseVersion( projectId, RELEASE_VERSION );
+ config.addDevelopmentVersion( projectId, NEXT_VERSION );
}
@Override
- protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
+ protected void unmapNextVersion( ReleaseDescriptorBuilder builder, String projectId )
{
- config.mapReleaseVersion( projectId, RELEASE_VERSION );
+ builder.addReleaseVersion( projectId, RELEASE_VERSION );
}
@Override
- protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
throws Exception
{
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- mapScm( config );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ mapScm( builder );
- return config;
+ return builder;
}
@Override
- protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
throws Exception
{
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
- mapScm( config );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
+ mapScm( builder );
- return config;
+ return builder;
}
@Test
@@ -277,16 +280,16 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
Scm scm = new Scm();
scm.setConnection( "${scm.base}:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
scm.setDeveloperConnection( "${scm.base}:ext:${username}@localhost:/tmp/scm-repo:module" );
scm.setUrl( "${baseUrl}/module" );
- config.mapOriginalScmInfo( "groupId:artifactId", scm );
+ builder.addOriginalScmInfo( "groupId:artifactId", scm );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -297,17 +300,17 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
Scm scm = new Scm();
scm.setConnection( "scm:cvs:pserver:anoncvs@localhost:/tmp/scm-repo:module" );
scm.setDeveloperConnection( "scm:cvs:ext:${username}@localhost:/tmp/scm-repo:module" );
scm.setUrl( "http://localhost/viewcvs.cgi/module" );
scm.setTag( "original-label" );
- config.mapOriginalScmInfo( "groupId:artifactId", scm );
+ builder.addOriginalScmInfo( "groupId:artifactId", scm );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -318,24 +321,23 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-inherited-scm" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subsubproject", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subsubproject", NEXT_VERSION );
- config.mapOriginalScmInfo( "groupId:artifactId", null );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject1", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subsubproject", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subsubproject", NEXT_VERSION );
Scm scm = new Scm();
scm.setConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk/subproject1" );
scm.setDeveloperConnection( "scm:svn:file://localhost/tmp/scm-repo/trunk/subproject1" );
// MRELEASE-107
scm.setUrl( "http://localhost/viewvc/mypath/trunk/subproject1" );
- config.mapOriginalScmInfo( "groupId:subproject1", scm );
- config.mapOriginalScmInfo( "groupId:subsubproject", null );
+ builder.addOriginalScmInfo( "groupId:subproject1", scm );
+ builder.addOriginalScmInfo( "groupId:subsubproject", null );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -368,17 +370,17 @@
{
List<MavenProject> reactorProjects = createReactorProjects( path );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- mapScm( config );
+ mapScm( builder );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -390,22 +392,20 @@
// use the original ones since simulation didn't modify them
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent-and-properties-sim" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- mapScm( config );
+ mapScm( builder );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
- for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
+ for ( MavenProject project : reactorProjects )
{
- MavenProject project = i.next();
-
File pomFile = project.getFile();
File actualFile = new File( pomFile.getParentFile(), pomFile.getName() + ".next" );
File expectedFile = new File( actualFile.getParentFile(), "expected-pom.xml" );
@@ -421,17 +421,17 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
- config.mapDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_RELEASE_VERSION );
+ builder.addDevelopmentVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- mapScm( config );
+ mapScm( builder );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -442,11 +442,11 @@
{
List<MavenProject> reactorProjects =
createReactorProjects( "internal-snapshot-dependencies-without-dependencies-version-update" );
- ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
- config.setUpdateDependencies( false );
- mapNextVersion( config, "groupId:subsubproject" );
+ ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects );
+ builder.setUpdateDependencies( false );
+ mapNextVersion( builder, "groupId:subsubproject" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java
index a89ef57..d81b7a5 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RewritePomsForReleasePhaseTest.java
@@ -30,7 +30,9 @@
import java.util.Objects;
import org.apache.maven.project.MavenProject;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseStageVersions;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.util.ReleaseUtil;
import org.junit.Test;
@@ -78,12 +80,12 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
String expected = readTestProjectFile( "basic-pom/pom.xml" );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
String actual = readTestProjectFile( "basic-pom/pom.xml" );
assertEquals( "Check the original POM untouched", expected, actual );
@@ -98,12 +100,12 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-dashes-in-comment" );
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
String expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
String actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
assertEquals( "Check the original POM is untouched", expected, actual );
@@ -118,14 +120,14 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" );
testFile.delete();
assertFalse( testFile.exists() );
- phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( testFile.exists() );
@@ -139,8 +141,6 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
- ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" );
testFile.delete();
@@ -157,50 +157,50 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-overridden-scm" );
- ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
- config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+ builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@Override
- protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
+ protected void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
- config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
+ config.addReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
}
@Override
- protected void mapNextVersion( ReleaseDescriptor config, String projectId )
+ protected void mapNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
- config.mapReleaseVersion( projectId, NEXT_VERSION );
+ config.addReleaseVersion( projectId, NEXT_VERSION );
}
@Override
- protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<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 );
- return config;
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ return builder;
}
@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 );
- return config;
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", NEXT_VERSION );
+ return builder;
}
@Override
- protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
+ protected void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId )
{
// nothing to do
}
@@ -211,10 +211,10 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -225,10 +225,10 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-scm-expression" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -239,11 +239,11 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.setScmTagBase( "file://localhost/tmp/scm-repo/releases" );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.setScmTagBase( "file://localhost/tmp/scm-repo/releases" );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -253,11 +253,11 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base-and-varying-scm-urls" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.setScmTagBase( "file://localhost/tmp/scm-repo/allprojects/releases" );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.setScmTagBase( "file://localhost/tmp/scm-repo/allprojects/releases" );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -267,10 +267,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -280,10 +280,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-empty-scm" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -293,9 +293,9 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
- ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+ ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -305,14 +305,14 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject3", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject3", NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
{
@@ -331,10 +331,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-inherited-scm" );
- ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
- config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects );
+ builder.addReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -345,12 +345,12 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent-and-properties" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -362,12 +362,12 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -379,11 +379,11 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-scm-of-parent-ending-with-a-slash" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -394,12 +394,12 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "multimodule-with-deep-subprojects" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addReleaseVersion( "groupId:artifactId", NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -410,9 +410,9 @@
{
List<MavenProject> reactorProjects =
createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" );
- ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
+ ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -423,23 +423,23 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "cdata-section" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- mapNextVersion( config, "groupId:artifactId" );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ mapNextVersion( builder, "groupId:artifactId" );
RewritePomsForReleasePhase phase = (RewritePomsForReleasePhase) this.phase;
phase.setLs( "\r\n" );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// compare POMS without line ending normalization
assertTrue( comparePomFiles( reactorProjects, false ) );
}
@Override
- protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
+ protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects )
{
- ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects );
- descriptor.setScmReleaseLabel( "release-label" );
- return descriptor;
+ ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects( reactorProjects );
+ builder.setScmReleaseLabel( "release-label" );
+ return builder;
}
@Test
@@ -448,11 +448,12 @@
{
List<MavenProject> reactorProjects = createReactorProjects( "pom-with-externally-released-parent" );
- ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
- config.mapResolvedSnapshotDependencies( "external:parent-artifactId", "1", "2-SNAPSHOT" );
- config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects );
+ builder.addDependencyReleaseVersion( "external:parent-artifactId", "1" );
+ builder.addDependencyDevelopmentVersion( "external:parent-artifactId", "2-SNAPSHOT" );
+ builder.addReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -463,9 +464,9 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "imported-dependency-management-in-reactor" );
- ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
+ ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
@@ -475,10 +476,10 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects( "modules-with-different-versions" );
- ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
- config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
+ ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects );
+ builder.addReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
- phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
assertTrue( comparePomFiles( reactorProjects ) );
}
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java
index 9710ddc..ee520f3 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunCompleteGoalsPhaseTest.java
@@ -37,7 +37,8 @@
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
import org.apache.maven.shared.release.exec.MavenExecutor;
@@ -57,7 +58,7 @@
private MavenExecutorWrapper mavenExecutorWrapper;
- private ReleaseEnvironment releaseEnvironment;
+ private DefaultReleaseEnvironment releaseEnvironment;
@Override
public void setUp()
@@ -80,16 +81,16 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setCompletionGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setCompletionGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
// execute
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
// verify
verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -105,16 +106,16 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setCompletionGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setCompletionGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
// execute
- phase.simulate( config, releaseEnvironment, null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
// verify
verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -130,9 +131,9 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setCompletionGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setCompletionGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
doThrow( new MavenExecutorException( "...",
@@ -149,7 +150,7 @@
// execute
try
{
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
fail( "Should have thrown an exception" );
}
@@ -172,9 +173,9 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setCompletionGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setCompletionGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
doThrow( new MavenExecutorException( "...",
@@ -191,7 +192,7 @@
// execute
try
{
- phase.simulate( config, releaseEnvironment, null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
fail( "Should have thrown an exception" );
}
@@ -214,16 +215,16 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setCompletionGoals( "" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setCompletionGoals( "" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
// execute
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
// verify
// never invoke mock
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java
index f7bcd64..4b7ca8a 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPerformGoalsPhaseTest.java
@@ -48,7 +48,8 @@
import org.apache.maven.shared.release.PlexusJUnit4TestCase;
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
import org.apache.maven.shared.release.exec.MavenExecutor;
@@ -67,7 +68,7 @@
private MavenExecutorWrapper mavenExecutorWrapper;
- private ReleaseEnvironment releaseEnvironment;
+ private DefaultReleaseEnvironment releaseEnvironment;
@Override
public void setUp()
@@ -90,9 +91,9 @@
// prepare
File testFile = getTestFile( "target/checkout-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setPerformGoals( "goal1 goal2" );
- config.setCheckoutDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setPerformGoals( "goal1 goal2" );
+ builder.setCheckoutDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
@@ -111,7 +112,7 @@
// execute
try
{
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
fail( "Should have thrown an exception" );
}
@@ -136,16 +137,16 @@
{
//prepare
File testFile = getTestFile( "target/checkout-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setPerformGoals( "goal1 goal2" );
- config.setPomFileName( "pom1.xml" );
- config.setCheckoutDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setPerformGoals( "goal1 goal2" );
+ builder.setPomFileName( "pom1.xml" );
+ builder.setCheckoutDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
verify( mock ).executeGoals( eq( testFile ),
eq( "goal1 goal2" ),
@@ -162,12 +163,12 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" );
- releaseDescriptor.setPerformGoals( "goal1 goal2" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setAdditionalArguments( "-Dmaven.test.skip=true" );
+ builder.setPerformGoals( "goal1 goal2" );
File checkoutDirectory = getTestFile( "target/checkout-directory" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
@@ -182,10 +183,10 @@
ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
stub.setScmProvider( scmProviderMock );
- releaseDescriptor.setUseReleaseProfile( false );
+ builder.setUseReleaseProfile( false );
// execute
- phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
// verify
verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -206,11 +207,11 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setPerformGoals( "goal1 goal2" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setPerformGoals( "goal1 goal2" );
File checkoutDirectory = getTestFile( "target/checkout-directory" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
@@ -226,7 +227,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
// verify
verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -247,11 +248,11 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setPerformGoals( "goal1 goal2" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setPerformGoals( "goal1 goal2" );
File checkoutDirectory = getTestFile( "target/checkout-directory" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
@@ -266,10 +267,10 @@
ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
stub.setScmProvider( scmProviderMock );
- releaseDescriptor.setUseReleaseProfile( false );
+ builder.setUseReleaseProfile( false );
// execute
- phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
// verify
verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -290,12 +291,12 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" );
- releaseDescriptor.setPerformGoals( "goal1 goal2" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setAdditionalArguments( "-Dmaven.test.skip=true" );
+ builder.setPerformGoals( "goal1 goal2" );
File checkoutDirectory = getTestFile( "target/checkout-directory" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
@@ -311,7 +312,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
// verify
verify( mock ).executeGoals( eq( checkoutDirectory ),
@@ -332,11 +333,11 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setPerformGoals( "goal1 goal2" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setPerformGoals( "goal1 goal2" );
File checkoutDirectory = getTestFile( "target/checkout-directory" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
@@ -351,10 +352,10 @@
ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
stub.setScmProvider( scmProviderMock );
- releaseDescriptor.setCompletedPhase( "end-release" );
+ builder.setCompletedPhase( "end-release" );
// execute
- phase.execute( releaseDescriptor, releaseEnvironment, createReactorProjects() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, createReactorProjects() );
// verify
verify( mock ).executeGoals( eq( checkoutDirectory ),
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java
index 6a84ff7..4222580 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/RunPrepareGoalsPhaseTest.java
@@ -37,7 +37,8 @@
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
import org.apache.maven.shared.release.exec.MavenExecutor;
@@ -57,7 +58,7 @@
private MavenExecutorWrapper mavenExecutorWrapper;
- private ReleaseEnvironment releaseEnvironment;
+ private DefaultReleaseEnvironment releaseEnvironment;
@Override
public void setUp()
@@ -80,16 +81,16 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setPreparationGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setPreparationGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
// execute
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
// verify
verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -105,16 +106,16 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setPreparationGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setPreparationGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
// execute
- phase.simulate( config, releaseEnvironment, null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
// verify
verify( mock ).executeGoals( eq( testFile ), eq( "clean integration-test" ), isA( ReleaseEnvironment.class ),
@@ -130,9 +131,9 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setPreparationGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setPreparationGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
doThrow( new MavenExecutorException( "...",
@@ -149,7 +150,7 @@
// execute
try
{
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
fail( "Should have thrown an exception" );
}
@@ -172,9 +173,9 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setPreparationGoals( "clean integration-test" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setPreparationGoals( "clean integration-test" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
doThrow( new MavenExecutorException( "...",
@@ -191,7 +192,7 @@
// execute
try
{
- phase.simulate( config, releaseEnvironment, null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, null );
fail( "Should have thrown an exception" );
}
@@ -215,16 +216,16 @@
// prepare
File testFile = getTestFile( "target/working-directory" );
- ReleaseDescriptor config = new ReleaseDescriptor();
- config.setPreparationGoals( "" );
- config.setWorkingDirectory( testFile.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setPreparationGoals( "" );
+ builder.setWorkingDirectory( testFile.getAbsolutePath() );
MavenExecutor mock = mock( MavenExecutor.class );
mavenExecutorWrapper.setMavenExecutor( mock );
// execute
- phase.execute( config, releaseEnvironment, (List<MavenProject>) null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), releaseEnvironment, (List<MavenProject>) null );
// verify
// no invocations of mock
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java
index 748c2a6..9136cb2 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmBranchPhaseTest.java
@@ -52,7 +52,8 @@
import org.apache.maven.scm.repository.ScmRepositoryException;
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -74,7 +75,7 @@
{
super.setUp();
- phase = (ReleasePhase) lookup( ReleasePhase.class, "scm-branch" );
+ phase = lookup( ReleasePhase.class, "scm-branch" );
}
public static String getPath( File file )
@@ -88,13 +89,13 @@
throws Exception
{
// prepare
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
@@ -108,7 +109,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).branch( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -127,13 +128,13 @@
createReactorProjects( dir, dir, null );
String sourceUrl = "http://svn.example.com/repos/project/trunk/";
String scmUrl = "scm:svn:" + sourceUrl;
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( scmUrl );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( scmUrl );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
- descriptor.setScmBranchBase( "http://svn.example.com/repos/project/branches/" );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
+ builder.setScmBranchBase( "http://svn.example.com/repos/project/branches/" );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
@@ -152,7 +153,7 @@
stub.addScmRepositoryForUrl( scmUrl, repository );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).branch( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -169,11 +170,11 @@
List<MavenProject> reactorProjects =
createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( rootProject.getScm().getConnection() );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
// one directory up from root project
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile().getParentFile() );
@@ -193,7 +194,7 @@
stub.addScmRepositoryForUrl( "scm:svn:" + scmUrl, repository );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).branch( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -207,14 +208,14 @@
throws Exception
{
// prepare
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
String dir = "scm-commit/multiple-poms";
List<MavenProject> reactorProjects = createReactorProjects( dir, dir, null );
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
@@ -229,7 +230,7 @@
stub.setScmProvider( scmProviderMock );
// exeucte
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).branch( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -242,12 +243,12 @@
public void testBranchNoReleaseLabel()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
try
{
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have thrown an exception" );
}
catch ( ReleaseFailureException e )
@@ -260,12 +261,12 @@
public void testSimulateBranch()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
ScmProvider scmProviderMock = mock( ScmProvider.class );
@@ -273,7 +274,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
// no scmProvider invocation
@@ -284,12 +285,12 @@
public void testSimulateBranchNoReleaseLabel()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
try
{
- phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have thrown an exception" );
}
catch ( ReleaseFailureException e )
@@ -304,7 +305,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new NoSuchScmProviderException( "..." ) );
@@ -312,7 +313,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -329,7 +330,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new ScmRepositoryException( "..." ) );
@@ -337,7 +338,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -355,7 +356,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmProvider scmProviderMock = mock( ScmProvider.class );
when( scmProviderMock.branch( isA( ScmRepository.class ), isA( ScmFileSet.class ), isA( String.class ),
@@ -367,7 +368,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -387,17 +388,17 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
ScmProviderStub providerStub =
- (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+ (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" );
providerStub.setBranchScmResult( new BranchScmResult( "", "", "", false ) );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Commit should have failed" );
}
@@ -414,13 +415,13 @@
return createReactorProjects( dir, dir, null );
}
- private static ReleaseDescriptor createReleaseDescriptor()
+ private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
throws IOException
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( "scm-url" );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
- return descriptor;
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
+ return builder;
}
}
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java
index e6fad03..bff49da 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCheckModificationsPhaseTest.java
@@ -51,7 +51,8 @@
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleaseResult;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -82,9 +83,9 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new NoSuchScmProviderException( "..." ) );
@@ -92,7 +93,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -103,7 +104,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -119,9 +120,9 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new ScmRepositoryException( "..." ) );
@@ -129,7 +130,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -140,7 +141,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -155,9 +156,9 @@
throws Exception
{
// prepare
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
- releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
ScmProvider scmProviderMock = mock( ScmProvider.class );
when( scmProviderMock.status( isA( ScmRepository.class ),
@@ -169,7 +170,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -180,7 +181,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -198,17 +199,17 @@
public void testScmResultFailure()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
+ ScmManager scmManager = lookup( ScmManager.class );
ScmProviderStub providerStub =
- (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+ (ScmProviderStub) scmManager.getProviderByUrl( "scm:svn:file://localhost/tmp/scm-repo" );
providerStub.setStatusScmResult( new StatusScmResult( "", "", "", false ) );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -219,7 +220,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -233,13 +234,13 @@
public void testNoModifications()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- setChangedFiles( releaseDescriptor, Collections.<String>emptyList() );
+ setChangedFiles( builder, Collections.<String>emptyList() );
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
// successful execution is verification enough
assertTrue( true );
@@ -249,14 +250,14 @@
public void testModificationsToExcludedFilesOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- setChangedFiles( releaseDescriptor,
+ setChangedFiles( builder,
Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", "pom.xml.next" ) );
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
// successful execution is verification enough
assertTrue( true );
@@ -267,32 +268,32 @@
public void testModificationsToCustomExcludedFilesOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "**/keep.me" ) );
+ builder.setCheckModificationExcludes( Collections.singletonList( "**/keep.me" ) );
- setChangedFiles( releaseDescriptor,
+ setChangedFiles( builder,
Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag", "pom.xml.next",
"keep.me", "src/app/keep.me", "config\\keep.me" ) );
assertEquals( ReleaseResult.SUCCESS,
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
assertEquals( ReleaseResult.SUCCESS,
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
}
@Test
public void testModificationsToPoms()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- setChangedFiles( releaseDescriptor, Arrays.asList( "pom.xml", "module/pom.xml" ) );
+ setChangedFiles( builder, Arrays.asList( "pom.xml", "module/pom.xml" ) );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -303,7 +304,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -317,13 +318,13 @@
public void testModificationsToIncludedFilesOnly()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- setChangedFiles( releaseDescriptor, Collections.singletonList( "something.txt" ) );
+ setChangedFiles( builder, Collections.singletonList( "something.txt" ) );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -334,7 +335,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -348,14 +349,14 @@
public void testModificationsToIncludedAndExcludedFiles()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- setChangedFiles( releaseDescriptor, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag",
+ setChangedFiles( builder, Arrays.asList( "release.properties", "pom.xml.backup", "pom.xml.tag",
"pom.xml.release", "something.txt" ) );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -366,7 +367,7 @@
try
{
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null );
fail( "Status check should have failed" );
}
@@ -380,16 +381,16 @@
public void testModificationsToAdditionalExcludedFiles()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
- releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "something.*" ) );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+ builder.setCheckModificationExcludes( Collections.singletonList( "something.*" ) );
- setChangedFiles( releaseDescriptor, Collections.singletonList( "something.txt" ) );
+ setChangedFiles( builder, Collections.singletonList( "something.txt" ) );
assertEquals( ReleaseResult.SUCCESS,
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
assertEquals( ReleaseResult.SUCCESS,
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
}
// MRELEASE-775
@@ -397,25 +398,25 @@
public void testMultipleExclusionPatternMatch()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- releaseDescriptor.setCheckModificationExcludes( Collections.singletonList( "release.properties" ) );
+ builder.setCheckModificationExcludes( Collections.singletonList( "release.properties" ) );
- setChangedFiles( releaseDescriptor, Arrays.asList( "release.properties" ) );
+ setChangedFiles( builder, Arrays.asList( "release.properties" ) );
assertEquals( ReleaseResult.SUCCESS,
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
assertEquals( ReleaseResult.SUCCESS,
- phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), null ).getResultCode() );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), null ).getResultCode() );
}
- private void setChangedFiles( ReleaseDescriptor releaseDescriptor, List<String> changedFiles )
+ private void setChangedFiles( ReleaseDescriptorBuilder builder, List<String> changedFiles )
throws Exception
{
ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
ScmProviderStub providerStub =
- (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+ (ScmProviderStub) scmManager.getProviderByUrl( "scm:svn:file://localhost/tmp/scm-repo" );
providerStub.setStatusScmResult( new StatusScmResult( "", createScmFiles( changedFiles ) ) );
}
@@ -431,11 +432,11 @@
return files;
}
- private static ReleaseDescriptor createReleaseDescriptor()
+ private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
- releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
- return releaseDescriptor;
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
+ builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+ return builder;
}
}
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java
index fc67417..41c90f3 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitDevelopmentPhaseTest.java
@@ -42,7 +42,8 @@
import org.apache.maven.scm.manager.ScmManagerStub;
import org.apache.maven.scm.provider.ScmProvider;
import org.apache.maven.scm.repository.ScmRepository;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.util.ReleaseUtil;
import org.junit.Test;
@@ -64,7 +65,7 @@
private MavenProject rootProject;
- private ReleaseDescriptor descriptor;
+ private ReleaseDescriptorBuilder builder;
private ScmProvider scmProviderMock;
@@ -78,7 +79,7 @@
reactorProjects = createReactorProjects();
rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor = createReleaseDescriptor( rootProject );
+ builder = createReleaseDescriptorBuilder( rootProject );
}
@Test
@@ -91,16 +92,16 @@
public void testNoCommitOrRollbackRequired()
throws Exception
{
- ReleaseDescriptor descriptor = createReleaseDescriptor( rootProject );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( rootProject );
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setRemoteTagging( false );
- descriptor.setSuppressCommitBeforeTagOrBranch( true );
- descriptor.setUpdateWorkingCopyVersions( false );
+ builder.setRemoteTagging( false );
+ builder.setSuppressCommitBeforeTagOrBranch( true );
+ builder.setUpdateWorkingCopyVersions( false );
prepareNoCheckin();
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
verifyNoCheckin();
}
@@ -109,11 +110,11 @@
public void testCommitsNextVersions()
throws Exception
{
- descriptor.setUpdateWorkingCopyVersions( true );
+ builder.setUpdateWorkingCopyVersions( true );
prepareCheckin( COMMIT_MESSAGE );
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
verifyCheckin( COMMIT_MESSAGE );
}
@@ -122,13 +123,13 @@
public void testCommitsRollbackPrepare()
throws Exception
{
- descriptor.setUpdateWorkingCopyVersions( false );
+ builder.setUpdateWorkingCopyVersions( false );
- String message = ROLLBACK_PREFIX + descriptor.getScmReleaseLabel();
+ String message = ROLLBACK_PREFIX + "release-label";
prepareCheckin( message );
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
verifyCheckin( message );
}
@@ -176,12 +177,12 @@
return createReactorProjects( dir, dir, null );
}
- private static ReleaseDescriptor createReleaseDescriptor( MavenProject rootProject )
+ private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder( MavenProject rootProject )
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( "scm-url" );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
- return descriptor;
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+ return builder;
}
}
\ No newline at end of file
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java
index c1d562e..54c1860 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmCommitPreparationPhaseTest.java
@@ -53,7 +53,8 @@
import org.apache.maven.scm.repository.ScmRepositoryException;
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -99,11 +100,11 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( "scm-url" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
- descriptor.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+ builder.setScmReleaseLabel( "release-label" );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile(), rootProject.getFile() );
@@ -119,7 +120,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -132,13 +133,13 @@
throws Exception
{
// prepare
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
String dir = "scm-commit/multiple-poms";
List<MavenProject> reactorProjects = createReactorProjects( dir, dir, null );
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
- descriptor.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+ builder.setScmReleaseLabel( "release-label" );
List<File> poms = new ArrayList<>();
for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
@@ -159,7 +160,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -174,12 +175,12 @@
// prepare
phase = (ReleasePhase) lookup( ReleasePhase.class, "scm-commit-development" );
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
- descriptor.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+ builder.setScmReleaseLabel( "release-label" );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile(), rootProject.getFile() );
@@ -194,7 +195,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -207,12 +208,12 @@
public void testCommitNoReleaseLabel()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
try
{
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have thrown an exception" );
}
catch ( ReleaseFailureException e )
@@ -227,12 +228,12 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( "scm-url" );
- descriptor.setGenerateReleasePoms( true );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setGenerateReleasePoms( true );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
- descriptor.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+ builder.setScmReleaseLabel( "release-label" );
List<File> files = new ArrayList<>();
files.add( rootProject.getFile() );
@@ -251,7 +252,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).checkIn( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -263,19 +264,19 @@
public void testSimulateCommit()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
- descriptor.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( rootProject.getFile().getParentFile().getAbsolutePath() );
+ builder.setScmReleaseLabel( "release-label" );
ScmProvider scmProviderMock = mock( ScmProvider.class );
ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
stub.setScmProvider( scmProviderMock );
- phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// never invoke scmProviderMock
verifyNoMoreInteractions( scmProviderMock );
@@ -285,12 +286,12 @@
public void testSimulateCommitNoReleaseLabel()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
try
{
- phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have thrown an exception" );
}
catch ( ReleaseFailureException e )
@@ -305,14 +306,14 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new NoSuchScmProviderException( "..." ) );
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -329,7 +330,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new ScmRepositoryException( "..." ) );
@@ -337,7 +338,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -354,7 +355,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmProvider scmProviderMock = mock( ScmProvider.class );
when( scmProviderMock.checkIn( isA( ScmRepository.class ), isA( ScmFileSet.class ), isNull( ScmVersion.class ),
@@ -366,7 +367,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -386,17 +387,17 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
ScmProviderStub providerStub =
- (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+ (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" );
providerStub.setCheckInScmResult( new CheckInScmResult( "", "", "", false ) );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Commit should have failed" );
}
@@ -410,11 +411,11 @@
public void testSuppressCommitWithRemoteTaggingFails()
throws Exception
{
- ReleaseDescriptor descriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setRemoteTagging( true );
- descriptor.setSuppressCommitBeforeTagOrBranch( true );
+ builder.setRemoteTagging( true );
+ builder.setSuppressCommitBeforeTagOrBranch( true );
ScmProvider scmProviderMock = mock( ScmProvider.class );
@@ -423,7 +424,7 @@
try
{
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Commit should have failed with ReleaseFailureException" );
}
@@ -440,19 +441,19 @@
public void testSuppressCommitAfterBranch()
throws Exception
{
- ReleaseDescriptor descriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setBranchCreation( true );
- descriptor.setRemoteTagging( false );
- descriptor.setSuppressCommitBeforeTagOrBranch( true );
+ builder.setBranchCreation( true );
+ builder.setRemoteTagging( false );
+ builder.setSuppressCommitBeforeTagOrBranch( true );
ScmProvider scmProviderMock = mock( ScmProvider.class );
ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.class );
stub.setScmProvider( scmProviderMock );
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// never invoke scmProviderMock
verifyNoMoreInteractions( scmProviderMock );
@@ -465,12 +466,12 @@
return createReactorProjects( dir, dir, null );
}
- private static ReleaseDescriptor createReleaseDescriptor()
+ private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( "scm-url" );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
- return descriptor;
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
+ return builder;
}
}
\ No newline at end of file
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java
index 8f31526..1ac428b 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/phase/ScmTagPhaseTest.java
@@ -52,7 +52,8 @@
import org.apache.maven.scm.repository.ScmRepositoryException;
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
@@ -88,13 +89,13 @@
throws Exception
{
// prepare
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
@@ -108,7 +109,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).tag( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -126,13 +127,13 @@
createReactorProjects( "scm-commit/multimodule-with-deep-subprojects", "" );
String sourceUrl = "http://svn.example.com/repos/project/trunk/";
String scmUrl = "scm:svn:" + sourceUrl;
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( scmUrl );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( scmUrl );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
- descriptor.setScmTagBase( "http://svn.example.com/repos/project/releases/" );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
+ builder.setScmTagBase( "http://svn.example.com/repos/project/releases/" );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
@@ -151,7 +152,7 @@
stub.addScmRepositoryForUrl( scmUrl, repository );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).tag( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -168,11 +169,11 @@
List<MavenProject> reactorProjects =
createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "root-project" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( rootProject.getScm().getConnection() );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
// one directory up from root project
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile().getParentFile() );
@@ -192,7 +193,7 @@
stub.addScmRepositoryForUrl( "scm:svn:" + scmUrl, repository );
// execute
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).tag( eq( repository ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -206,14 +207,14 @@
throws Exception
{
// prepare
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
String dir = "scm-commit/multiple-poms";
List<MavenProject> reactorProjects = createReactorProjects( dir, dir, null );
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setScmCommentPrefix( "[my prefix] " );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setScmCommentPrefix( "[my prefix] " );
ScmFileSet fileSet = new ScmFileSet( rootProject.getFile().getParentFile() );
@@ -228,7 +229,7 @@
stub.setScmProvider( scmProviderMock );
// exeucte
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
verify( scmProviderMock ).tag( isA( ScmRepository.class ), argThat( new IsScmFileSetEquals( fileSet ) ),
@@ -241,12 +242,12 @@
public void testTagNoReleaseLabel()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
try
{
- phase.execute( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have thrown an exception" );
}
catch ( ReleaseFailureException e )
@@ -259,12 +260,12 @@
public void testSimulateTag()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
- descriptor.setScmSourceUrl( "scm-url" );
+ builder.setScmSourceUrl( "scm-url" );
MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
- descriptor.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
- descriptor.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( getPath( rootProject.getFile().getParentFile() ) );
+ builder.setScmReleaseLabel( "release-label" );
ScmProvider scmProviderMock = mock( ScmProvider.class );
@@ -272,7 +273,7 @@
stub.setScmProvider( scmProviderMock );
// execute
- phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
// verify
// no scmProvider invocation
@@ -283,12 +284,12 @@
public void testSimulateTagNoReleaseLabel()
throws Exception
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
List<MavenProject> reactorProjects = createReactorProjects();
try
{
- phase.simulate( descriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Should have thrown an exception" );
}
catch ( ReleaseFailureException e )
@@ -303,7 +304,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new NoSuchScmProviderException( "..." ) );
@@ -311,7 +312,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -328,7 +329,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmManagerStub scmManagerStub = (ScmManagerStub) lookup( ScmManager.class );
scmManagerStub.setException( new ScmRepositoryException( "..." ) );
@@ -336,7 +337,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -353,7 +354,7 @@
{
// prepare
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
ScmProvider scmProviderMock = mock( ScmProvider.class );
when( scmProviderMock.tag( isA( ScmRepository.class ), isA( ScmFileSet.class ), isA( String.class ),
@@ -365,7 +366,7 @@
// execute
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Status check should have failed" );
}
@@ -385,17 +386,17 @@
throws Exception
{
List<MavenProject> reactorProjects = createReactorProjects();
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
+ ScmManager scmManager = lookup( ScmManager.class );
ScmProviderStub providerStub =
- (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
+ (ScmProviderStub) scmManager.getProviderByUrl( "scm-url" );
providerStub.setTagScmResult( new TagScmResult( "", "", "", false ) );
try
{
- phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
+ phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
fail( "Commit should have failed" );
}
@@ -411,13 +412,13 @@
return createReactorProjects( "scm-commit/single-pom", "" );
}
- private static ReleaseDescriptor createReleaseDescriptor()
+ private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
throws IOException
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
- descriptor.setScmSourceUrl( "scm-url" );
- descriptor.setScmReleaseLabel( "release-label" );
- descriptor.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
- return descriptor;
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
+ builder.setScmReleaseLabel( "release-label" );
+ builder.setWorkingDirectory( getPath( getTestFile( "target/test/checkout" ) ) );
+ return builder;
}
}
diff --git a/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java b/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java
index e57c23d..985e6cf 100644
--- a/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java
+++ b/maven-release-manager/src/test/java/org/apache/maven/shared/release/scm/DefaultScmRepositoryConfiguratorTest.java
@@ -27,7 +27,8 @@
import org.apache.maven.scm.repository.ScmRepositoryException;
import org.apache.maven.settings.Server;
import org.apache.maven.settings.Settings;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
+import org.apache.maven.shared.release.config.ReleaseUtils;
import org.codehaus.plexus.PlexusTestCase;
/**
@@ -54,9 +55,9 @@
public void testGetConfiguredRepository()
throws ScmRepositoryException, NoSuchScmProviderException
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+ ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
assertEquals( "check provider", "cvs", repository.getProvider() );
assertEquals( "check username", "anoncvs", repository.getProviderRepository().getUser() );
@@ -66,9 +67,9 @@
public void testGetConfiguredRepositoryWithUsernameAndPassword()
throws ScmRepositoryException, NoSuchScmProviderException
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor( "username", "password" );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( "username", "password" );
- ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+ ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
assertEquals( "check username", "username", repository.getProviderRepository().getUser() );
assertEquals( "check password", "password", repository.getProviderRepository().getPassword() );
@@ -77,11 +78,11 @@
public void testGetConfiguredRepositoryWithTagBase()
throws ScmRepositoryException, NoSuchScmProviderException
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm:svn:http://localhost/home/svn/module/trunk" );
- releaseDescriptor.setScmTagBase( "http://localhost/home/svn/module/tags" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:http://localhost/home/svn/module/trunk" );
+ builder.setScmTagBase( "http://localhost/home/svn/module/tags" );
- ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+ ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
SvnScmProviderRepository providerRepository = (SvnScmProviderRepository) repository.getProviderRepository();
assertEquals( "check tag base", "http://localhost/home/svn/module/tags", providerRepository.getTagBase() );
@@ -99,10 +100,10 @@
server.setPassphrase( "settings-passphrase" );
settings.addServer( server );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
- ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings );
+ ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), settings );
ScmProviderRepositoryWithHost providerRepository =
(ScmProviderRepositoryWithHost) repository.getProviderRepository();
@@ -125,10 +126,10 @@
server.setPassphrase( "{7zK9P8hNVeUHbTsjiA/vnOs0zUXbND+9MBNPvdvl+x4=}" );
settings.addServer( server );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm:svn:svn://localhost/repo" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:svn:svn://localhost/repo" );
- ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, settings );
+ ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), settings );
ScmProviderRepositoryWithHost providerRepository =
(ScmProviderRepositoryWithHost) repository.getProviderRepository();
@@ -141,12 +142,12 @@
public void testGetConfiguredRepositoryInvalidScmUrl()
throws Exception
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm-url" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm-url" );
try
{
- scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+ scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
fail( "Expected failure to get a repository with an invalid SCM URL" );
}
@@ -159,12 +160,12 @@
public void testGetConfiguredRepositoryInvalidScmProvider()
throws ScmRepositoryException
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm:url:" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:url:" );
try
{
- scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+ scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
fail( "Expected failure to get a repository with an invalid SCM URL" );
}
@@ -177,12 +178,12 @@
public void testGetConfiguredRepositoryInvalidScmUrlParameters()
throws NoSuchScmProviderException
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm:cvs:" );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:cvs:" );
try
{
- scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+ scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
fail( "Expected failure to get a repository with an invalid SCM URL" );
}
@@ -195,26 +196,26 @@
public void testGetRepositoryProvider()
throws ScmRepositoryException, NoSuchScmProviderException
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
- ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( releaseDescriptor, null );
+ ScmRepository repository = scmRepositoryConfigurator.getConfiguredRepository( ReleaseUtils.buildReleaseDescriptor( builder ), null );
ScmProvider provider = scmRepositoryConfigurator.getRepositoryProvider( repository );
assertEquals( "Check SCM provider", "cvs", provider.getScmType() );
}
- private static ReleaseDescriptor createReleaseDescriptor()
+ private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder()
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
- return releaseDescriptor;
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setScmSourceUrl( "scm:cvs:pserver:anoncvs@localhost:/home/cvs:module" );
+ return builder;
}
- private static ReleaseDescriptor createReleaseDescriptor( String username, String password )
+ private static ReleaseDescriptorBuilder createReleaseDescriptorBuilder( String username, String password )
{
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
- releaseDescriptor.setScmUsername( username );
- releaseDescriptor.setScmPassword( password );
- return releaseDescriptor;
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder();
+ builder.setScmUsername( username );
+ builder.setScmPassword( password );
+ return builder;
}
}
diff --git a/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml b/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml
index 95ed5b8..ff02627 100644
--- a/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml
+++ b/maven-release-manager/src/test/resources/projects/rewrite-for-development/basic-pom-inherited-scm/pom.xml
@@ -37,9 +37,4 @@
<module>subproject1</module>
</modules>
- <scm>
- <connection>scm:svn:file://localhost/tmp/scm-repo/tags/release-label</connection>
- <developerConnection>scm:svn:file://localhost/tmp/scm-repo/tags/release-label</developerConnection>
- <url>file://localhost/tmp/scm-repo/tags/release-label</url>
- </scm>
</project>
\ No newline at end of file
diff --git a/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy b/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy
index bc7b56b..a41f9c3 100644
--- a/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy
+++ b/maven-release-plugin/src/it/projects/prepare/MRELEASE-420/verify.groovy
@@ -22,4 +22,3 @@
assert releaseProperties.exists()
assert 1 == releaseProperties.getText().count("scm.id=it-server")
-assert 1 == releaseProperties.getText().count("project.scm.org.apache.maven.plugin.release.its\\:mrelease-420.id=it-server")
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java
index f6242ed..7dda662 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractReleaseMojo.java
@@ -23,6 +23,7 @@
import java.util.Iterator;
import java.util.List;
+import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugins.annotations.Component;
@@ -30,7 +31,7 @@
import org.apache.maven.project.MavenProject;
import org.apache.maven.settings.Settings;
import org.apache.maven.shared.release.ReleaseManager;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
import org.codehaus.plexus.util.StringUtils;
@@ -149,16 +150,22 @@
*
* @return The release descriptor, never <code>null</code>.
*/
- protected ReleaseDescriptor createReleaseDescriptor()
+ protected ReleaseDescriptorBuilder createReleaseDescriptor()
{
- ReleaseDescriptor descriptor = new ReleaseDescriptor();
-
+ ReleaseDescriptorBuilder descriptor = new ReleaseDescriptorBuilder();
+
descriptor.setInteractive( settings.isInteractiveMode() );
descriptor.setWorkingDirectory( basedir.getAbsolutePath() );
descriptor.setPomFileName( pomFileName );
+ for ( MavenProject project : reactorProjects )
+ {
+ String versionlessKey = ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() );
+ descriptor.putOriginalVersion( versionlessKey, project.getVersion() );
+ }
+
List<String> profileIds = session.getRequest().getActiveProfiles();
String additionalProfiles = getAdditionalProfiles();
@@ -270,25 +277,4 @@
arguments = argument;
}
}
-
- /**
- * This method takes some of the release configuration picked up from the command line system properties and copies
- * it into the release config object.
- *
- * @param config The release configuration to merge the system properties into, must not be <code>null</code>.
- * @param sysPropertiesConfig The configuration from the system properties to merge in, must not be
- * <code>null</code>.
- */
- protected void mergeCommandLineConfig( ReleaseDescriptor config, ReleaseDescriptor sysPropertiesConfig )
- {
- // If the user specifies versions, these should override the existing versions
- if ( sysPropertiesConfig.getReleaseVersions() != null )
- {
- config.getReleaseVersions().putAll( sysPropertiesConfig.getReleaseVersions() );
- }
- if ( sysPropertiesConfig.getDevelopmentVersions() != null )
- {
- config.getDevelopmentVersions().putAll( sysPropertiesConfig.getDevelopmentVersions() );
- }
- }
}
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java
index b57aab4..d75064e 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/AbstractScmReleaseMojo.java
@@ -21,12 +21,15 @@
import java.util.Map;
+import org.apache.maven.artifact.ArtifactUtils;
+import org.apache.maven.model.Scm;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.Component;
import org.apache.maven.plugins.annotations.Parameter;
+import org.apache.maven.project.MavenProject;
import org.apache.maven.scm.manager.ScmManager;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
/**
* Abstract Mojo containing SCM parameters
@@ -127,9 +130,9 @@
}
@Override
- protected ReleaseDescriptor createReleaseDescriptor()
+ protected ReleaseDescriptorBuilder createReleaseDescriptor()
{
- ReleaseDescriptor descriptor = super.createReleaseDescriptor();
+ ReleaseDescriptorBuilder descriptor = super.createReleaseDescriptor();
descriptor.setScmPassword( password );
descriptor.setScmReleaseLabel( tag );
@@ -139,7 +142,51 @@
descriptor.setScmCommentPrefix( scmCommentPrefix );
descriptor.setPushChanges( pushChanges );
+
+ if ( project.getScm() != null )
+ {
+ if ( project.getScm().getDeveloperConnection() != null )
+ {
+ descriptor.setScmSourceUrl( project.getScm().getDeveloperConnection() );
+ }
+ else if ( project.getScm().getConnection() != null )
+ {
+ descriptor.setScmSourceUrl( project.getScm().getConnection() );
+ }
+ }
+
+ // As long as Scm.getId() does not exist, read it as a property
+ descriptor.setScmId( project.getProperties().getProperty( "project.scm.id" ) );
+
+ for ( MavenProject reactorProject : session.getProjects() )
+ {
+ if ( reactorProject.getScm() != null )
+ {
+ String projectId =
+ ArtifactUtils.versionlessKey( reactorProject.getGroupId(), reactorProject.getArtifactId() );
+
+ descriptor.addOriginalScmInfo( projectId, buildScm( project ) );
+ }
+ }
return descriptor;
}
+
+ protected Scm buildScm( MavenProject project )
+ {
+ Scm scm;
+ if ( project.getOriginalModel().getScm() == null )
+ {
+ scm = null;
+ }
+ else
+ {
+ scm = new Scm();
+ scm.setConnection( project.getOriginalModel().getScm().getConnection() );
+ scm.setDeveloperConnection( project.getOriginalModel().getScm().getDeveloperConnection() );
+ scm.setTag( project.getOriginalModel().getScm().getTag() );
+ scm.setUrl( project.getOriginalModel().getScm().getUrl() );
+ }
+ return scm;
+ }
}
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java
index 14829ea..4378d24 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/BranchReleaseMojo.java
@@ -28,8 +28,7 @@
import org.apache.maven.shared.release.ReleaseBranchRequest;
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
-import org.apache.maven.shared.release.config.ReleaseUtils;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
/**
* Branch a project in SCM, using the same steps as the <tt>release:prepare</tt> goal, creating a branch instead of a
@@ -217,7 +216,7 @@
{
super.execute();
- ReleaseDescriptor config = createReleaseDescriptor();
+ final ReleaseDescriptorBuilder config = createReleaseDescriptor();
config.setAddSchema( addSchema );
config.setScmUseEditMode( useEditMode );
config.setUpdateDependencies( updateDependencies );
@@ -235,11 +234,6 @@
config.setProjectVersionPolicyId( projectVersionPolicyId );
config.setProjectNamingPolicyId( projectBranchNamingPolicyId );
- // Create a config containing values from the session properties (ie command line properties with cli).
- ReleaseDescriptor sysPropertiesConfig
- = ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() );
- mergeCommandLineConfig( config, sysPropertiesConfig );
-
if ( checkModificationExcludeList != null )
{
checkModificationExcludes = checkModificationExcludeList.replaceAll( "\\s", "" ).split( "," );
@@ -253,10 +247,11 @@
try
{
ReleaseBranchRequest branchRequest = new ReleaseBranchRequest();
- branchRequest.setReleaseDescriptor( config );
+ branchRequest.setReleaseDescriptorBuilder( config );
branchRequest.setReleaseEnvironment( getReleaseEnvironment() );
branchRequest.setReactorProjects( getReactorProjects() );
branchRequest.setDryRun( dryRun );
+ branchRequest.setUserProperties( session.getUserProperties() );
releaseManager.branch( branchRequest );
}
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java
index 186785b..3de5857 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/CleanReleaseMojo.java
@@ -24,7 +24,7 @@
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.shared.release.ReleaseCleanRequest;
import org.apache.maven.shared.release.ReleaseFailureException;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
/**
* Clean up after a release preparation. This is done automatically after a successful <tt>release:perform</tt>,
@@ -44,11 +44,11 @@
public void execute()
throws MojoExecutionException, MojoFailureException
{
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
+ ReleaseDescriptorBuilder releaseDescriptor = new ReleaseDescriptorBuilder();
releaseDescriptor.setWorkingDirectory( getBasedir().getAbsolutePath() );
ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
- cleanRequest.setReleaseDescriptor( releaseDescriptor );
+ cleanRequest.setReleaseDescriptorBuilder( releaseDescriptor );
cleanRequest.setReactorProjects( getReactorProjects() );
try
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java
index 4826f78..9abd94f 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PerformReleaseMojo.java
@@ -31,7 +31,7 @@
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleasePerformRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
import org.codehaus.plexus.util.StringUtils;
/**
@@ -166,7 +166,7 @@
{
setDeploymentRepository();
// Note that the working directory here is not the same as in the release configuration, so don't reuse that
- ReleaseDescriptor releaseDescriptor = createReleaseDescriptor();
+ ReleaseDescriptorBuilder releaseDescriptor = createReleaseDescriptor();
if ( connectionUrl != null )
{
releaseDescriptor.setScmSourceUrl( connectionUrl );
@@ -191,7 +191,7 @@
releaseDescriptor.setPerformGoals( goals );
ReleasePerformRequest performRequest = new ReleasePerformRequest();
- performRequest.setReleaseDescriptor( releaseDescriptor );
+ performRequest.setReleaseDescriptorBuilder( releaseDescriptor );
performRequest.setReleaseEnvironment( getReleaseEnvironment() );
performRequest.setReactorProjects( getReactorProjects() );
performRequest.setDryRun( dryRun );
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java
index a73962d..196f727 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/PrepareReleaseMojo.java
@@ -28,8 +28,7 @@
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleasePrepareRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
-import org.apache.maven.shared.release.config.ReleaseUtils;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
/**
* Prepare for a release in SCM. Steps through several phases to ensure the POM is ready to be released and then
@@ -259,7 +258,7 @@
// above
super.execute();
- ReleaseDescriptor config = createReleaseDescriptor();
+ final ReleaseDescriptorBuilder config = createReleaseDescriptor();
config.setAddSchema( addSchema );
config.setGenerateReleasePoms( generateReleasePoms );
config.setScmUseEditMode( useEditMode );
@@ -288,18 +287,14 @@
{
config.setCheckModificationExcludes( Arrays.asList( checkModificationExcludes ) );
}
-
- // Create a config containing values from the session properties (ie command line properties with cli).
- ReleaseDescriptor sysPropertiesConfig =
- ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() );
- mergeCommandLineConfig( config, sysPropertiesConfig );
ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
- prepareRequest.setReleaseDescriptor( config );
+ prepareRequest.setReleaseDescriptorBuilder( config );
prepareRequest.setReleaseEnvironment( getReleaseEnvironment() );
prepareRequest.setReactorProjects( getReactorProjects() );
prepareRequest.setResume( resume );
prepareRequest.setDryRun( dryRun );
+ prepareRequest.setUserProperties( session.getUserProperties() );
try
{
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java
index cefcbbe..970dad6 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/RollbackReleaseMojo.java
@@ -49,7 +49,7 @@
try
{
ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest();
- rollbackRequest.setReleaseDescriptor( createReleaseDescriptor() );
+ rollbackRequest.setReleaseDescriptorBuilder( createReleaseDescriptor() );
rollbackRequest.setReleaseEnvironment( getReleaseEnvironment() );
rollbackRequest.setReactorProjects( getReactorProjects() );
diff --git a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java
index 242ed2b..2aa1e8e 100644
--- a/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java
+++ b/maven-release-plugin/src/main/java/org/apache/maven/plugins/release/UpdateVersionsMojo.java
@@ -27,8 +27,7 @@
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleaseUpdateVersionsRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
-import org.apache.maven.shared.release.config.ReleaseUtils;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
/**
* Update the POM versions for a project. This performs the normal version updates of the <tt>release:prepare</tt> goal
@@ -98,7 +97,7 @@
public void execute()
throws MojoExecutionException, MojoFailureException
{
- ReleaseDescriptor config = createReleaseDescriptor();
+ final ReleaseDescriptorBuilder config = createReleaseDescriptor();
config.setAddSchema( addSchema );
config.setAutoVersionSubmodules( autoVersionSubmodules );
config.setDefaultDevelopmentVersion( developmentVersion );
@@ -109,17 +108,13 @@
config.addOriginalScmInfo( ArtifactUtils.versionlessKey( project.getGroupId(), project.getArtifactId() ),
project.getScm() );
- // Create a config containing values from the session properties (ie command line properties with cli).
- ReleaseDescriptor sysPropertiesConfig =
- ReleaseUtils.copyPropertiesToReleaseDescriptor( session.getExecutionProperties() );
- mergeCommandLineConfig( config, sysPropertiesConfig );
-
try
{
ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest();
- updateVersionsRequest.setReleaseDescriptor( config );
+ updateVersionsRequest.setReleaseDescriptorBuilder( config );
updateVersionsRequest.setReleaseEnvironment( getReleaseEnvironment() );
updateVersionsRequest.setReactorProjects( getReactorProjects() );
+ updateVersionsRequest.setUserProperties( session.getUserProperties() );
releaseManager.updateVersions( updateVersionsRequest );
}
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java
index 2a972c3..d80848a 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/CleanReleaseMojoTest.java
@@ -68,8 +68,6 @@
// verify
verify( mock ).clean( request.capture() );
- assertEquals( workingDirectory.getAbsolutePath(),
- request.getValue().getReleaseDescriptor().getWorkingDirectory() );
assertEquals( mojo.getReactorProjects(), request.getValue().getReactorProjects() );
verifyNoMoreInteractions( mock );
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java
index 09b5a52..16fc026 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PerformReleaseMojoTest.java
@@ -27,6 +27,7 @@
import java.io.File;
import java.util.Arrays;
+import java.util.List;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.DistributionManagement;
@@ -40,7 +41,7 @@
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleaseManager;
import org.apache.maven.shared.release.ReleasePerformRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
import org.mockito.ArgumentCaptor;
/**
@@ -58,11 +59,11 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site-deploy" );
ReleaseManager mock = mock( ReleaseManager.class );
mojo.setReleaseManager( mock );
@@ -73,9 +74,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
}
@@ -85,12 +86,12 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-flat-structure.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy" );
- releaseDescriptor.setScmSourceUrl( "scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy" );
+ builder.setScmSourceUrl( "scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project" );
ReleaseManager mock = mock( ReleaseManager.class );
mojo.setReleaseManager( mock );
@@ -101,9 +102,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
}
@@ -120,11 +121,11 @@
MavenProject project = (MavenProject) getVariableValueFromObject( mojo, "project" );
setVariableValueToObject( mojo, "session", newMavenSession( project ) );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy" );
ReleaseManager mock = mock( ReleaseManager.class );
mojo.setReleaseManager( mock );
@@ -135,9 +136,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
}
@@ -163,11 +164,11 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site-deploy" );
ReleaseManager mock = mock( ReleaseManager.class );
doThrow( new ReleaseExecutionException( "..." ) ).when( mock ).perform( isA( ReleasePerformRequest.class ) );
@@ -188,9 +189,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
@@ -201,11 +202,11 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site-deploy" );
ReleaseManager mock = mock( ReleaseManager.class );
ReleaseFailureException cause = new ReleaseFailureException( "..." );
@@ -228,9 +229,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
@@ -241,12 +242,12 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-scm.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site-deploy" );
- releaseDescriptor.setScmSourceUrl( "scm-url" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site-deploy" );
+ builder.setScmSourceUrl( "scm-url" );
ReleaseManager mock = mock( ReleaseManager.class );
mojo.setReleaseManager( mock );
@@ -257,9 +258,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
@@ -270,12 +271,12 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site-deploy" );
- releaseDescriptor.setAdditionalArguments( "-P prof1,2prof" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site-deploy" );
+ builder.setAdditionalArguments( "-P prof1,2prof" );
MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session");
Profile profile1 = new Profile();
@@ -295,9 +296,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
@@ -308,12 +309,12 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-args.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site-deploy" );
- releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true -P prof1,2prof" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site-deploy" );
+ builder.setAdditionalArguments( "-Dmaven.test.skip=true -P prof1,2prof" );
MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session");
Profile profile1 = new Profile();
@@ -333,9 +334,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
@@ -346,11 +347,11 @@
{
PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-multiline-goals.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site-deploy" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site-deploy" );
ReleaseManager mock = mock( ReleaseManager.class );
mojo.setReleaseManager( mock );
@@ -361,14 +362,28 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
}
+ private ReleaseDescriptorBuilder createReleaseDescriptorBuilder( PerformReleaseMojo mojo ) throws Exception
+ {
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+
+ @SuppressWarnings( "unchecked" )
+ List<MavenProject> reactorProjects = (List<MavenProject>) getVariableValueFromObject( mojo, "reactorProjects" );
+
+ for ( MavenProject project : reactorProjects )
+ {
+ builder.putOriginalVersion( project.getGroupId() + ':' + project.getArtifactId(), project.getVersion() );
+ }
+
+ return builder;
+ }
protected void setUp()
throws Exception
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java
index deca8a5..876044b 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/PrepareReleaseMojoTest.java
@@ -22,7 +22,7 @@
import static org.hamcrest.CoreMatchers.instanceOf;
import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.CoreMatchers.notNullValue;
import static org.junit.Assert.assertThat;
import static org.mockito.Matchers.isA;
@@ -32,17 +32,20 @@
import static org.mockito.Mockito.verifyNoMoreInteractions;
import java.io.File;
+import java.util.Collections;
+import java.util.List;
import java.util.Properties;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugin.testing.AbstractMojoTestCase;
+import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleaseManager;
import org.apache.maven.shared.release.ReleasePrepareRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
import org.mockito.ArgumentCaptor;
@@ -64,19 +67,26 @@
throws Exception
{
File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" );
- PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
+ final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
setDefaults( mojo );
mojo.setBasedir( testFile.getParentFile() );
mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null )
{
- public Properties getExecutionProperties(){
- return new Properties();
- };
+ public Properties getExecutionProperties()
+ {
+ return new Properties();
+ };
+
+ @Override
+ public List<MavenProject> getProjects()
+ {
+ return Collections.singletonList( mojo.project );
+ }
};
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
- releaseDescriptor.setUpdateDependencies( false );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
+ builder.setUpdateDependencies( false );
ReleaseManager mock = mock( ReleaseManager.class );
mojo.setReleaseManager( mock );
@@ -89,9 +99,10 @@
// verify
verify( mock ).prepare( prepareRequest.capture() );
- assertThat( prepareRequest.getValue().getReleaseDescriptor(), is( releaseDescriptor ) );
- assertThat( prepareRequest.getValue().getReleaseEnvironment(), is(instanceOf( ReleaseEnvironment.class ) ) );
- assertThat( prepareRequest.getValue().getReactorProjects(), is( nullValue() ) );
+ assertThat( prepareRequest.getValue().getReleaseDescriptorBuilder(),
+ is( instanceOf( ReleaseDescriptorBuilder.class ) ) );
+ assertThat( prepareRequest.getValue().getReleaseEnvironment(), is( instanceOf( ReleaseEnvironment.class ) ) );
+ assertThat( prepareRequest.getValue().getReactorProjects(), is( notNullValue() ) );
assertThat( prepareRequest.getValue().getResume(), is( true ) );
assertThat( prepareRequest.getValue().getDryRun(), is( false ) );
}
@@ -100,7 +111,7 @@
throws Exception
{
File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" );
- PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
+ final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
setDefaults( mojo );
mojo.setBasedir( testFile.getParentFile() );
mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null )
@@ -108,11 +119,14 @@
public Properties getExecutionProperties(){
return new Properties();
};
+
+ @Override
+ public List<MavenProject> getProjects()
+ {
+ return Collections.singletonList( mojo.project );
+ }
};
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
- releaseDescriptor.setUpdateDependencies( false );
-
+
ReleaseManager mock = mock( ReleaseManager.class );
doThrow( new ReleaseExecutionException( "..." ) ).when( mock ).prepare( isA( ReleasePrepareRequest.class ) );
mojo.setReleaseManager( mock );
@@ -138,7 +152,7 @@
throws Exception
{
File testFile = getTestFile( "target/test-classes/mojos/prepare/prepare.xml" );
- PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
+ final PrepareReleaseMojo mojo = (PrepareReleaseMojo) lookupMojo( "prepare", testFile );
setDefaults( mojo );
mojo.setBasedir( testFile.getParentFile() );
mojo.session = new MavenSession( null, null, null, null, null, null, null, null, null )
@@ -146,10 +160,13 @@
public Properties getExecutionProperties(){
return new Properties();
};
+
+ @Override
+ public List<MavenProject> getProjects()
+ {
+ return Collections.singletonList( mojo.project );
+ }
};
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( testFile.getParentFile().getAbsolutePath() );
- releaseDescriptor.setUpdateDependencies( false );
ReleaseManager mock = mock( ReleaseManager.class );
ReleaseFailureException cause = new ReleaseFailureException( "..." );
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java
index 092d77e..b88eb24 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/StageReleaseMojoTest.java
@@ -31,7 +31,7 @@
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.release.ReleaseManager;
import org.apache.maven.shared.release.ReleasePerformRequest;
-import org.apache.maven.shared.release.config.ReleaseDescriptor;
+import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
import org.mockito.ArgumentCaptor;
/**
@@ -49,15 +49,15 @@
{
StageReleaseMojo mojo = getMojoWithProjectSite( "stage.xml" );
- ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
- releaseDescriptor.setWorkingDirectory( workingDirectory.getAbsolutePath() );
+ ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
+ builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
File checkoutDirectory = getTestFile( "target/checkout" );
- releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
- releaseDescriptor.setPerformGoals( "deploy site:stage-deploy" );
- releaseDescriptor.setAdditionalArguments( "-DaltDeploymentRepository=\"staging\"" );
+ builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
+ builder.setPerformGoals( "deploy site:stage-deploy" );
+ builder.setAdditionalArguments( "-DaltDeploymentRepository=\"staging\"" );
ReleasePerformRequest performRequest = new ReleasePerformRequest();
- performRequest.setReleaseDescriptor( releaseDescriptor );
+ performRequest.setReleaseDescriptorBuilder( builder );
performRequest.setReleaseEnvironment( mojo.getReleaseEnvironment() );
performRequest.setReactorProjects( mojo.getReactorProjects() );
performRequest.setDryRun( false );
@@ -70,9 +70,9 @@
// verify
ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
verify( mock ).perform( argument.capture() );
- assertEquals( releaseDescriptor, argument.getValue().getReleaseDescriptor() );
+ assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
assertNotNull( argument.getValue().getReleaseEnvironment() );
- assertNull( argument.getValue().getReactorProjects() );
+ assertNotNull( argument.getValue().getReactorProjects() );
assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
verifyNoMoreInteractions( mock );
}
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java
index 99ee9e2..7617d41 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/FlatMultiModuleMavenProjectStub.java
@@ -82,5 +82,22 @@
return scm;
}
-
+
+ @Override
+ public String getGroupId()
+ {
+ return "GROUPID";
+ }
+
+ @Override
+ public String getArtifactId()
+ {
+ return "ARTIFACTID";
+ }
+
+ @Override
+ public String getVersion()
+ {
+ return "VERSION";
+ }
}
diff --git a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java
index 44f654f..63eefa4 100644
--- a/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java
+++ b/maven-release-plugin/src/test/java/org/apache/maven/plugins/release/stubs/MavenProjectStub.java
@@ -54,4 +54,22 @@
{
return getModel().getDistributionManagement();
}
+
+ @Override
+ public String getGroupId()
+ {
+ return "GROUPID";
+ }
+
+ @Override
+ public String getArtifactId()
+ {
+ return "ARTIFACTID";
+ }
+
+ @Override
+ public String getVersion()
+ {
+ return "VERSION";
+ }
}
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml
index 1ea3faa..14af0dc 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-args.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ </reactorProjects>
<workingDirectory>${basedir}/target/checkout</workingDirectory>
<useReleaseProfile>true</useReleaseProfile>
<goals>deploy site-deploy</goals>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml
index 074acfe..32e25fc 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-flat-structure.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugins.release.stubs.FlatMultiModuleMavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.FlatMultiModuleMavenProjectStub"/>
+ </reactorProjects>
<workingDirectory>${basedir}/target/checkout</workingDirectory>
<useReleaseProfile>true</useReleaseProfile>
<connectionUrl>scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project</connectionUrl>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml
index ad13c48..f544639 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-multiline-goals.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ </reactorProjects>
<workingDirectory>${basedir}/target/checkout</workingDirectory>
<useReleaseProfile>true</useReleaseProfile>
<goals>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml
index 02849c9..cb8a866 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-with-scm.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ </reactorProjects>
<workingDirectory>${basedir}/target/checkout</workingDirectory>
<useReleaseProfile>true</useReleaseProfile>
<connectionUrl>scm-url</connectionUrl>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml
index c4d826a..be9fcbb 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform-without-site.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ </reactorProjects>
<workingDirectory>${basedir}/target/checkout</workingDirectory>
<goals>deploy</goals>
<useReleaseProfile>true</useReleaseProfile>
diff --git a/maven-release-plugin/src/test/resources/mojos/perform/perform.xml b/maven-release-plugin/src/test/resources/mojos/perform/perform.xml
index 87b529f..0580f00 100644
--- a/maven-release-plugin/src/test/resources/mojos/perform/perform.xml
+++ b/maven-release-plugin/src/test/resources/mojos/perform/perform.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ </reactorProjects>
<workingDirectory>${basedir}/target/checkout</workingDirectory>
<goals>deploy site-deploy</goals>
<useReleaseProfile>true</useReleaseProfile>
diff --git a/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml b/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml
index bec7b49..623ff2b 100644
--- a/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml
+++ b/maven-release-plugin/src/test/resources/mojos/prepare/prepare.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugin.testing.stubs.MavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ </reactorProjects>
<resume>true</resume>
</configuration>
</plugin>
diff --git a/maven-release-plugin/src/test/resources/mojos/stage/stage.xml b/maven-release-plugin/src/test/resources/mojos/stage/stage.xml
index a8f5ea0..d1ac583 100644
--- a/maven-release-plugin/src/test/resources/mojos/stage/stage.xml
+++ b/maven-release-plugin/src/test/resources/mojos/stage/stage.xml
@@ -26,6 +26,9 @@
<configuration>
<settings implementation="org.apache.maven.settings.Settings"/>
<project implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ <reactorProjects>
+ <reactorProject implementation="org.apache.maven.plugins.release.stubs.MavenProjectStub"/>
+ </reactorProjects>
<workingDirectory>${basedir}/target/checkout</workingDirectory>
<stagingRepository>staging</stagingRepository>
<goals>deploy site-deploy</goals>
