View Javadoc

1   package org.apache.maven.plugin.dependency.utils.markers;
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 java.io.File;
23  import java.io.IOException;
24  import java.util.ArrayList;
25  import java.util.List;
26  import java.util.Random;
27  
28  import junit.framework.TestCase;
29  
30  import org.apache.maven.artifact.Artifact;
31  import org.apache.maven.artifact.DefaultArtifact;
32  import org.apache.maven.artifact.handler.ArtifactHandler;
33  import org.apache.maven.artifact.handler.DefaultArtifactHandler;
34  import org.apache.maven.artifact.versioning.VersionRange;
35  import org.apache.maven.plugin.MojoExecutionException;
36  import org.apache.maven.plugin.dependency.testUtils.stubs.StubSourcesFileMarkerHandler;
37  import org.apache.maven.plugin.logging.Log;
38  import org.apache.maven.plugin.testing.SilentLog;
39  
40  /**
41   * @author brianf
42   * 
43   */
44  public class TestSourcesMarkerFileHandler
45      extends TestCase
46  {
47      List<Artifact> artifacts = new ArrayList<Artifact>();
48  
49      Log log = new SilentLog();
50  
51      File outputFolder;
52  
53      protected void setUp()
54          throws Exception
55      {
56          super.setUp();
57  
58          ArtifactHandler ah = new DefaultArtifactHandler();
59          VersionRange vr = VersionRange.createFromVersion( "1.1" );
60          Artifact artifact = new DefaultArtifact( "test", "1", vr, Artifact.SCOPE_COMPILE, "jar", "", ah, false );
61          artifacts.add( artifact );
62          artifact = new DefaultArtifact( "test", "2", vr, Artifact.SCOPE_PROVIDED, "war", "", ah, false );
63          artifacts.add( artifact );
64          artifact = new DefaultArtifact( "test", "3", vr, Artifact.SCOPE_TEST, "sources", "", ah, false );
65          artifacts.add( artifact );
66          artifact = new DefaultArtifact( "test", "4", vr, Artifact.SCOPE_RUNTIME, "zip", "", ah, false );
67          artifacts.add( artifact );
68  
69          // pick random output location
70          Random a = new Random();
71          outputFolder = new File( "target/markers" + a.nextLong() + "/" );
72          outputFolder.delete();
73          assertFalse( outputFolder.exists() );
74      }
75  
76      protected void tearDown()
77      {
78          outputFolder.delete();
79      }
80  
81      public void testSetMarkerResolved()
82          throws MojoExecutionException
83      {
84          DefaultFileMarkerHandler handler = new SourcesFileMarkerHandler( artifacts.get( 0 ),
85                                                                           this.outputFolder, true );
86          assertFalse( handler.isMarkerSet() );
87          handler.setMarker();
88          assertTrue( handler.isMarkerSet() );
89          handler.clearMarker();
90          assertFalse( handler.isMarkerSet() );
91  
92          handler.setMarker();
93          handler.setMarker();
94          assertTrue( handler.isMarkerSet() );
95  
96          handler.clearMarker();
97          handler.clearMarker();
98          outputFolder.delete();
99          assertFalse( outputFolder.exists() );
100     }
101 
102     public void testSetMarkerUnresolved()
103         throws MojoExecutionException
104     {
105         DefaultFileMarkerHandler handler = new SourcesFileMarkerHandler( artifacts.get( 0 ),
106                                                                          this.outputFolder, false );
107         assertFalse( handler.isMarkerSet() );
108         handler.setMarker();
109         assertTrue( handler.isMarkerSet() );
110         handler.clearMarker();
111         assertFalse( handler.isMarkerSet() );
112 
113         handler.setMarker();
114         handler.setMarker();
115         assertTrue( handler.isMarkerSet() );
116 
117         handler.clearMarker();
118         handler.clearMarker();
119         outputFolder.delete();
120         assertFalse( outputFolder.exists() );
121     }
122 
123     public void testBothMarkers()
124         throws MojoExecutionException
125     {
126         DefaultFileMarkerHandler handler = new SourcesFileMarkerHandler( artifacts.get( 1 ),
127                                                                          this.outputFolder, true );
128         DefaultFileMarkerHandler handler2 = new SourcesFileMarkerHandler( artifacts.get( 1 ),
129                                                                           this.outputFolder, false );
130 
131         handler.setMarker();
132         assertTrue( handler.isMarkerSet() );
133         assertTrue( handler2.isMarkerSet() );
134 
135         handler2.clearMarker();
136         assertFalse( handler.isMarkerSet() );
137         assertFalse( handler2.isMarkerSet() );
138         outputFolder.delete();
139         assertFalse( outputFolder.exists() );
140     }
141 
142     public void testMarkerFile()
143         throws MojoExecutionException, IOException
144     {
145         DefaultFileMarkerHandler handler = new SourcesFileMarkerHandler( artifacts.get( 0 ),
146                                                                          this.outputFolder, true );
147         DefaultFileMarkerHandler handler2 = new SourcesFileMarkerHandler( artifacts.get( 0 ),
148                                                                           this.outputFolder, false );
149 
150         File handle = handler.getMarkerFile();
151         File handle2 = handler2.getMarkerFile();
152         assertFalse( handle.exists() );
153         assertFalse( handler.isMarkerSet() );
154         assertFalse( handle2.exists() );
155         assertFalse( handler2.isMarkerSet() );
156 
157         // if either file exists, the marker is set
158         handler.setMarker();
159         assertTrue( handler.isMarkerSet() );
160         assertTrue( handle.exists() );
161         assertTrue( handler2.isMarkerSet() );
162         assertFalse( handle2.exists() );
163 
164         // if either file exists, the marker is set
165         // setting 1 will clear the other marker
166         handler2.setMarker();
167         assertTrue( handler.isMarkerSet() );
168         assertFalse( handle.exists() );
169         assertTrue( handler2.isMarkerSet() );
170         assertTrue( handle2.exists() );
171 
172         // reset file for next test
173         handle.createNewFile();
174 
175         // only delete one, should be still true
176         handle2.delete();
177         assertTrue( handler.isMarkerSet() );
178         assertTrue( handler2.isMarkerSet() );
179 
180         // delete the 2nd, should be false.
181         handle.delete();
182         assertFalse( handler.isMarkerSet() );
183         assertFalse( handler2.isMarkerSet() );
184 
185         handle.createNewFile();
186         assertTrue( handler.isMarkerSet() );
187         assertTrue( handler2.isMarkerSet() );
188 
189         handler.clearMarker();
190         assertFalse( handle.exists() );
191         handler2.clearMarker();
192         assertFalse( handle2.exists() );
193 
194         handle.delete();
195         handle2.delete();
196 
197         outputFolder.delete();
198         assertFalse( outputFolder.exists() );
199     }
200 
201     public void testMarkerTimeStampResolved()
202         throws MojoExecutionException, IOException, InterruptedException
203     {
204         doTestMarkerTimeStamp( true );
205     }
206 
207     public void testMarkerTimeStampUnResolved()
208         throws MojoExecutionException, IOException, InterruptedException
209     {
210         doTestMarkerTimeStamp( false );
211     }
212 
213     public void doTestMarkerTimeStamp( boolean resolved )
214         throws MojoExecutionException, IOException, InterruptedException
215     {
216         File theFile = new File( outputFolder, "theFile.jar" );
217         outputFolder.mkdirs();
218         theFile.createNewFile();
219         Artifact theArtifact = artifacts.get( 0 );
220         theArtifact.setFile( theFile );
221         SourcesFileMarkerHandler resolvedHandler = new SourcesFileMarkerHandler( artifacts.get( 0 ),
222                                                                                  this.outputFolder, resolved );
223         SourcesFileMarkerHandler unResolvedHandler = new SourcesFileMarkerHandler( artifacts.get( 0 ),
224                                                                                    this.outputFolder, !resolved );
225 
226         assertFalse( resolvedHandler.isMarkerSet() );
227         assertFalse( unResolvedHandler.isMarkerSet() );
228         // if the marker is not set, assume it is infinately older than the
229         // artifact.
230         assertTrue( resolvedHandler.isMarkerOlder( theArtifact ) );
231         assertTrue( unResolvedHandler.isMarkerOlder( theArtifact ) );
232         resolvedHandler.setMarker();
233         assertFalse( resolvedHandler.isMarkerOlder( theArtifact ) );
234         assertFalse( unResolvedHandler.isMarkerOlder( theArtifact ) );
235 
236         resolvedHandler.clearMarker();
237         unResolvedHandler.setMarker();
238         assertFalse( resolvedHandler.isMarkerOlder( theArtifact ) );
239         assertFalse( unResolvedHandler.isMarkerOlder( theArtifact ) );
240 
241         theFile.setLastModified( theFile.lastModified() + 60000 );
242         assertTrue( resolvedHandler.isMarkerOlder( theArtifact ) );
243         assertTrue( unResolvedHandler.isMarkerOlder( theArtifact ) );
244 
245         theFile.delete();
246         resolvedHandler.clearMarker();
247         assertFalse( resolvedHandler.isMarkerSet() );
248     }
249 
250     public void testMarkerFileException()
251     {
252         // this stub wraps the file with an object to throw exceptions
253         StubSourcesFileMarkerHandler handler = new StubSourcesFileMarkerHandler( artifacts.get( 0 ),
254                                                                                  this.outputFolder, true );
255         try
256         {
257             handler.setMarker();
258             fail( "Expected an Exception here" );
259         }
260         catch ( MojoExecutionException e )
261         {
262         }
263     }
264 
265     public void testMarkerFileResolvedSetter()
266     {
267         SourcesFileMarkerHandler handler = new SourcesFileMarkerHandler( null, null, true );
268         assertTrue( handler.isResolved() );
269         handler.setResolved( false );
270         assertFalse( handler.isResolved() );
271     }
272 
273     public void testNullParent()
274         throws MojoExecutionException
275     {
276         // the parent isn't set so this will create the marker in the local
277         // folder. We must clear the
278         // marker to avoid leaving test droppings in root.
279         DefaultFileMarkerHandler handler = new SourcesFileMarkerHandler( null, null, false );
280         handler.setArtifact( artifacts.get( 0 ) );
281         handler.setMarker();
282         assertTrue( handler.isMarkerSet() );
283         handler.clearMarker();
284         assertFalse( handler.isMarkerSet() );
285     }
286 
287     public void testNullParentResolved()
288         throws MojoExecutionException
289     {
290         // the parent isn't set so this will create the marker in the local
291         // folder. We must clear the
292         // marker to avoid leaving test droppings in root.
293         DefaultFileMarkerHandler handler = new SourcesFileMarkerHandler( null, null, true );
294         handler.setArtifact( artifacts.get( 0 ) );
295         handler.setMarker();
296         assertTrue( handler.isMarkerSet() );
297         handler.clearMarker();
298         assertFalse( handler.isMarkerSet() );
299 
300     }
301 }