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