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.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   * Test release:perform.
48   *
49   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
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          // execute
67          mojo.execute();
68  
69          // verify
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          // execute
93          mojo.execute();
94  
95          // verify
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         // execute
125         mojo.execute();
126 
127         // verify
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         // execute
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         // verify
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         // execute
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         // verify
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         // execute
235         mojo.execute();
236 
237         // verify
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         // execute
271         mojo.execute();
272 
273         // verify
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         // execute
307         mojo.execute();
308 
309         // verify
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         // execute
333         mojo.execute();
334 
335         // verify
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 }