1 package org.apache.maven.shared.release.phase;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.mockito.Matchers.eq;
23 import static org.mockito.Matchers.isA;
24 import static org.mockito.Matchers.startsWith;
25 import static org.mockito.Mockito.mock;
26 import static org.mockito.Mockito.times;
27 import static org.mockito.Mockito.verify;
28 import static org.mockito.Mockito.verifyNoMoreInteractions;
29 import static org.mockito.Mockito.when;
30
31 import java.util.Collections;
32 import java.util.List;
33
34 import org.apache.maven.model.Model;
35 import org.apache.maven.project.MavenProject;
36 import org.apache.maven.shared.release.ReleaseExecutionException;
37 import org.apache.maven.shared.release.config.ReleaseDescriptor;
38 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
39 import org.apache.maven.shared.release.versions.VersionParseException;
40 import org.codehaus.plexus.PlexusTestCase;
41 import org.codehaus.plexus.components.interactivity.Prompter;
42 import org.codehaus.plexus.components.interactivity.PrompterException;
43
44
45
46
47
48
49 public class MapVersionsPhaseTest
50 extends PlexusTestCase
51 {
52 public void testMapReleaseVersionsInteractive()
53 throws Exception
54 {
55
56 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
57 MavenProject project = createProject( "artifactId", "1.0-SNAPSHOT" );
58
59 Prompter mockPrompter = mock( Prompter.class );
60 when( mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) ) ).thenReturn( "2.0" );
61 phase.setPrompter( mockPrompter );
62
63 List<MavenProject> reactorProjects = Collections.singletonList( project );
64
65 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
66
67
68 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
69
70
71 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
72 releaseDescriptor.getReleaseVersions() );
73
74
75 releaseDescriptor = new ReleaseDescriptor();
76
77
78 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
79
80
81 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
82 releaseDescriptor.getReleaseVersions() );
83 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) );
84 verifyNoMoreInteractions( mockPrompter );
85 }
86
87
88 public void testMapReleaseVersionsInteractiveAddZeroIncremental()
89 throws Exception
90 {
91
92 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
93 MavenProject project = createProject( "artifactId", "1.0-SNAPSHOT" );
94
95 Prompter mockPrompter = mock( Prompter.class );
96 when(
97 mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
98 eq( "1.0" ) ) ).thenReturn( "1.0.0" );
99 phase.setPrompter( mockPrompter );
100
101 List<MavenProject> reactorProjects = Collections.singletonList( project );
102
103 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
104
105
106 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
107
108
109 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
110 releaseDescriptor.getReleaseVersions() );
111
112
113 releaseDescriptor = new ReleaseDescriptor();
114
115
116 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
117
118
119 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
120 releaseDescriptor.getReleaseVersions() );
121 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName()
122 + "\"?" ), eq( "1.0" ) );
123 verifyNoMoreInteractions( mockPrompter );
124 }
125
126
127
128
129
130 public void testMapReleaseVersionsInteractiveWithSnaphotVersion()
131 throws Exception
132 {
133
134 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
135 MavenProject project = createProject( "artifactId", "SNAPSHOT" );
136
137 Prompter mockPrompter = mock( Prompter.class );
138 when( mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) ) ).thenReturn( "2.0" );
139 phase.setPrompter( mockPrompter );
140
141 List<MavenProject> reactorProjects = Collections.singletonList( project );
142
143 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
144
145
146 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
147
148
149 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
150 releaseDescriptor.getReleaseVersions() );
151
152
153 releaseDescriptor = new ReleaseDescriptor();
154
155
156 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
157
158
159 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
160 releaseDescriptor.getReleaseVersions() );
161
162 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) );
163 verifyNoMoreInteractions( mockPrompter );
164 }
165
166
167
168
169 public void testMapReleaseVersionsNonInteractiveWithExplicitVersion()
170 throws Exception
171 {
172
173 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "SNAPSHOT" ) );
174
175 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
176
177 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
178 releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
179
180 Prompter mockPrompter = mock( Prompter.class );
181 phase.setPrompter( mockPrompter );
182
183
184 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
185
186
187 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
188 releaseDescriptor.getReleaseVersions() );
189
190
191 releaseDescriptor = new ReleaseDescriptor();
192 releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
193
194
195 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
196
197
198 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
199 releaseDescriptor.getReleaseVersions() );
200
201
202 verifyNoMoreInteractions( mockPrompter );
203 }
204
205 public void testMapReleaseVersionsNonInteractive()
206 throws Exception
207 {
208
209 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
210
211 Prompter mockPrompter = mock( Prompter.class );
212 phase.setPrompter( mockPrompter );
213
214 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
215
216 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
217 releaseDescriptor.setInteractive( false );
218
219
220 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
221
222
223 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
224 releaseDescriptor.getReleaseVersions() );
225
226 releaseDescriptor = new ReleaseDescriptor();
227 releaseDescriptor.setInteractive( false );
228
229
230 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
231
232
233 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
234 releaseDescriptor.getReleaseVersions() );
235
236
237 verifyNoMoreInteractions( mockPrompter );
238 }
239
240 public void testMapDevVersionsInteractive()
241 throws Exception
242 {
243
244 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
245 MavenProject project = createProject( "artifactId", "1.0" );
246
247 Prompter mockPrompter = mock( Prompter.class );
248 when( mockPrompter.prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
249 phase.setPrompter( mockPrompter );
250
251 List<MavenProject> reactorProjects = Collections.singletonList( project );
252
253 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
254
255
256 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
257
258
259 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
260 releaseDescriptor.getDevelopmentVersions() );
261
262
263 releaseDescriptor = new ReleaseDescriptor();
264
265
266 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
267
268
269 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
270 releaseDescriptor.getDevelopmentVersions() );
271
272 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
273 verifyNoMoreInteractions( mockPrompter );
274 }
275
276
277
278
279 public void testMapDevVersionsInteractiveDoNotUpdateWorkingCopy()
280 throws Exception
281 {
282
283 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
284 MavenProject project = createProject( "artifactId", "1.0" );
285
286 Prompter mockPrompter = mock( Prompter.class );
287 phase.setPrompter( mockPrompter );
288
289 List<MavenProject> reactorProjects = Collections.singletonList( project );
290
291 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
292 releaseDescriptor.setUpdateWorkingCopyVersions( false );
293
294
295 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
296
297
298 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
299 releaseDescriptor.getDevelopmentVersions() );
300
301
302 releaseDescriptor = new ReleaseDescriptor();
303 releaseDescriptor.setUpdateWorkingCopyVersions( false );
304
305
306 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
307
308
309 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
310 releaseDescriptor.getDevelopmentVersions() );
311
312 verifyNoMoreInteractions( mockPrompter );
313 }
314
315 public void testMapDevVersionsNonInteractive()
316 throws Exception
317 {
318
319 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
320
321 Prompter mockPrompter = mock( Prompter.class );
322 phase.setPrompter( mockPrompter );
323
324 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
325
326 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
327 releaseDescriptor.setInteractive( false );
328
329
330 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
331
332
333 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
334 releaseDescriptor.getDevelopmentVersions() );
335
336
337 releaseDescriptor = new ReleaseDescriptor();
338 releaseDescriptor.setInteractive( false );
339
340
341 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
342
343
344 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
345 releaseDescriptor.getDevelopmentVersions() );
346
347
348 verifyNoMoreInteractions( mockPrompter );
349 }
350
351
352
353
354 public void testMapDevVersionsNonInteractiveWithExplicitVersion()
355 throws Exception
356 {
357
358 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
359 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
360
361 Prompter mockPrompter = mock( Prompter.class );
362 phase.setPrompter( mockPrompter );
363
364 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
365 releaseDescriptor.setInteractive( false );
366 releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
367
368
369 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
370
371
372 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
373 releaseDescriptor.getDevelopmentVersions() );
374
375
376 releaseDescriptor = new ReleaseDescriptor();
377 releaseDescriptor.setInteractive( false );
378 releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
379
380
381 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
382
383
384 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
385 releaseDescriptor.getDevelopmentVersions() );
386
387
388 verifyNoMoreInteractions( mockPrompter );
389 }
390
391 public void testPrompterException()
392 throws Exception
393 {
394
395 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
396
397 Prompter mockPrompter = mock( Prompter.class );
398 when( mockPrompter.prompt( isA( String.class ), isA( String.class ) ) ).thenThrow( new PrompterException( "..." ) );
399 phase.setPrompter( mockPrompter );
400
401 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
402
403 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
404
405
406 try
407 {
408 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
409
410 fail( "Expected an exception" );
411 }
412 catch ( ReleaseExecutionException e )
413 {
414 assertEquals( "check cause", PrompterException.class, e.getCause().getClass() );
415 }
416
417
418 releaseDescriptor = new ReleaseDescriptor();
419
420
421 try
422 {
423 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
424
425 fail( "Expected an exception" );
426 }
427 catch ( ReleaseExecutionException e )
428 {
429 assertEquals( "check cause", PrompterException.class, e.getCause().getClass() );
430 }
431
432
433 verify( mockPrompter, times( 2 ) ).prompt( isA( String.class ), isA( String.class ) );
434 verifyNoMoreInteractions( mockPrompter );
435 }
436
437 public void testAdjustVersionInteractive()
438 throws Exception
439 {
440
441 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
442 MavenProject project = createProject( "artifactId", "foo" );
443
444 Prompter mockPrompter = mock( Prompter.class );
445 when( mockPrompter.prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
446 phase.setPrompter( mockPrompter );
447
448 List<MavenProject> reactorProjects = Collections.singletonList( project );
449
450 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
451
452
453 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
454
455
456 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
457 releaseDescriptor.getDevelopmentVersions() );
458
459
460 releaseDescriptor = new ReleaseDescriptor();
461
462
463 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
464
465
466 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
467 releaseDescriptor.getDevelopmentVersions() );
468 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
469 verifyNoMoreInteractions( mockPrompter );
470 }
471
472 public void testAdjustVersionNonInteractive()
473 throws Exception
474 {
475 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
476
477 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "foo" ) );
478
479 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
480 releaseDescriptor.setInteractive( false );
481
482 try
483 {
484 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
485
486 fail( "Expected an exception" );
487 }
488 catch ( ReleaseExecutionException e )
489 {
490 assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() );
491 }
492
493 releaseDescriptor = new ReleaseDescriptor();
494 releaseDescriptor.setInteractive( false );
495
496 try
497 {
498 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
499
500 fail( "Expected an exception" );
501 }
502 catch ( ReleaseExecutionException e )
503 {
504 assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() );
505 }
506 }
507
508 private static MavenProject createProject( String artifactId, String version )
509 {
510 Model model = new Model();
511 model.setGroupId( "groupId" );
512 model.setArtifactId( artifactId );
513 model.setVersion( version );
514 return new MavenProject( model );
515 }
516
517 }