1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.plugins.release;
20
21 import java.io.File;
22 import java.util.Arrays;
23 import java.util.List;
24
25 import org.apache.maven.execution.MavenSession;
26 import org.apache.maven.model.DistributionManagement;
27 import org.apache.maven.model.Profile;
28 import org.apache.maven.model.Site;
29 import org.apache.maven.plugin.MojoExecutionException;
30 import org.apache.maven.plugin.MojoFailureException;
31 import org.apache.maven.plugin.testing.AbstractMojoTestCase;
32 import org.apache.maven.project.MavenProject;
33 import org.apache.maven.shared.release.ReleaseExecutionException;
34 import org.apache.maven.shared.release.ReleaseFailureException;
35 import org.apache.maven.shared.release.ReleaseManager;
36 import org.apache.maven.shared.release.ReleasePerformRequest;
37 import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
38 import org.mockito.ArgumentCaptor;
39
40 import static org.mockito.Matchers.isA;
41 import static org.mockito.Mockito.doThrow;
42 import static org.mockito.Mockito.mock;
43 import static org.mockito.Mockito.verify;
44 import static org.mockito.Mockito.verifyNoMoreInteractions;
45
46
47
48
49
50
51 public class PerformReleaseMojoTest extends AbstractMojoTestCase {
52 private File workingDirectory;
53
54 public void testPerform() throws Exception {
55 PerformReleaseMojo mojo = getMojoWithProjectSite("perform.xml");
56
57 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
58 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
59 File checkoutDirectory = getTestFile("target/checkout");
60 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
61 builder.setPerformGoals("deploy site-deploy");
62
63 ReleaseManager mock = mock(ReleaseManager.class);
64 mojo.setReleaseManager(mock);
65
66
67 mojo.execute();
68
69
70 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
71 verify(mock).perform(argument.capture());
72 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
73 assertNotNull(argument.getValue().getReleaseEnvironment());
74 assertNotNull(argument.getValue().getReactorProjects());
75 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
76 verifyNoMoreInteractions(mock);
77 }
78
79 public void testPerformWithFlatStructure() throws Exception {
80 PerformReleaseMojo mojo = getMojoWithProjectSite("perform-with-flat-structure.xml");
81
82 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
83 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
84 File checkoutDirectory = getTestFile("target/checkout");
85 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
86 builder.setPerformGoals("deploy");
87 builder.setScmSourceUrl("scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project");
88
89 ReleaseManager mock = mock(ReleaseManager.class);
90 mojo.setReleaseManager(mock);
91
92
93 mojo.execute();
94
95
96 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
97 verify(mock).perform(argument.capture());
98 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
99 assertNotNull(argument.getValue().getReleaseEnvironment());
100 assertNotNull(argument.getValue().getReactorProjects());
101 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
102 verifyNoMoreInteractions(mock);
103 }
104
105 public void testPerformWithoutSite() throws Exception {
106 File testFileDirectory = getTestFile("target/test-classes/mojos/perform/");
107 PerformReleaseMojo mojo =
108 (PerformReleaseMojo) lookupMojo("perform", new File(testFileDirectory, "perform-without-site.xml"));
109 mojo.setBasedir(testFileDirectory);
110 mojo.setPomFileName("pom.xml");
111
112 MavenProject project = (MavenProject) getVariableValueFromObject(mojo, "project");
113 setVariableValueToObject(mojo, "session", newMavenSession(project));
114
115 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
116 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
117 File checkoutDirectory = getTestFile("target/checkout");
118 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
119 builder.setPerformGoals("deploy");
120
121 ReleaseManager mock = mock(ReleaseManager.class);
122 mojo.setReleaseManager(mock);
123
124
125 mojo.execute();
126
127
128 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
129 verify(mock).perform(argument.capture());
130 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
131 assertNotNull(argument.getValue().getReleaseEnvironment());
132 assertNotNull(argument.getValue().getReactorProjects());
133 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
134 verifyNoMoreInteractions(mock);
135 }
136
137 private PerformReleaseMojo getMojoWithProjectSite(String fileName) throws Exception {
138 PerformReleaseMojo mojo = (PerformReleaseMojo) lookupMojo("perform", new File(workingDirectory, fileName));
139 mojo.setBasedir(workingDirectory);
140 mojo.setPomFileName(fileName);
141
142 MavenProject project = (MavenProject) getVariableValueFromObject(mojo, "project");
143 DistributionManagement distributionManagement = new DistributionManagement();
144 distributionManagement.setSite(new Site());
145 project.setDistributionManagement(distributionManagement);
146
147 setVariableValueToObject(mojo, "session", newMavenSession(project));
148
149 return mojo;
150 }
151
152 public void testPerformWithExecutionException() throws Exception {
153 PerformReleaseMojo mojo = getMojoWithProjectSite("perform.xml");
154
155 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
156 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
157 File checkoutDirectory = getTestFile("target/checkout");
158 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
159 builder.setPerformGoals("deploy site-deploy");
160
161 ReleaseManager mock = mock(ReleaseManager.class);
162 doThrow(new ReleaseExecutionException("...")).when(mock).perform(isA(ReleasePerformRequest.class));
163 mojo.setReleaseManager(mock);
164
165
166 try {
167 mojo.execute();
168
169 fail("Should have thrown an exception");
170 } catch (MojoExecutionException e) {
171 assertEquals(
172 "Check cause", ReleaseExecutionException.class, e.getCause().getClass());
173 }
174
175
176 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
177 verify(mock).perform(argument.capture());
178 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
179 assertNotNull(argument.getValue().getReleaseEnvironment());
180 assertNotNull(argument.getValue().getReactorProjects());
181 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
182
183 verifyNoMoreInteractions(mock);
184 }
185
186 public void testPerformWithExecutionFailure() throws Exception {
187 PerformReleaseMojo mojo = getMojoWithProjectSite("perform.xml");
188
189 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
190 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
191 File checkoutDirectory = getTestFile("target/checkout");
192 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
193 builder.setPerformGoals("deploy site-deploy");
194
195 ReleaseManager mock = mock(ReleaseManager.class);
196 ReleaseFailureException cause = new ReleaseFailureException("...");
197 doThrow(cause).when(mock).perform(isA(ReleasePerformRequest.class));
198
199 mojo.setReleaseManager(mock);
200
201
202 try {
203 mojo.execute();
204
205 fail("Should have thrown an exception");
206 } catch (MojoFailureException e) {
207 assertEquals("Check cause exists", cause, e.getCause());
208 }
209
210
211 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
212 verify(mock).perform(argument.capture());
213 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
214 assertNotNull(argument.getValue().getReleaseEnvironment());
215 assertNotNull(argument.getValue().getReactorProjects());
216 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
217
218 verifyNoMoreInteractions(mock);
219 }
220
221 public void testPerformWithScm() throws Exception {
222 PerformReleaseMojo mojo = getMojoWithProjectSite("perform-with-scm.xml");
223
224 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
225 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
226 File checkoutDirectory = getTestFile("target/checkout");
227 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
228 builder.setPerformGoals("deploy site-deploy");
229 builder.setScmSourceUrl("scm-url");
230
231 ReleaseManager mock = mock(ReleaseManager.class);
232 mojo.setReleaseManager(mock);
233
234
235 mojo.execute();
236
237
238 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
239 verify(mock).perform(argument.capture());
240 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
241 assertNotNull(argument.getValue().getReleaseEnvironment());
242 assertNotNull(argument.getValue().getReactorProjects());
243 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
244
245 verifyNoMoreInteractions(mock);
246 }
247
248 public void testPerformWithProfiles() throws Exception {
249 PerformReleaseMojo mojo = getMojoWithProjectSite("perform.xml");
250
251 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
252 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
253 File checkoutDirectory = getTestFile("target/checkout");
254 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
255 builder.setPerformGoals("deploy site-deploy");
256 builder.setAdditionalArguments("-P prof1,2prof");
257
258 MavenSession session = (MavenSession) getVariableValueFromObject(mojo, "session");
259 Profile profile1 = new Profile();
260 profile1.setId("prof1");
261 session.getRequest().addProfile(profile1);
262 Profile profile2 = new Profile();
263 profile2.setId("2prof");
264 session.getRequest().addProfile(profile2);
265 session.getRequest().setActiveProfiles(Arrays.asList("prof1", "2prof"));
266
267 ReleaseManager mock = mock(ReleaseManager.class);
268 mojo.setReleaseManager(mock);
269
270
271 mojo.execute();
272
273
274 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
275 verify(mock).perform(argument.capture());
276 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
277 assertNotNull(argument.getValue().getReleaseEnvironment());
278 assertNotNull(argument.getValue().getReactorProjects());
279 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
280
281 verifyNoMoreInteractions(mock);
282 }
283
284 public void testPerformWithProfilesAndArguments() throws Exception {
285 PerformReleaseMojo mojo = getMojoWithProjectSite("perform-with-args.xml");
286
287 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
288 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
289 File checkoutDirectory = getTestFile("target/checkout");
290 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
291 builder.setPerformGoals("deploy site-deploy");
292 builder.setAdditionalArguments("-Dmaven.test.skip=true -P prof1,2prof");
293
294 MavenSession session = (MavenSession) getVariableValueFromObject(mojo, "session");
295 Profile profile1 = new Profile();
296 profile1.setId("prof1");
297 session.getRequest().addProfile(profile1);
298 Profile profile2 = new Profile();
299 profile2.setId("2prof");
300 session.getRequest().addProfile(profile2);
301 session.getRequest().setActiveProfiles(Arrays.asList("prof1", "2prof"));
302
303 ReleaseManager mock = mock(ReleaseManager.class);
304 mojo.setReleaseManager(mock);
305
306
307 mojo.execute();
308
309
310 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
311 verify(mock).perform(argument.capture());
312 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
313 assertNotNull(argument.getValue().getReleaseEnvironment());
314 assertNotNull(argument.getValue().getReactorProjects());
315 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
316
317 verifyNoMoreInteractions(mock);
318 }
319
320 public void testPerformWithMultilineGoals() throws Exception {
321 PerformReleaseMojo mojo = getMojoWithProjectSite("perform-with-multiline-goals.xml");
322
323 ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder(mojo);
324 builder.setWorkingDirectory(workingDirectory.getAbsolutePath());
325 File checkoutDirectory = getTestFile("target/checkout");
326 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
327 builder.setPerformGoals("deploy site-deploy");
328
329 ReleaseManager mock = mock(ReleaseManager.class);
330 mojo.setReleaseManager(mock);
331
332
333 mojo.execute();
334
335
336 ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
337 verify(mock).perform(argument.capture());
338 assertNotNull(argument.getValue().getReleaseDescriptorBuilder());
339 assertNotNull(argument.getValue().getReleaseEnvironment());
340 assertNotNull(argument.getValue().getReactorProjects());
341 assertEquals(Boolean.FALSE, argument.getValue().getDryRun());
342
343 verifyNoMoreInteractions(mock);
344 }
345
346 private ReleaseDescriptorBuilder createReleaseDescriptorBuilder(PerformReleaseMojo mojo) throws Exception {
347 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
348
349 @SuppressWarnings("unchecked")
350 List<MavenProject> reactorProjects = (List<MavenProject>) getVariableValueFromObject(mojo, "reactorProjects");
351
352 for (MavenProject project : reactorProjects) {
353 builder.putOriginalVersion(project.getGroupId() + ':' + project.getArtifactId(), project.getVersion());
354 }
355
356 return builder;
357 }
358
359 protected void setUp() throws Exception {
360 super.setUp();
361 workingDirectory = getTestFile("target/test-classes/mojos/perform");
362 }
363 }