View Javadoc
1   package org.apache.maven.shared.io.location;
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.Collections;
25  import java.util.List;
26  
27  import junit.framework.TestCase;
28  
29  import org.apache.maven.artifact.Artifact;
30  import org.apache.maven.artifact.factory.ArtifactFactory;
31  import org.apache.maven.artifact.repository.ArtifactRepository;
32  import org.apache.maven.artifact.resolver.ArtifactNotFoundException;
33  import org.apache.maven.artifact.resolver.ArtifactResolutionException;
34  import org.apache.maven.artifact.resolver.ArtifactResolver;
35  import org.apache.maven.shared.io.logging.DefaultMessageHolder;
36  import org.apache.maven.shared.io.logging.MessageHolder;
37  
38  import static org.easymock.EasyMock.*;
39  
40  public class ArtifactLocatorStrategyTest
41      extends TestCase
42  {
43  
44      private ArtifactFactory factory;
45  
46      private ArtifactResolver resolver;
47  
48      private ArtifactRepository localRepository;
49  
50      public void setUp()
51      {
52          factory = createMock( ArtifactFactory.class );
53          resolver = createMock( ArtifactResolver.class );
54          localRepository = createMock( ArtifactRepository.class );
55      }
56  
57      public void testShouldConstructWithoutDefaultArtifactType()
58      {
59          replay( factory, resolver, localRepository );
60  
61          new ArtifactLocatorStrategy( factory, resolver, localRepository, Collections.EMPTY_LIST );
62  
63          verify( factory, resolver, localRepository );
64      }
65  
66      public void testShouldConstructWithDefaultArtifactType()
67      {
68          replay( factory, resolver, localRepository );
69  
70          new ArtifactLocatorStrategy( factory, resolver, localRepository, Collections.EMPTY_LIST, "zip" );
71  
72          verify( factory, resolver, localRepository );
73      }
74  
75      public void testShouldFailToResolveSpecWithOneToken()
76      {
77          replay( factory, resolver, localRepository );
78  
79          LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
80                                                                  Collections.EMPTY_LIST, "zip" );
81          MessageHolder mh = new DefaultMessageHolder();
82  
83          Location location = strategy.resolve( "one-token", mh );
84  
85          assertNull( location );
86          assertEquals( 1, mh.size() );
87  
88          verify( factory, resolver, localRepository );
89      }
90  
91      public void testShouldFailToResolveSpecWithTwoTokens()
92      {
93          replay( factory, resolver, localRepository );
94  
95          LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
96                                                                  Collections.EMPTY_LIST, "zip" );
97          MessageHolder mh = new DefaultMessageHolder();
98  
99          Location location = strategy.resolve( "two:tokens", mh );
100 
101         assertNull( location );
102         assertEquals( 1, mh.size() );
103 
104         verify( factory, resolver, localRepository );
105     }
106 
107     public void testShouldResolveSpecWithThreeTokensUsingDefaultType()
108         throws IOException
109     {
110         File tempFile = File.createTempFile( "artifact-location.", ".temp" );
111         tempFile.deleteOnExit();
112 
113         Artifact artifact = createMock( Artifact.class );
114         
115         expect( artifact.getFile() ).andReturn( tempFile );
116         expect( artifact.getFile() ).andReturn( tempFile );
117         
118         expect( factory.createArtifact( "group", "artifact", "version", null, "jar" ) ).andReturn( artifact );
119 
120         try
121         {
122             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
123         }
124         catch ( ArtifactResolutionException e )
125         {
126             // should never happen
127             fail( "This should NEVER happen. It's a mock!" );
128         }
129         catch ( ArtifactNotFoundException e )
130         {
131             // should never happen
132             fail( "This should NEVER happen. It's a mock!" );
133         }
134 
135         replay( factory, resolver, localRepository, artifact );
136 
137         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
138                                                                 Collections.EMPTY_LIST );
139         MessageHolder mh = new DefaultMessageHolder();
140 
141         Location location = strategy.resolve( "group:artifact:version", mh );
142 
143         assertNotNull( location );
144         assertEquals( 0, mh.size() );
145 
146         assertSame( tempFile, location.getFile() );
147 
148         verify( factory, resolver, localRepository, artifact );
149     }
150 
151     public void testShouldResolveSpecWithThreeTokensUsingCustomizedDefaultType()
152         throws IOException
153     {
154         File tempFile = File.createTempFile( "artifact-location.", ".temp" );
155         tempFile.deleteOnExit();
156 
157         Artifact artifact = createMock( Artifact.class );
158         
159         expect( artifact.getFile() ).andReturn( tempFile );
160         expect( artifact.getFile() ).andReturn( tempFile );
161         
162         expect( factory.createArtifact( "group", "artifact", "version", null, "zip" ) ).andReturn( artifact );
163 
164         try
165         {
166             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
167         }
168         catch ( ArtifactResolutionException e )
169         {
170             // should never happen
171             fail( "This should NEVER happen. It's a mock!" );
172         }
173         catch ( ArtifactNotFoundException e )
174         {
175             // should never happen
176             fail( "This should NEVER happen. It's a mock!" );
177         }
178 
179         replay( factory, resolver, localRepository, artifact );
180 
181         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
182                                                                 Collections.EMPTY_LIST, "zip" );
183         MessageHolder mh = new DefaultMessageHolder();
184 
185         Location location = strategy.resolve( "group:artifact:version", mh );
186 
187         assertNotNull( location );
188         assertEquals( 0, mh.size() );
189 
190         assertSame( tempFile, location.getFile() );
191 
192         verify( factory, resolver, localRepository, artifact );
193     }
194 
195     public void testShouldResolveSpecWithFourTokens()
196         throws IOException
197     {
198         File tempFile = File.createTempFile( "artifact-location.", ".temp" );
199         tempFile.deleteOnExit();
200 
201         Artifact artifact = createMock( Artifact.class );
202         
203         expect( artifact.getFile() ).andReturn( tempFile );
204         expect( artifact.getFile() ).andReturn( tempFile );
205         
206         expect( factory.createArtifact( "group", "artifact", "version", null, "zip" ) ).andReturn( artifact );
207 
208         try
209         {
210             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
211         }
212         catch ( ArtifactResolutionException e )
213         {
214             // should never happen
215             fail( "This should NEVER happen. It's a mock!" );
216         }
217         catch ( ArtifactNotFoundException e )
218         {
219             // should never happen
220             fail( "This should NEVER happen. It's a mock!" );
221         }
222 
223         replay( factory, resolver, localRepository, artifact );
224 
225         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
226                                                                 Collections.EMPTY_LIST );
227         MessageHolder mh = new DefaultMessageHolder();
228 
229         Location location = strategy.resolve( "group:artifact:version:zip", mh );
230 
231         assertNotNull( location );
232         assertEquals( 0, mh.size() );
233 
234         assertSame( tempFile, location.getFile() );
235 
236         verify( factory, resolver, localRepository, artifact );
237     }
238 
239     public void testShouldResolveSpecWithFiveTokens()
240         throws IOException
241     {
242         File tempFile = File.createTempFile( "artifact-location.", ".temp" );
243         tempFile.deleteOnExit();
244 
245         Artifact artifact = createMock( Artifact.class );
246         
247         expect( artifact.getFile() ).andReturn( tempFile );
248         expect( artifact.getFile() ).andReturn( tempFile );
249         
250         expect( factory.createArtifactWithClassifier( "group", "artifact", "version", "zip", "classifier" ) )
251                 .andReturn( artifact );
252 
253         try
254         {
255             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
256         }
257         catch ( ArtifactResolutionException e )
258         {
259             // should never happen
260             fail( "This should NEVER happen. It's a mock!" );
261         }
262         catch ( ArtifactNotFoundException e )
263         {
264             // should never happen
265             fail( "This should NEVER happen. It's a mock!" );
266         }
267 
268         replay( factory, resolver, localRepository, artifact );
269 
270         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
271                                                                 Collections.EMPTY_LIST );
272         MessageHolder mh = new DefaultMessageHolder();
273 
274         Location location = strategy.resolve( "group:artifact:version:zip:classifier", mh );
275 
276         assertNotNull( location );
277         assertEquals( 0, mh.size() );
278 
279         assertSame( tempFile, location.getFile() );
280 
281         verify( factory, resolver, localRepository, artifact );
282     }
283 
284     public void testShouldResolveSpecWithFiveTokensAndEmptyTypeToken()
285         throws IOException
286     {
287         File tempFile = File.createTempFile( "artifact-location.", ".temp" );
288         tempFile.deleteOnExit();
289 
290         Artifact artifact = createMock( Artifact.class );
291         
292         expect( artifact.getFile() ).andReturn( tempFile );
293         expect( artifact.getFile() ).andReturn( tempFile );
294         
295         expect( factory.createArtifactWithClassifier( "group", "artifact", "version", "jar", "classifier" ) )
296                 .andReturn( artifact );
297 
298         try
299         {
300             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
301         }
302         catch ( ArtifactResolutionException e )
303         {
304             // should never happen
305             fail( "This should NEVER happen. It's a mock!" );
306         }
307         catch ( ArtifactNotFoundException e )
308         {
309             // should never happen
310             fail( "This should NEVER happen. It's a mock!" );
311         }
312 
313         replay( factory, resolver, localRepository, artifact );
314 
315         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
316                                                                 Collections.EMPTY_LIST );
317         MessageHolder mh = new DefaultMessageHolder();
318 
319         Location location = strategy.resolve( "group:artifact:version::classifier", mh );
320 
321         assertNotNull( location );
322         assertEquals( 0, mh.size() );
323 
324         assertSame( tempFile, location.getFile() );
325 
326         verify( factory, resolver, localRepository, artifact );
327     }
328 
329     public void testShouldResolveSpecWithMoreThanFiveTokens()
330         throws IOException
331     {
332         File tempFile = File.createTempFile( "artifact-location.", ".temp" );
333         tempFile.deleteOnExit();
334 
335         Artifact artifact = createMock( Artifact.class );
336         
337         expect( artifact.getFile() ).andReturn( tempFile );
338         expect( artifact.getFile() ).andReturn( tempFile );
339         
340         expect( factory.createArtifactWithClassifier( "group", "artifact", "version", "zip", "classifier" ) )
341                 .andReturn( artifact );
342 
343         try
344         {
345             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
346         }
347         catch ( ArtifactResolutionException e )
348         {
349             // should never happen
350             fail( "This should NEVER happen. It's a mock!" );
351         }
352         catch ( ArtifactNotFoundException e )
353         {
354             // should never happen
355             fail( "This should NEVER happen. It's a mock!" );
356         }
357 
358         replay( factory, resolver, localRepository, artifact );
359 
360         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
361                                                                 Collections.EMPTY_LIST );
362         MessageHolder mh = new DefaultMessageHolder();
363 
364         Location location = strategy.resolve( "group:artifact:version:zip:classifier:six:seven", mh );
365 
366         assertNotNull( location );
367         assertEquals( 1, mh.size() );
368 
369         assertTrue( mh.render().indexOf( ":six:seven" ) > -1 );
370 
371         assertSame( tempFile, location.getFile() );
372 
373         verify( factory, resolver, localRepository, artifact );
374     }
375 
376     public void testShouldNotResolveSpecToArtifactWithNullFile()
377         throws IOException
378     {
379         Artifact artifact = createMock( Artifact.class );
380         
381         expect( artifact.getFile() ).andReturn( null );
382         expect( artifact.getId() ).andReturn( "<some-artifact-id>" );
383         
384         expect( factory.createArtifact( "group", "artifact", "version", null, "jar" )).andReturn( artifact );
385 
386         try
387         {
388             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
389         }
390         catch ( ArtifactResolutionException e )
391         {
392             // should never happen
393             fail( "This should NEVER happen. It's a mock!" );
394         }
395         catch ( ArtifactNotFoundException e )
396         {
397             // should never happen
398             fail( "This should NEVER happen. It's a mock!" );
399         }
400 
401         replay( factory, resolver, localRepository, artifact );
402 
403         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
404                                                                 Collections.EMPTY_LIST );
405         MessageHolder mh = new DefaultMessageHolder();
406 
407         Location location = strategy.resolve( "group:artifact:version", mh );
408 
409         assertNull( location );
410         assertEquals( 1, mh.size() );
411 
412         assertTrue( mh.render().indexOf( "<some-artifact-id>" ) > -1 );
413 
414         verify( factory, resolver, localRepository, artifact );
415     }
416 
417     public void testShouldNotResolveWhenArtifactNotFoundExceptionThrown()
418         throws IOException
419     {
420         Artifact artifact = createMock( Artifact.class );
421 
422         expect( artifact.getId() ).andReturn( "<some-artifact-id>" );
423 
424         expect( factory.createArtifact( "group", "artifact", "version", null, "jar" ) ).andReturn( artifact );
425 
426         try
427         {
428             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
429             expectLastCall().andThrow( new ArtifactNotFoundException( "not found", "group", "artifact", "version",
430                                                                                "jar", null, Collections.<ArtifactRepository>emptyList(),
431                                                                                "http://nowhere.com", Collections.<String>emptyList(),
432                                                                                 new NullPointerException() ) );
433         }
434         catch ( ArtifactResolutionException e )
435         {
436             // should never happen
437             fail( "This should NEVER happen. It's a mock!" );
438         }
439         catch ( ArtifactNotFoundException e )
440         {
441             // should never happen
442             fail( "This should NEVER happen. It's a mock!" );
443         }
444 
445         replay( factory, resolver, localRepository, artifact );
446 
447         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
448                                                                 Collections.EMPTY_LIST );
449         MessageHolder mh = new DefaultMessageHolder();
450 
451         Location location = strategy.resolve( "group:artifact:version", mh );
452 
453         assertNull( location );
454         assertEquals( 1, mh.size() );
455 
456         assertTrue( mh.render().indexOf( "<some-artifact-id>" ) > -1 );
457         assertTrue( mh.render().indexOf( "not found" ) > -1 );
458 
459         verify( factory, resolver, localRepository, artifact );
460     }
461 
462     public void testShouldNotResolveWhenArtifactResolutionExceptionThrown()
463         throws IOException
464     {
465         Artifact artifact = createMock( Artifact.class );
466 
467         expect( artifact.getId() ).andReturn( "<some-artifact-id>" );
468 
469         expect( factory.createArtifact( "group", "artifact", "version", null, "jar" ) ).andReturn( artifact );
470 
471         try
472         {
473             resolver.resolve( artifact, Collections.<ArtifactRepository>emptyList(), localRepository );
474             expectLastCall().andThrow( new ArtifactResolutionException( "resolution failed", "group", "artifact",
475                                                                                  "version", "jar", null, Collections.<ArtifactRepository>emptyList(),
476                                                                                  Collections.<String>emptyList(),
477                                                                                  new NullPointerException() ) );
478 
479         }
480         catch ( ArtifactResolutionException e )
481         {
482             // should never happen
483             fail( "This should NEVER happen. It's a mock!" );
484         }
485         catch ( ArtifactNotFoundException e )
486         {
487             // should never happen
488             fail( "This should NEVER happen. It's a mock!" );
489         }
490 
491         replay( factory, resolver, localRepository, artifact );
492 
493         LocatorStrategy strategy = new ArtifactLocatorStrategy( factory, resolver, localRepository,
494                                                                 Collections.EMPTY_LIST );
495         MessageHolder mh = new DefaultMessageHolder();
496 
497         Location location = strategy.resolve( "group:artifact:version", mh );
498 
499         assertNull( location );
500         assertEquals( 1, mh.size() );
501 
502         assertTrue( mh.render().indexOf( "<some-artifact-id>" ) > -1 );
503         assertTrue( mh.render().indexOf( "resolution failed" ) > -1 );
504 
505         verify( factory, resolver, localRepository, artifact );
506     }
507 
508 }