View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.maven.shared.release.phase;
20  
21  import java.io.File;
22  import java.util.ArrayList;
23  import java.util.Arrays;
24  import java.util.Collections;
25  import java.util.List;
26  import java.util.Map;
27  
28  import org.apache.maven.model.Model;
29  import org.apache.maven.project.MavenProject;
30  import org.apache.maven.shared.release.PlexusJUnit4TestCase;
31  import org.apache.maven.shared.release.ReleaseExecutionException;
32  import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
33  import org.apache.maven.shared.release.config.ReleaseUtils;
34  import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
35  import org.apache.maven.shared.release.policy.PolicyException;
36  import org.apache.maven.shared.release.policy.version.VersionPolicy;
37  import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
38  import org.apache.maven.shared.release.versions.VersionParseException;
39  import org.codehaus.plexus.components.interactivity.Prompter;
40  import org.codehaus.plexus.components.interactivity.PrompterException;
41  import org.hamcrest.CoreMatchers;
42  import org.junit.Test;
43  import org.mockito.Mock;
44  import org.mockito.MockitoAnnotations;
45  
46  import static org.hamcrest.MatcherAssert.assertThat;
47  import static org.junit.Assert.assertEquals;
48  import static org.junit.Assert.assertNull;
49  import static org.junit.Assert.assertThrows;
50  import static org.junit.Assert.fail;
51  import static org.mockito.ArgumentMatchers.eq;
52  import static org.mockito.ArgumentMatchers.isA;
53  import static org.mockito.ArgumentMatchers.startsWith;
54  import static org.mockito.Mockito.times;
55  import static org.mockito.Mockito.verify;
56  import static org.mockito.Mockito.verifyNoMoreInteractions;
57  import static org.mockito.Mockito.when;
58  
59  /**
60   * Test the version mapping phase.
61   *
62   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
63   */
64  public class MapVersionsPhaseTest extends PlexusJUnit4TestCase {
65      @Mock
66      private ScmRepositoryConfigurator scmRepositoryConfigurator;
67  
68      @Mock
69      private Prompter mockPrompter;
70  
71      private Map<String, VersionPolicy> versionPolicies;
72  
73      @Override
74      public void setUp() throws Exception {
75          super.setUp();
76          MockitoAnnotations.initMocks(this);
77          versionPolicies = lookupMap(VersionPolicy.class);
78      }
79  
80      @Override
81      public void tearDown() throws Exception {
82          super.tearDown();
83          verifyNoMoreInteractions(mockPrompter);
84      }
85  
86      @Test
87      public void testExecuteSnapshotMapRelease() throws Exception {
88          // prepare
89          MavenProject project = createProject("artifactId", "1.0-SNAPSHOT");
90          when(mockPrompter.prompt(
91                          startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0")))
92                  .thenReturn("2.0");
93          MapReleaseVersionsPhase phase =
94                  new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
95  
96          List<MavenProject> reactorProjects = Collections.singletonList(project);
97  
98          ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
99  
100         // execute
101         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
102 
103         // verify
104         assertEquals(
105                 "Check mapped versions",
106                 "2.0",
107                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
108 
109         verify(mockPrompter)
110                 .prompt(startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0"));
111     }
112 
113     @Test
114     public void testSimulateSnapshotMapReleaseVersions() throws Exception {
115         // prepare
116         MavenProject project = createProject("artifactId", "1.0-SNAPSHOT");
117         when(mockPrompter.prompt(
118                         startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0")))
119                 .thenReturn("2.0");
120         MapReleaseVersionsPhase phase =
121                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
122 
123         List<MavenProject> reactorProjects = Collections.singletonList(project);
124 
125         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
126 
127         // execute
128         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
129 
130         // verify
131         assertEquals(
132                 "Check mapped versions",
133                 "2.0",
134                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
135         verify(mockPrompter)
136                 .prompt(startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0"));
137     }
138 
139     // MRELEASE-403: Release plugin ignores given version number
140     @Test
141     public void testMapReleaseVersionsInteractiveAddZeroIncremental() throws Exception {
142         // prepare
143         MavenProject project = createProject("artifactId", "1.0-SNAPSHOT");
144         when(mockPrompter.prompt(
145                         startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0")))
146                 .thenReturn("1.0.0");
147         MapReleaseVersionsPhase phase =
148                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
149 
150         List<MavenProject> reactorProjects = Collections.singletonList(project);
151 
152         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
153 
154         // execute
155         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
156 
157         // verify
158         assertEquals(
159                 "Check mapped versions",
160                 "1.0.0",
161                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
162 
163         // prepare
164         builder = new ReleaseDescriptorBuilder();
165 
166         // execute
167         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
168 
169         // verify
170         assertEquals(
171                 "Check mapped versions",
172                 "1.0.0",
173                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
174         verify(mockPrompter, times(2))
175                 .prompt(startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0"));
176     }
177 
178     /**
179      * Test to release "SNAPSHOT" version MRELEASE-90
180      */
181     @Test
182     public void testMapReleaseVersionsInteractiveWithSnaphotVersion() throws Exception {
183         // prepare
184         MavenProject project = createProject("artifactId", "SNAPSHOT");
185         when(mockPrompter.prompt(
186                         startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0")))
187                 .thenReturn("2.0");
188         MapReleaseVersionsPhase phase =
189                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
190 
191         List<MavenProject> reactorProjects = Collections.singletonList(project);
192 
193         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
194 
195         // execute
196         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
197 
198         // verify
199         assertEquals(
200                 "Check mapped versions",
201                 "2.0",
202                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
203 
204         // prepare
205         builder = new ReleaseDescriptorBuilder();
206 
207         // execute
208         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
209 
210         // verify
211         assertEquals(
212                 "Check mapped versions",
213                 "2.0",
214                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
215 
216         verify(mockPrompter, times(2))
217                 .prompt(startsWith("What is the release version for \"" + project.getName() + "\"?"), eq("1.0"));
218     }
219 
220     /**
221      * MRELEASE-524: ignores commandline versions in batch mode
222      */
223     @Test
224     public void testMapReleaseVersionsNonInteractiveWithExplicitVersion() throws Exception {
225         // prepare
226         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "SNAPSHOT"));
227 
228         MapReleaseVersionsPhase phase =
229                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
230 
231         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
232         builder.addReleaseVersion("groupId:artifactId", "2.0");
233 
234         // execute
235         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
236 
237         // verify
238         assertEquals(
239                 "Check mapped versions",
240                 "2.0",
241                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
242 
243         // prepare
244         builder = new ReleaseDescriptorBuilder();
245         builder.addReleaseVersion("groupId:artifactId", "2.0");
246 
247         // execute
248         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
249 
250         // verify
251         assertEquals(
252                 "Check mapped versions",
253                 "2.0",
254                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
255     }
256 
257     /**
258      * MRELEASE-1022: don't ignore command line (or release.properties) versions when auto-versioning sub-modules
259      */
260     @Test
261     public void testMapReleaseVersionsForSubModuleWithExplicitVersion() throws Exception {
262         // prepare
263         MavenProject rootProject = createProject("rootArtifactId", "SNAPSHOT");
264         rootProject.setExecutionRoot(true);
265 
266         final MavenProject moduleProject = createProject("artifactId", "SNAPSHOT");
267         moduleProject.setParent(rootProject);
268 
269         List<MavenProject> reactorProjects = Arrays.asList(rootProject, moduleProject);
270 
271         MapReleaseVersionsPhase phase =
272                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
273 
274         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder()
275                 .setInteractive(false) // batch mode
276                 .setAutoVersionSubmodules(true)
277                 .addReleaseVersion("groupId:artifactId", "2.0");
278 
279         // execute
280         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
281 
282         // verify
283         assertEquals(
284                 "Check mapped versions",
285                 "1.0",
286                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:rootArtifactId"));
287         assertEquals(
288                 "Check mapped versions",
289                 "2.0",
290                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
291 
292         // execute
293         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
294 
295         // verify
296         assertEquals(
297                 "Check mapped versions",
298                 "1.0",
299                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:rootArtifactId"));
300         assertEquals(
301                 "Check mapped versions",
302                 "2.0",
303                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
304     }
305 
306     /**
307      * MRELEASE-1022: don't ignore command line (or release.properties) versions when auto-versioning sub-modules
308      */
309     @Test
310     public void testMapDevelopmentVersionsForSubModuleWithExplicitVersion() throws Exception {
311         // prepare
312         MavenProject rootProject = createProject("rootArtifactId", "1.0");
313         rootProject.setExecutionRoot(true);
314 
315         final MavenProject moduleProject = createProject("artifactId", "1.0");
316         moduleProject.setParent(rootProject);
317 
318         List<MavenProject> reactorProjects = Arrays.asList(rootProject, moduleProject);
319 
320         MapDevelopmentVersionsPhase phase =
321                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
322 
323         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder()
324                 .setInteractive(false) // batch mode
325                 .setAutoVersionSubmodules(true)
326                 .setDefaultDevelopmentVersion("1.1-SNAPSHOT")
327                 .addDevelopmentVersion("groupId:artifactId", "2.0-SNAPSHOT");
328 
329         // execute
330         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
331 
332         // verify
333         assertEquals(
334                 "Check mapped versions",
335                 "1.1-SNAPSHOT",
336                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:rootArtifactId"));
337         assertEquals(
338                 "Check mapped versions",
339                 "2.0-SNAPSHOT",
340                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
341 
342         // execute
343         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
344 
345         // verify
346         assertEquals(
347                 "Check mapped versions",
348                 "1.1-SNAPSHOT",
349                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:rootArtifactId"));
350         assertEquals(
351                 "Check mapped versions",
352                 "2.0-SNAPSHOT",
353                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
354     }
355 
356     @Test
357     public void testExecuteSnapshotNonInteractiveMapRelease() throws Exception {
358         // prepare
359         MapReleaseVersionsPhase phase =
360                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
361 
362         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.0-SNAPSHOT"));
363 
364         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
365         builder.setInteractive(false);
366 
367         // execute
368         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
369 
370         // verify
371         assertEquals(
372                 "Check mapped versions",
373                 "1.0",
374                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
375     }
376 
377     @Test
378     public void testSimulateSnapshotNonInteractiveMapReleaseVersions() throws Exception {
379         // prepare
380         MapReleaseVersionsPhase phase =
381                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
382 
383         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.0-SNAPSHOT"));
384 
385         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
386         builder.setInteractive(false);
387 
388         // execute
389         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
390 
391         // verify
392         assertEquals(
393                 "Check mapped versions",
394                 "1.0",
395                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
396     }
397 
398     @Test
399     public void testMapDevVersionsInteractive() throws Exception {
400         // prepare
401         MavenProject project = createProject("artifactId", "1.0");
402         when(mockPrompter.prompt(
403                         startsWith("What is the new development version for \"" + project.getName() + "\"?"),
404                         eq("1.1-SNAPSHOT")))
405                 .thenReturn("2.0-SNAPSHOT");
406         MapDevelopmentVersionsPhase phase =
407                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
408 
409         List<MavenProject> reactorProjects = Collections.singletonList(project);
410 
411         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
412 
413         // execute
414         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
415 
416         // verify
417         assertEquals(
418                 "Check mapped versions",
419                 "2.0-SNAPSHOT",
420                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
421 
422         // prepare
423         builder = new ReleaseDescriptorBuilder();
424 
425         // execute
426         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
427 
428         // verify
429         assertEquals(
430                 "Check mapped versions",
431                 "2.0-SNAPSHOT",
432                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
433 
434         verify(mockPrompter, times(2))
435                 .prompt(
436                         startsWith("What is the new development version for \"" + project.getName() + "\"?"),
437                         eq("1.1-SNAPSHOT"));
438     }
439 
440     /**
441      * MRELEASE-760: updateWorkingCopyVersions=false still bumps up pom versions to next development version
442      */
443     @Test
444     public void testMapDevVersionsInteractiveDoNotUpdateWorkingCopy() throws Exception {
445         // prepare
446         MapDevelopmentVersionsPhase phase =
447                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
448         MavenProject project = createProject("artifactId", "1.0");
449 
450         List<MavenProject> reactorProjects = Collections.singletonList(project);
451 
452         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
453         builder.setUpdateWorkingCopyVersions(false);
454 
455         // execute
456         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
457 
458         // verify
459         assertEquals(
460                 "Check mapped versions",
461                 "1.0",
462                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
463 
464         // prepare
465         builder = new ReleaseDescriptorBuilder();
466         builder.setUpdateWorkingCopyVersions(false);
467 
468         // execute
469         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
470 
471         // verify
472         assertEquals(
473                 "Check mapped versions",
474                 "1.0",
475                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
476     }
477 
478     @Test
479     public void testMapDevVersionsNonInteractive() throws Exception {
480         // prepare
481         MapDevelopmentVersionsPhase phase =
482                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
483 
484         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.0"));
485 
486         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
487         builder.setInteractive(false);
488 
489         // execute
490         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
491 
492         // verify
493         assertEquals(
494                 "Check mapped versions",
495                 "1.1-SNAPSHOT",
496                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
497 
498         // prepare
499         builder = new ReleaseDescriptorBuilder();
500         builder.setInteractive(false);
501 
502         // execute
503         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
504 
505         // verify
506         assertEquals(
507                 "Check mapped versions",
508                 "1.1-SNAPSHOT",
509                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
510     }
511 
512     /**
513      * MRELEASE-524: ignores commandline versions in batch mode
514      */
515     @Test
516     public void testMapDevVersionsNonInteractiveWithExplicitVersion() throws Exception {
517         // prepare
518         MapDevelopmentVersionsPhase phase =
519                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
520         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.0"));
521 
522         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
523         builder.setInteractive(false);
524         builder.addDevelopmentVersion("groupId:artifactId", "2-SNAPSHOT");
525 
526         // execute
527         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
528 
529         // verify
530         assertEquals(
531                 "Check mapped versions",
532                 "2-SNAPSHOT",
533                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
534 
535         // prepare
536         builder = new ReleaseDescriptorBuilder();
537         builder.setInteractive(false);
538         builder.addDevelopmentVersion("groupId:artifactId", "2-SNAPSHOT");
539 
540         // execute
541         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
542 
543         // verify
544         assertEquals(
545                 "Check mapped versions",
546                 "2-SNAPSHOT",
547                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
548     }
549 
550     @Test
551     public void testPrompterException() throws Exception {
552         // prepare
553         when(mockPrompter.prompt(isA(String.class), isA(String.class))).thenThrow(new PrompterException("..."));
554         MapDevelopmentVersionsPhase phase =
555                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
556 
557         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.0"));
558 
559         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
560 
561         // execute
562         try {
563             phase.execute(
564                     ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
565 
566             fail("Expected an exception");
567         } catch (ReleaseExecutionException e) {
568             assertEquals("check cause", PrompterException.class, e.getCause().getClass());
569         }
570 
571         // prepare
572         builder = new ReleaseDescriptorBuilder();
573 
574         // execute
575         try {
576             phase.simulate(
577                     ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
578 
579             fail("Expected an exception");
580         } catch (ReleaseExecutionException e) {
581             assertEquals("check cause", PrompterException.class, e.getCause().getClass());
582         }
583 
584         // verify
585         verify(mockPrompter, times(2)).prompt(isA(String.class), isA(String.class));
586     }
587 
588     @Test
589     public void testAdjustVersionInteractive() throws Exception {
590         // prepare
591         MavenProject project = createProject("artifactId", "foo");
592 
593         when(mockPrompter.prompt(
594                         startsWith("What is the new development version for \"" + project.getName() + "\"?"),
595                         eq("1.1-SNAPSHOT")))
596                 .thenReturn("2.0-SNAPSHOT");
597         MapDevelopmentVersionsPhase phase =
598                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
599 
600         List<MavenProject> reactorProjects = Collections.singletonList(project);
601 
602         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
603 
604         // execute
605         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
606 
607         // verify
608         assertEquals(
609                 "Check mapped versions",
610                 "2.0-SNAPSHOT",
611                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
612 
613         // prepare
614         builder = new ReleaseDescriptorBuilder();
615 
616         // execute
617         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
618 
619         // verify
620         assertEquals(
621                 "Check mapped versions",
622                 "2.0-SNAPSHOT",
623                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
624 
625         verify(mockPrompter, times(2))
626                 .prompt(
627                         startsWith("What is the new development version for \"" + project.getName() + "\"?"),
628                         eq("1.1-SNAPSHOT"));
629     }
630 
631     @Test
632     public void testAdjustVersionNonInteractive() {
633         MapDevelopmentVersionsPhase phase =
634                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
635 
636         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "foo"));
637 
638         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
639         builder.setInteractive(false);
640 
641         try {
642             phase.execute(
643                     ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
644 
645             fail("Expected an exception");
646         } catch (ReleaseExecutionException e) {
647             assertEquals(
648                     "check cause", VersionParseException.class, e.getCause().getClass());
649         }
650 
651         builder = new ReleaseDescriptorBuilder();
652         builder.setInteractive(false);
653 
654         try {
655             phase.simulate(
656                     ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
657 
658             fail("Expected an exception");
659         } catch (ReleaseExecutionException e) {
660             assertEquals(
661                     "check cause", VersionParseException.class, e.getCause().getClass());
662         }
663     }
664 
665     @Test
666     public void testExecuteSnapshotBranchCreationDefaultDevelopmentVersionMapDevelopment() throws Exception {
667         // prepare
668         MapDevelopmentVersionsPhase phase =
669                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
670 
671         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
672 
673         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
674         builder.setBranchCreation(true);
675         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
676 
677         // test
678         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
679 
680         // verify
681         assertNull(
682                 "Check release versions",
683                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
684         assertEquals(
685                 "Check development versions",
686                 "1.1.1-SNAPSHOT",
687                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
688     }
689 
690     @Test
691     public void testSimulateSnapshotBranchCreationDefaultDevelopmentVersionMapDevelopment() throws Exception {
692         // prepare
693         MapDevelopmentVersionsPhase phase =
694                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
695 
696         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
697 
698         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
699         builder.setBranchCreation(true);
700         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
701 
702         // test
703         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
704 
705         // verify
706         assertNull(
707                 "Check release versions",
708                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
709         assertEquals(
710                 "Check development versions",
711                 "1.1.1-SNAPSHOT",
712                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
713     }
714 
715     @Test
716     public void testExecuteSnapshotBranchCreationDefaultDevelopmentVersionNonInteractiveMapDevelopment()
717             throws Exception {
718         // prepare
719         MapDevelopmentVersionsPhase phase =
720                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
721 
722         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
723 
724         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
725         builder.setBranchCreation(true);
726         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
727         builder.setInteractive(false);
728 
729         // test
730         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
731 
732         // verify
733         assertNull(
734                 "Check release versions",
735                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
736         assertEquals(
737                 "Check development versions",
738                 "1.1.1-SNAPSHOT",
739                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
740     }
741 
742     @Test
743     public void testSimulateSnapshotBranchCreationDefaultDevelopmentVersionNonInteractiveMapDevelopment()
744             throws Exception {
745         // prepare
746         MapDevelopmentVersionsPhase phase =
747                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
748 
749         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
750 
751         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
752         builder.setBranchCreation(true);
753         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
754         builder.setInteractive(false);
755 
756         // test
757         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
758 
759         // verify
760         assertNull(
761                 "Check release versions",
762                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
763         assertEquals(
764                 "Check development versions",
765                 "1.1.1-SNAPSHOT",
766                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
767     }
768 
769     @Test
770     public void testExecuteSnapshotBranchCreationNonInteractiveMapDevelopment() throws Exception {
771         // prepare
772         MapDevelopmentVersionsPhase phase =
773                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
774 
775         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
776 
777         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
778         builder.setBranchCreation(true);
779         builder.setInteractive(false);
780 
781         // test
782         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
783 
784         // verify
785         assertNull(
786                 "Check release versions",
787                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
788         assertEquals(
789                 "Check development versions",
790                 "1.3-SNAPSHOT",
791                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
792     }
793 
794     @Test
795     public void testSimulateSnapshotBranchCreationNonInteractiveMapDevelopment() throws Exception {
796         // prepare
797         MapDevelopmentVersionsPhase phase =
798                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
799 
800         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
801 
802         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
803         builder.setBranchCreation(true);
804         builder.setInteractive(false);
805 
806         // test
807         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
808 
809         // verify
810         assertNull(
811                 "Check release versions",
812                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
813         assertEquals(
814                 "Check development versions",
815                 "1.3-SNAPSHOT",
816                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
817     }
818 
819     @Test
820     public void testExecuteSnapshotDefaultDevelopmentVersionMapDevelopment() throws Exception {
821         // prepare
822         MapDevelopmentVersionsPhase phase =
823                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
824 
825         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
826 
827         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
828         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
829 
830         // test
831         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
832 
833         // verify
834         assertNull(
835                 "Check release versions",
836                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
837         assertEquals(
838                 "Check development versions",
839                 "1.1.1-SNAPSHOT",
840                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
841     }
842 
843     @Test
844     public void testSimulateSnapshotDefaultDevelopmentVersionMapDevelopment() throws Exception {
845         // prepare
846         MapDevelopmentVersionsPhase phase =
847                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
848 
849         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
850 
851         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
852         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
853 
854         // test
855         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
856 
857         // verify
858         assertNull(
859                 "Check release versions",
860                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
861         assertEquals(
862                 "Check development versions",
863                 "1.1.1-SNAPSHOT",
864                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
865     }
866 
867     @Test
868     public void testExecuteSnapshotDefaultDevelopmentVersionNonInteractiveMapDevelopment() throws Exception {
869         // prepare
870         MapDevelopmentVersionsPhase phase =
871                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
872 
873         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
874 
875         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
876         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
877         builder.setInteractive(false);
878 
879         // test
880         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
881 
882         // verify
883         assertNull(
884                 "Check release versions",
885                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
886         assertEquals(
887                 "Check development versions",
888                 "1.1.1-SNAPSHOT",
889                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
890     }
891 
892     @Test
893     public void testSimulateSnapshotDefaultDevelopmentVersionNonInteractiveMapDevelopment() throws Exception {
894         // prepare
895         MapDevelopmentVersionsPhase phase =
896                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
897 
898         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
899 
900         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
901         builder.setDefaultDevelopmentVersion("1.1.1-SNAPSHOT");
902         builder.setInteractive(false);
903 
904         // test
905         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
906 
907         // verify
908         assertNull(
909                 "Check release versions",
910                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
911         assertEquals(
912                 "Check development versions",
913                 "1.1.1-SNAPSHOT",
914                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
915     }
916 
917     @Test
918     public void testExecuteSnapshotNonInteractiveMapDevelopment() throws Exception {
919         // prepare
920         MapDevelopmentVersionsPhase phase =
921                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
922 
923         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
924 
925         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
926         builder.setInteractive(false);
927 
928         // test
929         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
930 
931         // verify
932         assertNull(
933                 "Check release versions",
934                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
935         assertEquals(
936                 "Check development versions",
937                 "1.3-SNAPSHOT",
938                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
939     }
940 
941     @Test
942     public void testSimulateSnapshotNonInteractiveMapDevelopment() throws Exception {
943         // prepare
944         MapDevelopmentVersionsPhase phase =
945                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
946 
947         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
948 
949         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
950         builder.setInteractive(false);
951 
952         // test
953         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
954 
955         // verify
956         assertNull(
957                 "Check release versions",
958                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
959         assertEquals(
960                 "Check development versions",
961                 "1.3-SNAPSHOT",
962                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
963     }
964 
965     @Test
966     public void testExecuteSnapshotAutoVersionSubmodulesNotInteractiveMapDevelopment() throws Exception {
967         // verify
968         MapDevelopmentVersionsPhase phase =
969                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
970 
971         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
972 
973         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
974         builder.setAutoVersionSubmodules(true);
975         builder.setInteractive(false);
976 
977         // test
978         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
979 
980         // verify
981         assertEquals(
982                 "Check development versions",
983                 "1.3-SNAPSHOT",
984                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
985         assertNull(
986                 "Check release versions",
987                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
988     }
989 
990     @Test
991     public void testSimulateSnapshotAutoVersionSubmodulesNotInteractiveMapDevelopment() throws Exception {
992         // verify
993         MapDevelopmentVersionsPhase phase =
994                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
995 
996         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
997 
998         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
999         builder.setAutoVersionSubmodules(true);
1000         builder.setInteractive(false);
1001 
1002         // test
1003         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1004 
1005         // verify
1006         assertEquals(
1007                 "Check development versions",
1008                 "1.3-SNAPSHOT",
1009                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1010         assertNull(
1011                 "Check release versions",
1012                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1013     }
1014 
1015     @Test
1016     public void testExecuteReleaseAutoVersionSubmodulesNotInteractiveMapDevelopment() throws Exception {
1017         // verify
1018         MapDevelopmentVersionsPhase phase =
1019                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1020 
1021         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1022 
1023         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1024         builder.setAutoVersionSubmodules(true);
1025         builder.setInteractive(false);
1026 
1027         // test
1028         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1029 
1030         // verify
1031         assertEquals(
1032                 "Check development versions",
1033                 "1.3-SNAPSHOT",
1034                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1035         assertNull(
1036                 "Check release versions",
1037                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1038     }
1039 
1040     @Test
1041     public void testSimulateReleaseAutoVersionSubmodulesNotInteractiveMapDevelopment() throws Exception {
1042         // verify
1043         MapDevelopmentVersionsPhase phase =
1044                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1045 
1046         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1047 
1048         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1049         builder.setAutoVersionSubmodules(true);
1050         builder.setInteractive(false);
1051 
1052         // test
1053         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1054 
1055         // verify
1056         assertEquals(
1057                 "Check development versions",
1058                 "1.3-SNAPSHOT",
1059                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1060         assertNull(
1061                 "Check release versions",
1062                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1063     }
1064 
1065     @Test
1066     public void testExecuteSnapshotAutoVersionSubmodulesNotInteractiveMapRelease() throws Exception {
1067         // verify
1068         MapReleaseVersionsPhase phase =
1069                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1070 
1071         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1072 
1073         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1074         builder.setAutoVersionSubmodules(true);
1075         builder.setInteractive(false);
1076 
1077         // test
1078         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1079 
1080         // verify
1081         assertEquals(
1082                 "Check release versions",
1083                 "1.2",
1084                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1085         assertNull(
1086                 "Check development versions",
1087                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1088     }
1089 
1090     @Test
1091     public void testSimulateSnapshotAutoVersionSubmodulesNotInteractiveMapRelease() throws Exception {
1092         // verify
1093         MapReleaseVersionsPhase phase =
1094                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1095 
1096         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1097 
1098         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1099         builder.setAutoVersionSubmodules(true);
1100         builder.setInteractive(false);
1101 
1102         // test
1103         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1104 
1105         // verify
1106         assertEquals(
1107                 "Check release versions",
1108                 "1.2",
1109                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1110         assertNull(
1111                 "Check development versions",
1112                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1113     }
1114 
1115     @Test
1116     public void testExecuteReleaseAutoVersionSubmodulesNotInteractiveMapRelease() throws Exception {
1117         // verify
1118         MapReleaseVersionsPhase phase =
1119                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1120 
1121         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1122 
1123         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1124         builder.setAutoVersionSubmodules(true);
1125         builder.setInteractive(false);
1126 
1127         // test
1128         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1129 
1130         // verify
1131         assertEquals(
1132                 "Check release versions",
1133                 "1.2",
1134                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1135         assertNull(
1136                 "Check development versions",
1137                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1138     }
1139 
1140     @Test
1141     public void testSimulateReleaseAutoVersionSubmodulesNotInteractiveMapRelease() throws Exception {
1142         // verify
1143         MapReleaseVersionsPhase phase =
1144                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1145 
1146         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1147 
1148         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1149         builder.setAutoVersionSubmodules(true);
1150         builder.setInteractive(false);
1151 
1152         // test
1153         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1154 
1155         // verify
1156         assertEquals(
1157                 "Check release versions",
1158                 "1.2",
1159                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1160         assertNull(
1161                 "Check development versions",
1162                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1163     }
1164 
1165     @Test
1166     public void testExecuteSnapshotAutoVersionSubmodulesBranchCreationNotInteractiveMapDevelopment() throws Exception {
1167         // prepare
1168         MapDevelopmentVersionsPhase phase =
1169                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1170 
1171         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1172 
1173         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1174         builder.setAutoVersionSubmodules(true);
1175         builder.setBranchCreation(true);
1176         builder.setInteractive(false);
1177 
1178         // test
1179         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1180 
1181         // verify
1182         assertEquals(
1183                 "Check development versions",
1184                 "1.3-SNAPSHOT",
1185                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1186         assertNull(
1187                 "Check release versions",
1188                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1189     }
1190 
1191     @Test
1192     public void testSimulateSnapshotAutoVersionSubmodulesBranchCreationNotInteractiveMapDevelopment() throws Exception {
1193         // prepare
1194         MapDevelopmentVersionsPhase phase =
1195                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1196 
1197         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1198 
1199         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1200         builder.setAutoVersionSubmodules(true);
1201         builder.setBranchCreation(true);
1202         builder.setInteractive(false);
1203 
1204         // test
1205         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1206 
1207         // verify
1208         assertEquals(
1209                 "Check development versions",
1210                 "1.3-SNAPSHOT",
1211                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1212         assertNull(
1213                 "Check release versions",
1214                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1215     }
1216 
1217     @Test
1218     public void testExecuteReleaseAutoVersionSubmodulesBranchCreationNotInteractiveMapDevelopment() throws Exception {
1219         // prepare
1220         MapDevelopmentVersionsPhase phase =
1221                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1222 
1223         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1224 
1225         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1226         builder.setAutoVersionSubmodules(true);
1227         builder.setBranchCreation(true);
1228         builder.setInteractive(false);
1229 
1230         // test
1231         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1232 
1233         // verify
1234         assertEquals(
1235                 "Check development versions",
1236                 "1.2",
1237                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1238         assertNull(
1239                 "Check release versions",
1240                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1241     }
1242 
1243     @Test
1244     public void testSimulateReleaseAutoVersionSubmodulesBranchCreationNotInteractiveMapDevelopment() throws Exception {
1245         // prepare
1246         MapDevelopmentVersionsPhase phase =
1247                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1248 
1249         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1250 
1251         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1252         builder.setAutoVersionSubmodules(true);
1253         builder.setBranchCreation(true);
1254         builder.setInteractive(false);
1255 
1256         // test
1257         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1258 
1259         // verify
1260         assertEquals(
1261                 "Check development versions",
1262                 "1.2",
1263                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1264         assertNull(
1265                 "Check release versions",
1266                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1267     }
1268 
1269     @Test
1270     public void testExecuteSnapshotAutoVersionSubmodulesBranchCreationNotInteractiveMapBranch() throws Exception {
1271         // prepare
1272         MapBranchVersionsPhase phase =
1273                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1274 
1275         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1276 
1277         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1278         builder.setAutoVersionSubmodules(true);
1279         builder.setBranchCreation(true);
1280         builder.setInteractive(false);
1281 
1282         // test
1283         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1284 
1285         // verify
1286         assertEquals(
1287                 "Check release versions",
1288                 "1.2-SNAPSHOT",
1289                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1290         assertNull(
1291                 "Check development versions",
1292                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1293     }
1294 
1295     @Test
1296     public void testSimulateSnapshotAutoVersionSubmodulesBranchCreationNotInteractiveMapBranch() throws Exception {
1297         // prepare
1298         MapBranchVersionsPhase phase =
1299                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1300 
1301         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1302 
1303         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1304         builder.setAutoVersionSubmodules(true);
1305         builder.setBranchCreation(true);
1306         builder.setInteractive(false);
1307 
1308         // test
1309         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1310 
1311         // verify
1312         assertEquals(
1313                 "Check release versions",
1314                 "1.2-SNAPSHOT",
1315                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1316         assertNull(
1317                 "Check development versions",
1318                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1319     }
1320 
1321     @Test
1322     public void testExecuteReleaseAutoVersionSubmodulesBranchCreationNotInteractiveMapBranch() throws Exception {
1323         // prepare
1324         MapBranchVersionsPhase phase =
1325                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1326 
1327         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1328 
1329         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1330         builder.setAutoVersionSubmodules(true);
1331         builder.setBranchCreation(true);
1332         builder.setInteractive(false);
1333 
1334         // test
1335         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1336 
1337         // verify
1338         /*
1339          * "By default, the POM in the new branch keeps the same version as the local working copy, and the local POM is incremented to the next revision."
1340          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
1341          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
1342          */
1343         assertEquals(
1344                 "Check release versions",
1345                 "1.2",
1346                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1347         assertNull(
1348                 "Check development versions",
1349                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1350     }
1351 
1352     @Test
1353     public void testSimulateReleaseAutoVersionSubmodulesBranchCreationNotInteractiveMapBranch() throws Exception {
1354         // prepare
1355         MapBranchVersionsPhase phase =
1356                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1357 
1358         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1359 
1360         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1361         builder.setAutoVersionSubmodules(true);
1362         builder.setBranchCreation(true);
1363         builder.setInteractive(false);
1364 
1365         // test
1366         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1367 
1368         // verify
1369         /*
1370          * "By default, the POM in the new branch keeps the same version as the local working copy, and the local POM is incremented to the next revision."
1371          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
1372          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
1373          */
1374         assertEquals(
1375                 "Check release versions",
1376                 "1.2",
1377                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1378         assertNull(
1379                 "Check development versions",
1380                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1381     }
1382 
1383     @Test
1384     public void testExecuteSnapshotBranchCreationNonInteractiveUpdateBranchVersionsMapBranch() throws Exception {
1385         // prepare
1386         MapBranchVersionsPhase phase =
1387                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1388 
1389         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1390 
1391         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1392         builder.setBranchCreation(true);
1393         builder.setInteractive(false);
1394         builder.setUpdateBranchVersions(true);
1395 
1396         // test
1397         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1398 
1399         // verify
1400         // updateBranchVersions is set to true, so suggest the next snapshot version
1401         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1402         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1403         assertEquals(
1404                 "Check release versions",
1405                 "1.3-SNAPSHOT",
1406                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1407         assertNull(
1408                 "Check development versions",
1409                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1410     }
1411 
1412     @Test
1413     public void testSimulateSnapshotBranchCreationNonInteractiveUpdateBranchVersionsMapBranch() throws Exception {
1414         // prepare
1415         MapBranchVersionsPhase phase =
1416                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1417 
1418         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1419 
1420         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1421         builder.setBranchCreation(true);
1422         builder.setInteractive(false);
1423         builder.setUpdateBranchVersions(true);
1424 
1425         // test
1426         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1427 
1428         // verify
1429         // updateBranchVersions is set to true, so suggest the next snapshot version
1430         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1431         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1432         assertEquals(
1433                 "Check release versions",
1434                 "1.3-SNAPSHOT",
1435                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1436         assertNull(
1437                 "Check development versions",
1438                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1439     }
1440 
1441     @Test
1442     public void testExecuteSnapshotBranchCreationDefaultReleaseVersionNonInteractiveUpdateBranchVersionsMapBranch()
1443             throws Exception {
1444         // prepare
1445         MapBranchVersionsPhase phase =
1446                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1447 
1448         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1449 
1450         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1451         builder.setBranchCreation(true);
1452         builder.setDefaultReleaseVersion("2.1-SNAPSHOT");
1453         builder.setInteractive(false);
1454         builder.setUpdateBranchVersions(true);
1455 
1456         // test
1457         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1458 
1459         // verify
1460         assertEquals(
1461                 "Check release versions",
1462                 "2.1-SNAPSHOT",
1463                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1464         assertNull(
1465                 "Check development versions",
1466                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1467     }
1468 
1469     @Test
1470     public void testSimulateSnapshotBranchCreationDefaultReleaseVersionNonInteractiveUpdateBranchVersionsMapBranch()
1471             throws Exception {
1472         // prepare
1473         MapBranchVersionsPhase phase =
1474                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1475 
1476         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1477 
1478         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1479         builder.setBranchCreation(true);
1480         builder.setDefaultReleaseVersion("2.1-SNAPSHOT");
1481         builder.setInteractive(false);
1482         builder.setUpdateBranchVersions(true);
1483 
1484         // test
1485         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1486 
1487         // verify
1488         assertEquals(
1489                 "Check release versions",
1490                 "2.1-SNAPSHOT",
1491                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1492         assertNull(
1493                 "Check development versions",
1494                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1495     }
1496 
1497     @Test
1498     public void testExecuteSnapshotBranchCreationDefaultReleaseVersionUpdateBranchVersionsMapBranch() throws Exception {
1499         // prepare
1500         MapBranchVersionsPhase phase =
1501                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1502 
1503         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1504 
1505         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1506         builder.setBranchCreation(true);
1507         builder.setDefaultReleaseVersion("2.1-SNAPSHOT");
1508         builder.setUpdateBranchVersions(true);
1509 
1510         // test
1511         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1512 
1513         // verify
1514         assertEquals(
1515                 "Check release versions",
1516                 "2.1-SNAPSHOT",
1517                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1518         assertNull(
1519                 "Check development versions",
1520                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1521     }
1522 
1523     @Test
1524     public void testSimulateSnapshotBranchCreationDefaultReleaseVersionUpdateBranchVersionsMapBranch()
1525             throws Exception {
1526         // prepare
1527         MapBranchVersionsPhase phase =
1528                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1529 
1530         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1531 
1532         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1533         builder.setBranchCreation(true);
1534         builder.setDefaultReleaseVersion("2.1-SNAPSHOT");
1535         builder.setUpdateBranchVersions(true);
1536 
1537         // test
1538         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1539 
1540         // verify
1541         assertEquals(
1542                 "Check release versions",
1543                 "2.1-SNAPSHOT",
1544                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1545         assertNull(
1546                 "Check development versions",
1547                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1548     }
1549 
1550     @Test
1551     public void testExecuteSnapshotBranchCreationUpdateBranchVersionsMapBranch() throws Exception {
1552         // prepare
1553         // updateBranchVersions is set to true, so suggest the next snapshot version
1554         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1555         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1556         when(mockPrompter.prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT")))
1557                 .thenReturn("2.0-SNAPSHOT");
1558         MapBranchVersionsPhase phase =
1559                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1560 
1561         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1562 
1563         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1564         builder.setBranchCreation(true);
1565         builder.setUpdateBranchVersions(true);
1566 
1567         // test
1568         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1569 
1570         // verify
1571         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1572         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1573         verify(mockPrompter).prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT"));
1574     }
1575 
1576     @Test
1577     public void testSimulateSnapshotBranchCreationUpdateBranchVersionsMapBranch() throws Exception {
1578         // prepare
1579         // updateBranchVersions is set to true, so suggest the next snapshot version
1580         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1581         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1582         when(mockPrompter.prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT")))
1583                 .thenReturn("2.0-SNAPSHOT");
1584         MapBranchVersionsPhase phase =
1585                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1586 
1587         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1588 
1589         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1590         builder.setBranchCreation(true);
1591         builder.setUpdateBranchVersions(true);
1592 
1593         // test
1594         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1595 
1596         // verify
1597         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1598         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1599         verify(mockPrompter).prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT"));
1600     }
1601 
1602     @Test
1603     public void testExecuteReleaseBranchCreationUpdateBranchVersionsUpdateVersionsToSnapshotMapBranch()
1604             throws Exception {
1605         // prepare
1606         // updateBranchVersions is set to true, so suggest the next snapshot version
1607         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
1608         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1609         when(mockPrompter.prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT")))
1610                 .thenReturn("2.1-SNAPSHOT");
1611         MapBranchVersionsPhase phase =
1612                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1613 
1614         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1615 
1616         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1617         builder.setBranchCreation(true);
1618         builder.setUpdateBranchVersions(true);
1619         builder.setUpdateVersionsToSnapshot(true);
1620 
1621         // test
1622         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1623 
1624         // verify
1625         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
1626         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1627         verify(mockPrompter).prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT"));
1628         assertEquals(
1629                 "Check release versions",
1630                 "2.1-SNAPSHOT",
1631                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1632         assertNull(
1633                 "Check development versions",
1634                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1635     }
1636 
1637     @Test
1638     public void testSimulateReleaseBranchCreationUpdateBranchVersionsUpdateVersionsToSnapshotMapBranch()
1639             throws Exception {
1640         // prepare
1641         // updateBranchVersions is set to true, so suggest the next snapshot version
1642         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
1643         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1644         when(mockPrompter.prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT")))
1645                 .thenReturn("2.1-SNAPSHOT");
1646         MapBranchVersionsPhase phase =
1647                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1648 
1649         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1650 
1651         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1652         builder.setBranchCreation(true);
1653         builder.setUpdateBranchVersions(true);
1654         builder.setUpdateVersionsToSnapshot(true);
1655 
1656         // test
1657         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1658 
1659         // verify
1660         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT (yes, one step back!)
1661         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1662         verify(mockPrompter).prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT"));
1663         assertEquals(
1664                 "Check release versions",
1665                 "2.1-SNAPSHOT",
1666                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1667         assertNull(
1668                 "Check development versions",
1669                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1670     }
1671 
1672     @Test
1673     public void testExecuteSnapshotBranchCreationUpdateBranchVersionsUpdateVersionsToSnapshotMapBranch()
1674             throws Exception {
1675         // prepare
1676         // updateBranchVersions is set to true, so suggest the next snapshot version
1677         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1678         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1679         when(mockPrompter.prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT")))
1680                 .thenReturn("2.0-SNAPSHOT");
1681         MapBranchVersionsPhase phase =
1682                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1683 
1684         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1685 
1686         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1687         builder.setBranchCreation(true);
1688         builder.setUpdateBranchVersions(true);
1689         builder.setUpdateVersionsToSnapshot(true);
1690 
1691         // test
1692         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1693 
1694         // verify
1695         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1696         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1697         verify(mockPrompter).prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT"));
1698     }
1699 
1700     @Test
1701     public void testSimulateSnapshotBranchCreationUpdateBranchVersionsUpdateVersionsToSnapshotMapBranch()
1702             throws Exception {
1703         // prepare
1704         // updateBranchVersions is set to true, so suggest the next snapshot version
1705         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1706         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1707         when(mockPrompter.prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT")))
1708                 .thenReturn("2.0-SNAPSHOT");
1709         MapBranchVersionsPhase phase =
1710                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1711 
1712         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1713 
1714         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1715         builder.setBranchCreation(true);
1716         builder.setUpdateBranchVersions(true);
1717         builder.setUpdateVersionsToSnapshot(true);
1718 
1719         // test
1720         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1721 
1722         // verify
1723         // org.apache.maven.release:maven-release-manager:(,2.4) > 1.2-SNAPSHOT
1724         // org.apache.maven.release:maven-release-manager:[2.4,) > 1.3-SNAPSHOT
1725         verify(mockPrompter).prompt(startsWith("What is the branch version for"), eq("1.3-SNAPSHOT"));
1726     }
1727 
1728     @Test
1729     public void testExecuteReleaseBranchCreationMapBranch() throws Exception {
1730         // prepare
1731         MapBranchVersionsPhase phase =
1732                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1733 
1734         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1735 
1736         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1737         builder.setBranchCreation(true);
1738 
1739         // test
1740         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1741 
1742         // verify
1743         /*
1744          * "By default, the POM in the new branch keeps the same version as the local working copy, and the local POM is incremented to the next revision."
1745          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
1746          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
1747          */
1748         assertEquals(
1749                 "Check release versions",
1750                 "1.2",
1751                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1752         assertNull(
1753                 "Check development versions",
1754                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1755     }
1756 
1757     @Test
1758     public void testSimulateReleaseBranchCreationMapBranch() throws Exception {
1759         // prepare
1760         MapBranchVersionsPhase phase =
1761                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1762 
1763         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1764 
1765         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1766         builder.setBranchCreation(true);
1767 
1768         // test
1769         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1770 
1771         // verify
1772         /*
1773          * "By default, the POM in the new branch keeps the same version as the local working copy, and the local POM is incremented to the next revision."
1774          * This is true for trunk, but when branching from a tag I would expect the next SNAPSHOT version. For now keep
1775          * '1.2' instead of '1.3-SNAPSHOT' until further investigation.
1776          */
1777         assertEquals(
1778                 "Check release versions",
1779                 "1.2",
1780                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1781         assertNull(
1782                 "Check development versions",
1783                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1784     }
1785 
1786     @Test
1787     public void testExecuteReleaseBranchCreationNonUpdateWorkingCopyVersionsMapDevelopment() throws Exception {
1788         // prepare
1789         MapDevelopmentVersionsPhase phase =
1790                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1791 
1792         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1793 
1794         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1795         builder.setBranchCreation(true);
1796         builder.setUpdateWorkingCopyVersions(false);
1797 
1798         // test
1799         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1800 
1801         // verify
1802         assertNull(
1803                 "Check release versions",
1804                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1805         assertEquals(
1806                 "Check development versions",
1807                 "1.2",
1808                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1809     }
1810 
1811     @Test
1812     public void testSimulateReleaseBranchCreationNonUpdateWorkingCopyVersionsMapDevelopment() throws Exception {
1813         // prepare
1814         MapDevelopmentVersionsPhase phase =
1815                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1816 
1817         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1818 
1819         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1820         builder.setBranchCreation(true);
1821         builder.setUpdateWorkingCopyVersions(false);
1822 
1823         // test
1824         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1825 
1826         // verify
1827         assertNull(
1828                 "Check release versions",
1829                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1830         assertEquals(
1831                 "Check development versions",
1832                 "1.2",
1833                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1834     }
1835 
1836     @Test
1837     public void testExecuteReleaseBranchCreationMapDevelopment() throws Exception {
1838         // prepare
1839         MapDevelopmentVersionsPhase phase =
1840                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1841 
1842         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1843 
1844         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1845         builder.setBranchCreation(true);
1846         // org.apache.maven.release:maven-release-manager:(,2.4) > true
1847         // org.apache.maven.release:maven-release-manager:[2.4,) > false
1848         builder.setInteractive(false);
1849         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1850 
1851         // verify
1852         assertNull(
1853                 "Check release versions",
1854                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1855         assertEquals(
1856                 "Check development versions",
1857                 "1.2",
1858                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1859     }
1860 
1861     @Test
1862     public void testSimulateReleaseBranchCreationMapDevelopment() throws Exception {
1863         // prepare
1864         MapDevelopmentVersionsPhase phase =
1865                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1866 
1867         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1868 
1869         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1870         builder.setBranchCreation(true);
1871         // org.apache.maven.release:maven-release-manager:(,2.4) > true
1872         // org.apache.maven.release:maven-release-manager:[2.4,) > false
1873         builder.setInteractive(false);
1874 
1875         // test
1876         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1877 
1878         // verify
1879         assertNull(
1880                 "Check release versions",
1881                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1882         assertEquals(
1883                 "Check development versions",
1884                 "1.2",
1885                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1886     }
1887 
1888     @Test
1889     public void testExecuteSnapshotBranchCreationMapBranch() throws Exception {
1890         // prepare
1891         MapBranchVersionsPhase phase =
1892                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1893 
1894         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1895 
1896         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1897         builder.setBranchCreation(true);
1898 
1899         // test
1900         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1901 
1902         // verify
1903         assertEquals(
1904                 "Check release versions",
1905                 "1.2-SNAPSHOT",
1906                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1907         assertNull(
1908                 "Check development versions",
1909                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1910     }
1911 
1912     @Test
1913     public void testSimulateSnapshotBranchCreationMapBranch() throws Exception {
1914         // prepare
1915         MapBranchVersionsPhase phase =
1916                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1917 
1918         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1919 
1920         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1921         builder.setBranchCreation(true);
1922 
1923         // test
1924         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1925 
1926         // verify
1927         assertEquals(
1928                 "Check release versions",
1929                 "1.2-SNAPSHOT",
1930                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1931         assertNull(
1932                 "Check development versions",
1933                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1934     }
1935 
1936     @Test
1937     public void testExecuteSnapshotBranchCreationNonUpdateWorkingCopyVersionsMapDevelopment() throws Exception {
1938         // prepare
1939         MapDevelopmentVersionsPhase phase =
1940                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1941 
1942         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1943 
1944         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1945         builder.setBranchCreation(true);
1946         builder.setUpdateWorkingCopyVersions(false);
1947 
1948         // test
1949         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1950 
1951         // verify
1952         assertNull(
1953                 "Check release versions",
1954                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1955         assertEquals(
1956                 "Check development versions",
1957                 "1.2-SNAPSHOT",
1958                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1959     }
1960 
1961     @Test
1962     public void testSimulateSnapshotBranchCreationNonUpdateWorkingCopyVersionsMapDevelopment() throws Exception {
1963         // prepare
1964         MapDevelopmentVersionsPhase phase =
1965                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1966 
1967         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
1968 
1969         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1970         builder.setBranchCreation(true);
1971         builder.setUpdateWorkingCopyVersions(false);
1972 
1973         // test
1974         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
1975 
1976         // verify
1977         assertNull(
1978                 "Check release versions",
1979                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
1980         assertEquals(
1981                 "Check development versions",
1982                 "1.2-SNAPSHOT",
1983                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
1984     }
1985 
1986     @Test
1987     public void testExecuteReleaseBranchCreationUpdateBranchVersionsMapBranch() throws Exception {
1988         // prepare
1989         MapBranchVersionsPhase phase =
1990                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
1991 
1992         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
1993 
1994         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
1995         builder.setBranchCreation(true);
1996         builder.setUpdateBranchVersions(true);
1997         // org.apache.maven.release:maven-release-manager:(,2.4) > true
1998         // org.apache.maven.release:maven-release-manager:[2.4,) > false
1999         builder.setInteractive(false);
2000 
2001         // test
2002         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2003 
2004         // verify
2005         assertEquals(
2006                 "Check release versions",
2007                 "1.2",
2008                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2009         assertNull(
2010                 "Check development versions",
2011                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2012     }
2013 
2014     @Test
2015     public void testSimulateReleaseBranchCreationUpdateBranchVersionsMapBranch() throws Exception {
2016         // prepare
2017         MapBranchVersionsPhase phase =
2018                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2019 
2020         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2"));
2021 
2022         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2023         builder.setBranchCreation(true);
2024         builder.setUpdateBranchVersions(true);
2025         // org.apache.maven.release:maven-release-manager:(,2.4) > true
2026         // org.apache.maven.release:maven-release-manager:[2.4,) > false
2027         builder.setInteractive(false);
2028 
2029         // test
2030         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2031 
2032         // verify
2033         assertEquals(
2034                 "Check release versions",
2035                 "1.2",
2036                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2037         assertNull(
2038                 "Check development versions",
2039                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2040     }
2041 
2042     @Test
2043     public void testExecuteSnapshotBranchCreationUpdateWorkingCopyVersionsMapDevelopment() throws Exception {
2044         // prepare
2045         when(mockPrompter.prompt(startsWith("What is the new working copy version for"), eq("1.3-SNAPSHOT")))
2046                 .thenReturn("2.0-SNAPSHOT");
2047         MapDevelopmentVersionsPhase phase =
2048                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2049 
2050         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
2051 
2052         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2053         builder.setBranchCreation(true);
2054         builder.setUpdateWorkingCopyVersions(true);
2055 
2056         // test
2057         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2058 
2059         // verify
2060         verify(mockPrompter).prompt(startsWith("What is the new working copy version for"), eq("1.3-SNAPSHOT"));
2061     }
2062 
2063     @Test
2064     public void testSimulateSnapshotBranchCreationUpdateWorkingCopyVersionsMapDevelopment() throws Exception {
2065         // prepare
2066         when(mockPrompter.prompt(startsWith("What is the new working copy version for"), eq("1.3-SNAPSHOT")))
2067                 .thenReturn("2.0-SNAPSHOT");
2068         MapDevelopmentVersionsPhase phase =
2069                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2070 
2071         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2-SNAPSHOT"));
2072 
2073         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2074         builder.setBranchCreation(true);
2075         builder.setUpdateWorkingCopyVersions(true);
2076 
2077         // test
2078         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2079 
2080         // verify
2081         verify(mockPrompter).prompt(startsWith("What is the new working copy version for"), eq("1.3-SNAPSHOT"));
2082     }
2083 
2084     @Test
2085     public void testExecuteMultiModuleAutoVersionSubmodulesMapDevelopment() throws Exception {
2086         // verify
2087         MapDevelopmentVersionsPhase phase =
2088                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2089 
2090         List<MavenProject> reactorProjects = new ArrayList<>();
2091         Collections.addAll(
2092                 reactorProjects, createProject("artifactId", "1.2-SNAPSHOT"), createProject("module1", "2.0"));
2093 
2094         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2095         builder.setAutoVersionSubmodules(true);
2096         builder.setInteractive(false);
2097 
2098         // test
2099         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2100 
2101         // verify
2102         assertEquals(
2103                 "Check development versions",
2104                 "1.3-SNAPSHOT",
2105                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2106         assertEquals(
2107                 "Check development versions",
2108                 "2.0",
2109                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:module1"));
2110         assertNull(
2111                 "Check release versions",
2112                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2113         assertNull(
2114                 "Check release versions",
2115                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:module1"));
2116     }
2117 
2118     @Test
2119     public void testSimulateMultiModuleAutoVersionSubmodulesMapDevelopment() throws Exception {
2120         // verify
2121         MapDevelopmentVersionsPhase phase =
2122                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2123 
2124         List<MavenProject> reactorProjects = new ArrayList<>();
2125         Collections.addAll(
2126                 reactorProjects, createProject("artifactId", "1.2-SNAPSHOT"), createProject("module1", "2.0"));
2127 
2128         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2129         builder.setAutoVersionSubmodules(true);
2130         builder.setInteractive(false);
2131 
2132         // test
2133         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2134 
2135         // verify
2136         assertEquals(
2137                 "Check development versions",
2138                 "1.3-SNAPSHOT",
2139                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2140         assertEquals(
2141                 "Check development versions",
2142                 "2.0",
2143                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:module1"));
2144         assertNull(
2145                 "Check release versions",
2146                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2147         assertNull(
2148                 "Check release versions",
2149                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:module1"));
2150     }
2151 
2152     @Test
2153     public void testExecuteSnapshotAutoVersionSubmodulesDefaultReleaseVersionNonInteractiveMapDevelopment()
2154             throws Exception {
2155         // verify
2156         MapDevelopmentVersionsPhase phase =
2157                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2158 
2159         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2.1-SNAPSHOT"));
2160 
2161         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2162         builder.setAutoVersionSubmodules(true);
2163         builder.setDefaultReleaseVersion("3.0");
2164         builder.setInteractive(false);
2165 
2166         // test
2167         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2168 
2169         // verify
2170         assertEquals(
2171                 "Check development versions",
2172                 "3.1-SNAPSHOT",
2173                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2174         assertNull(
2175                 "Check release versions",
2176                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2177     }
2178 
2179     @Test
2180     public void testSimulateSnapshotAutoVersionSubmodulesDefaultReleaseVersionNonInteractiveMapDevelopment()
2181             throws Exception {
2182         // verify
2183         MapDevelopmentVersionsPhase phase =
2184                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2185 
2186         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2.1-SNAPSHOT"));
2187 
2188         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2189         builder.setAutoVersionSubmodules(true);
2190         builder.setDefaultReleaseVersion("3.0");
2191         builder.setInteractive(false);
2192 
2193         // test
2194         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2195 
2196         // verify
2197         assertEquals(
2198                 "Check development versions",
2199                 "3.1-SNAPSHOT",
2200                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2201         assertNull(
2202                 "Check release versions",
2203                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2204     }
2205 
2206     @Test
2207     public void testExecuteSnapshotAutoVersionSubmodulesDefaultDevelopmentVersionNonInteractiveMapDevelopment()
2208             throws Exception {
2209         // verify
2210         MapDevelopmentVersionsPhase phase =
2211                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2212 
2213         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2.1-SNAPSHOT"));
2214 
2215         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2216         builder.setAutoVersionSubmodules(true);
2217         builder.setDefaultDevelopmentVersion("3.0-SNAPSHOT");
2218         builder.setInteractive(false);
2219 
2220         // test
2221         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2222 
2223         // verify
2224         assertEquals(
2225                 "Check development versions",
2226                 "3.0-SNAPSHOT",
2227                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2228         assertNull(
2229                 "Check release versions",
2230                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2231     }
2232 
2233     @Test
2234     public void testSimulateSnapshotAutoVersionSubmodulesDefaultDevelopmentVersionNonInteractiveMapDevelopment()
2235             throws Exception {
2236         // verify
2237         MapDevelopmentVersionsPhase phase =
2238                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2239 
2240         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.2.1-SNAPSHOT"));
2241 
2242         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2243         builder.setAutoVersionSubmodules(true);
2244         builder.setDefaultDevelopmentVersion("3.0-SNAPSHOT");
2245         builder.setInteractive(false);
2246 
2247         // test
2248         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2249 
2250         // verify
2251         assertEquals(
2252                 "Check development versions",
2253                 "3.0-SNAPSHOT",
2254                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2255         assertNull(
2256                 "Check release versions",
2257                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2258     }
2259 
2260     // MRELEASE-511
2261     @Test
2262     public void testUnusualVersions1() throws Exception {
2263         MapReleaseVersionsPhase mapReleasephase =
2264                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2265         MapDevelopmentVersionsPhase mapDevelopmentphase =
2266                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2267 
2268         List<MavenProject> reactorProjects =
2269                 Collections.singletonList(createProject("artifactId", "MYB_200909-SNAPSHOT"));
2270 
2271         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2272         builder.setDefaultReleaseVersion("PPX");
2273         builder.setDefaultDevelopmentVersion("MYB_200909-SNAPSHOT");
2274 
2275         // test
2276         mapReleasephase.execute(
2277                 ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2278         mapDevelopmentphase.execute(
2279                 ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2280 
2281         // verify
2282         assertEquals(
2283                 "Check development versions",
2284                 "MYB_200909-SNAPSHOT",
2285                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2286         assertEquals(
2287                 "Check release versions",
2288                 "PPX",
2289                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2290     }
2291 
2292     // MRELEASE-269
2293     @Test
2294     public void testContinuousSnapshotCheck() throws Exception {
2295         // prepare
2296         when(mockPrompter.prompt(startsWith("What is the new development version for "), eq("1.12-SNAPSHOT")))
2297                 .thenReturn("2.0") // wrong, expected SNAPSHOT
2298                 .thenReturn("2.0-SNAPSHOT");
2299         MapDevelopmentVersionsPhase phase =
2300                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2301 
2302         List<MavenProject> reactorProjects = Collections.singletonList(createProject("bar", "1.11-SNAPSHOT"));
2303 
2304         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2305 
2306         // test
2307         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2308 
2309         // verify
2310         verify(mockPrompter, times(2))
2311                 .prompt(startsWith("What is the new development version for "), eq("1.12-SNAPSHOT"));
2312     }
2313 
2314     // MRELEASE-734
2315     @Test
2316     public void testEmptyDefaultDevelopmentVersion() throws Exception {
2317         // prepare
2318         when(mockPrompter.prompt(startsWith("What is the new development version for "), eq("1.12-SNAPSHOT")))
2319                 .thenReturn("2.0-SNAPSHOT");
2320         MapDevelopmentVersionsPhase phase =
2321                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2322 
2323         List<MavenProject> reactorProjects = Collections.singletonList(createProject("bar", "1.11-SNAPSHOT"));
2324 
2325         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2326         builder.setDefaultDevelopmentVersion("");
2327 
2328         // test
2329         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2330 
2331         // verify
2332         verify(mockPrompter).prompt(startsWith("What is the new development version for "), eq("1.12-SNAPSHOT"));
2333     }
2334 
2335     @Test
2336     public void testEmptyDefaultReleaseVersion() throws Exception {
2337         // prepare
2338         when(mockPrompter.prompt(startsWith("What is the release version for "), eq("1.11")))
2339                 .thenReturn("2.0");
2340         MapReleaseVersionsPhase phase =
2341                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2342 
2343         List<MavenProject> reactorProjects = Collections.singletonList(createProject("bar", "1.11-SNAPSHOT"));
2344 
2345         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2346         builder.setDefaultReleaseVersion("");
2347 
2348         // test
2349         phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2350 
2351         // verify
2352         verify(mockPrompter).prompt(startsWith("What is the release version for "), eq("1.11"));
2353     }
2354 
2355     /**
2356      * MRELEASE-975: Test that a PolicyException is thrown when using an unknown policy version hint.
2357      */
2358     @Test
2359     public void testNonExistentVersionPolicy() {
2360         // prepare
2361         MapReleaseVersionsPhase phase =
2362                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2363 
2364         List<MavenProject> reactorProjects = Collections.singletonList(createProject("artifactId", "1.0-SNAPSHOT"));
2365 
2366         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2367         builder.setProjectVersionPolicyId("UNKNOWN");
2368 
2369         // test
2370         ReleaseExecutionException e = assertThrows(
2371                 ReleaseExecutionException.class,
2372                 () -> phase.execute(
2373                         ReleaseUtils.buildReleaseDescriptor(builder),
2374                         new DefaultReleaseEnvironment(),
2375                         reactorProjects));
2376         assertThat(e.getCause(), CoreMatchers.instanceOf(PolicyException.class));
2377     }
2378 
2379     @Test
2380     public void testUpdateBranchInvalidDefaultReleaseVersionNonInteractive() {
2381         // prepare
2382         MapBranchVersionsPhase phase =
2383                 new MapBranchVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2384 
2385         List<MavenProject> reactorProjects = Collections.singletonList(createProject("bar", "1.11-SNAPSHOT"));
2386 
2387         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2388         builder.setDefaultReleaseVersion("3.0");
2389         builder.setInteractive(false);
2390         builder.setUpdateBranchVersions(true);
2391 
2392         // test
2393         try {
2394             phase.execute(
2395                     ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2396             fail("Should fail due to invalid version");
2397         } catch (ReleaseExecutionException e) {
2398             assertEquals("3.0 is invalid, expected a snapshot", e.getMessage());
2399         }
2400     }
2401 
2402     @Test
2403     public void testUpdateReleaseInvalidDefaultReleaseVersionNonInteractive() {
2404         // prepare
2405         MapReleaseVersionsPhase phase =
2406                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2407 
2408         List<MavenProject> reactorProjects = Collections.singletonList(createProject("bar", "1.11-SNAPSHOT"));
2409 
2410         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2411         builder.setDefaultReleaseVersion("3.0-SNAPSHOT");
2412         builder.setInteractive(false);
2413 
2414         // test
2415         try {
2416             phase.execute(
2417                     ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2418             fail("Should fail due to invalid version");
2419         } catch (ReleaseExecutionException e) {
2420             assertEquals("3.0-SNAPSHOT is invalid, expected a non-snapshot", e.getMessage());
2421         }
2422     }
2423 
2424     @Test
2425     public void testUpdateDevelopmentInvalidDefaultDevelopmentVersionNonInteractive() {
2426         // prepare
2427         MapDevelopmentVersionsPhase phase =
2428                 new MapDevelopmentVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2429 
2430         List<MavenProject> reactorProjects = Collections.singletonList(createProject("bar", "1.11-SNAPSHOT"));
2431 
2432         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2433         builder.setDefaultDevelopmentVersion("3.0");
2434         builder.setInteractive(false);
2435 
2436         // test
2437         try {
2438             phase.execute(
2439                     ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2440             fail("Should fail due to invalid version");
2441         } catch (ReleaseExecutionException e) {
2442             assertEquals("3.0 is invalid, expected a snapshot", e.getMessage());
2443         }
2444     }
2445 
2446     @Test
2447     public void testSimulateReleaseCheckModificationExcludes() throws Exception {
2448         // verify
2449         MapReleaseVersionsPhase phase =
2450                 new MapReleaseVersionsPhase(scmRepositoryConfigurator, mockPrompter, versionPolicies);
2451 
2452         List<MavenProject> reactorProjects = new ArrayList<>();
2453         Collections.addAll(
2454                 reactorProjects,
2455                 createProject("bar", "1.11-SNAPSHOT"),
2456                 createProjectWithPomFile(
2457                         "artifactId", "1.2-SNAPSHOT", "src/test/resources/projects/scm-commit/multiple-poms/pom.xml"),
2458                 createProjectWithPomFile(
2459                         "subproject1",
2460                         "2.0",
2461                         "src/test/resources/projects/scm-commit/multiple-poms/subproject1/pom.xml"));
2462 
2463         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
2464         builder.setCheckModificationExcludes(Collections.singletonList("**/subproject1/pom.xml"));
2465         builder.setInteractive(false);
2466 
2467         // test
2468         phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
2469 
2470         // verify
2471         assertEquals(
2472                 "Check release versions",
2473                 "1.2",
2474                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:artifactId"));
2475         assertNull(
2476                 "Check development versions",
2477                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:artifactId"));
2478 
2479         assertEquals(
2480                 "Check release versions",
2481                 "1.11",
2482                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:bar"));
2483         assertNull(
2484                 "Check development versions",
2485                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:bar"));
2486 
2487         assertNull(
2488                 "Check release versions",
2489                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectReleaseVersion("groupId:subproject1"));
2490         assertNull(
2491                 "Check development versions",
2492                 ReleaseUtils.buildReleaseDescriptor(builder).getProjectDevelopmentVersion("groupId:subproject1"));
2493     }
2494 
2495     private static MavenProject createProject(String artifactId, String version) {
2496         Model model = new Model();
2497         model.setGroupId("groupId");
2498         model.setArtifactId(artifactId);
2499         model.setVersion(version);
2500         MavenProject mavenProject = new MavenProject(model);
2501         mavenProject.setOriginalModel(model);
2502         return mavenProject;
2503     }
2504 
2505     private static MavenProject createProjectWithPomFile(String artifactId, String version, String pathName) {
2506         Model model = new Model();
2507         model.setGroupId("groupId");
2508         model.setArtifactId(artifactId);
2509         model.setVersion(version);
2510         MavenProject mavenProject = new MavenProject(model);
2511         mavenProject.setFile(new File(pathName));
2512         return mavenProject;
2513     }
2514 }