View Javadoc

1   package org.apache.maven.shared.release.config;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import org.apache.maven.shared.release.phase.AbstractReleaseTestCase;
23  import org.apache.maven.shared.release.scm.IdentifiedScm;
24  import org.codehaus.plexus.PlexusTestCase;
25  
26  import java.io.File;
27  import java.io.IOException;
28  
29  /**
30   * Test the properties store.
31   *
32   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
33   */
34  public class PropertiesReleaseDescriptorStoreTest
35      extends PlexusTestCase
36  {
37      private PropertiesReleaseDescriptorStore store;
38  
39      protected void setUp()
40          throws Exception
41      {
42          super.setUp();
43          store = (PropertiesReleaseDescriptorStore) lookup( ReleaseDescriptorStore.ROLE, "properties" );
44      }
45  
46      public void testReadFromFile()
47          throws ReleaseDescriptorStoreException
48      {
49          File file = getTestFile( "target/test-classes/release.properties" );
50  
51          ReleaseDescriptor config = store.read( file );
52  
53          ReleaseDescriptor expected = createExpectedReleaseConfiguration();
54  
55          assertEquals( "check matches", expected, config );
56      }
57  
58      public void testReadFromFileUsingWorkingDirectory()
59          throws Exception
60      {
61          ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
62          releaseDescriptor.setWorkingDirectory( AbstractReleaseTestCase.getPath(  getTestFile( "target/test-classes" ) ) );
63          ReleaseDescriptor config = store.read( releaseDescriptor );
64  
65          ReleaseDescriptor expected = createExpectedReleaseConfiguration();
66          expected.setWorkingDirectory( releaseDescriptor.getWorkingDirectory() );
67  
68          assertEquals( "check matches", expected, config );
69      }
70  
71      public void testReadFromEmptyFile()
72          throws ReleaseDescriptorStoreException
73      {
74          File file = getTestFile( "target/test-classes/empty-release.properties" );
75  
76          ReleaseDescriptor config = store.read( file );
77  
78          assertDefaultReleaseConfiguration( config );
79      }
80  
81      public void testReadMissingFile()
82          throws ReleaseDescriptorStoreException
83      {
84          File file = getTestFile( "target/test-classes/no-release.properties" );
85  
86          ReleaseDescriptor config = store.read( file );
87  
88          assertDefaultReleaseConfiguration( config );
89      }
90  
91      public void testMergeFromEmptyFile()
92          throws ReleaseDescriptorStoreException, IOException
93      {
94          File file = getTestFile( "target/test-classes/empty-release.properties" );
95  
96          ReleaseDescriptor mergeDescriptor = createMergeConfiguration();
97          ReleaseDescriptor config = store.read( mergeDescriptor, file );
98  
99          assertEquals( "Check configurations merged", mergeDescriptor, config );
100     }
101 
102     public void testMergeFromMissingFile()
103         throws ReleaseDescriptorStoreException, IOException
104     {
105         File file = getTestFile( "target/test-classes/no-release.properties" );
106 
107         ReleaseDescriptor mergeDescriptor = createMergeConfiguration();
108         ReleaseDescriptor config = store.read( mergeDescriptor, file );
109 
110         assertEquals( "Check configurations merged", mergeDescriptor, config );
111     }
112 
113     public void testWriteToNewFile()
114         throws ReleaseDescriptorStoreException
115     {
116         File file = getTestFile( "target/test-classes/new-release.properties" );
117         file.delete();
118         assertFalse( "Check file doesn't exist", file.exists() );
119 
120         ReleaseDescriptor config = createReleaseConfigurationForWriting();
121 
122         store.write( config, file );
123 
124         ReleaseDescriptor rereadDescriptor = store.read( file );
125 
126         assertEquals( "compare configuration", config, rereadDescriptor );
127     }
128 
129     public void testWriteToWorkingDirectory()
130         throws Exception
131     {
132         File file = getTestFile( "target/test-classes/new/release.properties" );
133         file.delete();
134         assertFalse( "Check file doesn't exist", file.exists() );
135         file.getParentFile().mkdirs();
136 
137         ReleaseDescriptor config = createReleaseConfigurationForWriting();
138         config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
139 
140         store.write( config );
141 
142         ReleaseDescriptor rereadDescriptor = store.read( file );
143         rereadDescriptor.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
144 
145         assertEquals( "compare configuration", config, rereadDescriptor );
146     }
147 
148     public void testWriteToNewFileRequiredOnly()
149         throws ReleaseDescriptorStoreException
150     {
151         File file = getTestFile( "target/test-classes/new-release.properties" );
152         file.delete();
153         assertFalse( "Check file doesn't exist", file.exists() );
154 
155         ReleaseDescriptor config = new ReleaseDescriptor();
156         config.setCompletedPhase( "completed-phase-write" );
157         config.setScmSourceUrl( "url-write" );
158 
159         store.write( config, file );
160 
161         ReleaseDescriptor rereadDescriptor = store.read( file );
162 
163         assertEquals( "compare configuration", config, rereadDescriptor );
164     }
165 
166     public void testWriteToNewFileDottedIds()
167         throws ReleaseDescriptorStoreException
168     {
169         File file = getTestFile( "target/test-classes/new-release.properties" );
170         file.delete();
171         assertFalse( "Check file doesn't exist", file.exists() );
172 
173         ReleaseDescriptor config = new ReleaseDescriptor();
174         config.setCompletedPhase( "completed-phase-write" );
175         config.setScmSourceUrl( "url-write" );
176 
177         config.mapReleaseVersion( "group.id:artifact.id", "1.1" );
178         config.mapDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" );
179 
180         IdentifiedScm scm = new IdentifiedScm();
181         scm.setId( "id" );
182         scm.setConnection( "connection" );
183         scm.setDeveloperConnection( "devConnection" );
184         scm.setTag( "tag" );
185         scm.setUrl( "url" );
186         config.mapOriginalScmInfo( "group.id:artifact.id", scm );
187 
188         store.write( config, file );
189 
190         ReleaseDescriptor rereadDescriptor = store.read( file );
191 
192         assertEquals( "compare configuration", config, rereadDescriptor );
193     }
194 
195     public void testWriteToNewFileNullMappedScm()
196         throws ReleaseDescriptorStoreException
197     {
198         File file = getTestFile( "target/test-classes/new-release.properties" );
199         file.delete();
200         assertFalse( "Check file doesn't exist", file.exists() );
201 
202         ReleaseDescriptor config = new ReleaseDescriptor();
203         config.setCompletedPhase( "completed-phase-write" );
204         config.setScmSourceUrl( "url-write" );
205 
206         config.mapReleaseVersion( "group.id:artifact.id", "1.1" );
207         config.mapDevelopmentVersion( "group.id:artifact.id", "1.2-SNAPSHOT" );
208 
209         config.mapOriginalScmInfo( "group.id:artifact.id", null );
210 
211         store.write( config, file );
212 
213         ReleaseDescriptor rereadDescriptor = store.read( file );
214 
215         assertNull( "check null scm is mapped correctly",
216                     rereadDescriptor.getOriginalScmInfo().get( "group.id:artifact.id" ) );
217 
218         assertEquals( "compare configuration", config, rereadDescriptor );
219     }
220 
221     public void testOverwriteFile()
222         throws ReleaseDescriptorStoreException
223     {
224         File file = getTestFile( "target/test-classes/rewrite-release.properties" );
225         assertTrue( "Check file already exists", file.exists() );
226 
227         ReleaseDescriptor config = createReleaseConfigurationForWriting();
228 
229         store.write( config, file );
230 
231         ReleaseDescriptor rereadDescriptor = store.read( file );
232 
233         assertEquals( "compare configuration", config, rereadDescriptor );
234     }
235 
236     public void testDeleteFile()
237         throws ReleaseDescriptorStoreException, IOException
238     {
239         File file = getTestFile( "target/test-classes/delete/release.properties" );
240         file.getParentFile().mkdirs();
241         file.createNewFile();
242         assertTrue( "Check file already exists", file.exists() );
243 
244         ReleaseDescriptor config = createReleaseConfigurationForWriting();
245         config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
246 
247         store.delete( config );
248 
249         assertFalse( "Check file already exists", file.exists() );
250     }
251 
252     public void testMissingDeleteFile()
253         throws ReleaseDescriptorStoreException, IOException
254     {
255         File file = getTestFile( "target/test-classes/delete/release.properties" );
256         file.getParentFile().mkdirs();
257         file.delete();
258         assertFalse( "Check file already exists", file.exists() );
259 
260         ReleaseDescriptor config = createReleaseConfigurationForWriting();
261         config.setWorkingDirectory( AbstractReleaseTestCase.getPath( file.getParentFile() ) );
262 
263         store.delete( config );
264 
265         assertFalse( "Check file already exists", file.exists() );
266     }
267 
268     private ReleaseDescriptor createReleaseConfigurationForWriting()
269     {
270         ReleaseDescriptor config = new ReleaseDescriptor();
271         config.setCompletedPhase( "completed-phase-write" );
272         config.setCommitByProject( true );
273         config.setScmSourceUrl( "url-write" );
274         config.setScmId( "id-write" );
275         config.setScmUsername( "username-write" );
276         config.setScmPassword( "password-write" );
277         config.setScmPrivateKey( "private-key-write" );
278         config.setScmPrivateKeyPassPhrase( "passphrase-write" );
279         config.setScmTagBase( "tag-base-write" );
280         config.setScmBranchBase( "branch-base-write" );
281         config.setScmReleaseLabel( "tag-write" );
282         config.setAdditionalArguments( "additional-args-write" );
283         config.setPreparationGoals( "preparation-goals-write" );
284         config.setCompletionGoals( "completion-goals-write" );
285         config.setPomFileName( "pom-file-name-write" );
286 
287         config.mapReleaseVersion( "groupId:artifactId", "1.0" );
288         config.mapDevelopmentVersion( "groupId:artifactId", "1.1-SNAPSHOT" );
289 
290         IdentifiedScm scm = new IdentifiedScm();
291         scm.setId( "id-write" );
292         scm.setConnection( "connection-write" );
293         scm.setDeveloperConnection( "developerConnection-write" );
294         scm.setUrl( "url-write" );
295         scm.setTag( "tag-write" );
296         config.mapOriginalScmInfo( "groupId:artifactId", scm );
297 
298         scm = new IdentifiedScm();
299         scm.setConnection( "connection-write" );
300         // omit optional elements
301         config.mapOriginalScmInfo( "groupId:subproject1", scm );
302 
303         return config;
304     }
305 
306     private static void assertDefaultReleaseConfiguration( ReleaseDescriptor config )
307     {
308         assertNull( "Expected no completedPhase", config.getCompletedPhase() );
309         assertFalse( "Expected no commitPerProject", config.isCommitByProject() );
310         assertNull( "Expected no id", config.getScmId() );
311         assertNull( "Expected no url", config.getScmSourceUrl() );
312         assertNull( "Expected no username", config.getScmUsername() );
313         assertNull( "Expected no password", config.getScmPassword() );
314         assertNull( "Expected no privateKey", config.getScmPrivateKey() );
315         assertNull( "Expected no passphrase", config.getScmPrivateKeyPassPhrase() );
316         assertNull( "Expected no tagBase", config.getScmTagBase() );
317         assertNull( "Expected no tag", config.getScmReleaseLabel() );
318         assertNull( "Expected no additional arguments", config.getAdditionalArguments() );
319         assertNull( "Expected no preparation goals", config.getPreparationGoals() );
320         assertNull( "Expected no completion goals", config.getCompletionGoals() );
321         assertNull( "Expected no pom file name", config.getPomFileName() );
322 
323         assertNull( "Expected no workingDirectory", config.getWorkingDirectory() );
324         assertFalse( "Expected no generateReleasePoms", config.isGenerateReleasePoms() );
325         assertFalse( "Expected no useEditMode", config.isScmUseEditMode() );
326         assertTrue( "Expected default interactive", config.isInteractive() );
327         assertFalse( "Expected no addScema", config.isAddSchema() );
328 
329         assertTrue( "Expected no release version mappings", config.getReleaseVersions().isEmpty() );
330         assertTrue( "Expected no dev version mappings", config.getDevelopmentVersions().isEmpty() );
331         assertTrue( "Expected no scm mappings", config.getOriginalScmInfo().isEmpty() );
332         assertNotNull( "Expected resolved snapshot dependencies map", config.getResolvedSnapshotDependencies() );
333     }
334 
335     public ReleaseDescriptor createMergeConfiguration()
336         throws IOException
337     {
338         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
339 
340         releaseDescriptor.setScmSourceUrl( "scm-url" );
341         releaseDescriptor.setScmUsername( "username" );
342         // Not setting other optional SCM settings for brevity
343         releaseDescriptor.setWorkingDirectory( AbstractReleaseTestCase.getPath( getTestFile( "target/test-working-directory" ) ) );
344         // Not setting non-override setting completedPhase
345 
346         return releaseDescriptor;
347     }
348 
349     private ReleaseDescriptor createExpectedReleaseConfiguration()
350     {
351         ReleaseDescriptor expected = new ReleaseDescriptor();
352         expected.setCompletedPhase( "step1" );
353         expected.setCommitByProject( true );
354         expected.setScmId( "scm-id" );
355         expected.setScmSourceUrl( "scm-url" );
356         expected.setScmUsername( "username" );
357         expected.setScmPassword( "password" );
358         expected.setScmPrivateKey( "private-key" );
359         expected.setScmPrivateKeyPassPhrase( "passphrase" );
360         expected.setScmTagBase( "tagBase" );
361         expected.setScmTagNameFormat( "expectedTagNameFormat" );
362         expected.setScmBranchBase( "branchBase" );
363         expected.setScmReleaseLabel( "tag" );
364         expected.setAdditionalArguments( "additional-arguments" );
365         expected.setPreparationGoals( "preparation-goals" );
366         expected.setCompletionGoals( "completion-goals" );
367         expected.setPomFileName( "pom-file-name" );
368         expected.setWorkingDirectory( null );
369         expected.setGenerateReleasePoms( false );
370         expected.setScmUseEditMode( false );
371         expected.setInteractive( true );
372         expected.setAddSchema( false );
373         expected.mapReleaseVersion( "groupId:artifactId1", "2.0" );
374         expected.mapReleaseVersion( "groupId:artifactId2", "3.0" );
375         expected.mapDevelopmentVersion( "groupId:artifactId1", "2.1-SNAPSHOT" );
376         expected.mapDevelopmentVersion( "groupId:artifactId2", "3.0.1-SNAPSHOT" );
377         IdentifiedScm scm = new IdentifiedScm();
378         scm.setId( "id" );
379         scm.setConnection( "connection" );
380         scm.setDeveloperConnection( "developerConnection" );
381         scm.setUrl( "url" );
382         scm.setTag( "tag" );
383         expected.mapOriginalScmInfo( "groupId:artifactId1", scm );
384         scm = new IdentifiedScm();
385         scm.setId( null );
386         scm.setConnection( "connection2" );
387         scm.setUrl( "url2" );
388         scm.setTag( null );
389         scm.setDeveloperConnection( null );
390         expected.mapOriginalScmInfo( "groupId:artifactId2", scm );
391         expected.mapResolvedSnapshotDependencies( "external:artifactId", "1.0", "1.1-SNAPSHOT" );
392 
393         return expected;
394     }
395 
396 }