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