1 package org.apache.maven.shared.io.location;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
127 fail( "This should NEVER happen. It's a mock!" );
128 }
129 catch ( ArtifactNotFoundException e )
130 {
131
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
171 fail( "This should NEVER happen. It's a mock!" );
172 }
173 catch ( ArtifactNotFoundException e )
174 {
175
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
215 fail( "This should NEVER happen. It's a mock!" );
216 }
217 catch ( ArtifactNotFoundException e )
218 {
219
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
260 fail( "This should NEVER happen. It's a mock!" );
261 }
262 catch ( ArtifactNotFoundException e )
263 {
264
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
305 fail( "This should NEVER happen. It's a mock!" );
306 }
307 catch ( ArtifactNotFoundException e )
308 {
309
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
350 fail( "This should NEVER happen. It's a mock!" );
351 }
352 catch ( ArtifactNotFoundException e )
353 {
354
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
393 fail( "This should NEVER happen. It's a mock!" );
394 }
395 catch ( ArtifactNotFoundException e )
396 {
397
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
437 fail( "This should NEVER happen. It's a mock!" );
438 }
439 catch ( ArtifactNotFoundException e )
440 {
441
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
483 fail( "This should NEVER happen. It's a mock!" );
484 }
485 catch ( ArtifactNotFoundException e )
486 {
487
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 }