1 package org.apache.maven.plugin.surefire;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.apache.maven.artifact.Artifact;
23 import org.apache.maven.artifact.DefaultArtifact;
24 import org.apache.maven.artifact.factory.ArtifactFactory;
25 import org.apache.maven.artifact.resolver.ArtifactResolutionRequest;
26 import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
27 import org.apache.maven.artifact.versioning.InvalidVersionSpecificationException;
28 import org.apache.maven.artifact.versioning.VersionRange;
29 import org.apache.maven.model.Dependency;
30 import org.apache.maven.plugin.surefire.log.api.ConsoleLogger;
31 import org.apache.maven.repository.RepositorySystem;
32 import org.junit.Rule;
33 import org.junit.Test;
34 import org.junit.rules.ExpectedException;
35 import org.mockito.invocation.InvocationOnMock;
36 import org.mockito.stubbing.Answer;
37
38 import java.io.File;
39 import java.util.HashMap;
40 import java.util.HashSet;
41 import java.util.Iterator;
42 import java.util.LinkedHashSet;
43 import java.util.Map;
44 import java.util.Set;
45
46 import static java.util.Arrays.asList;
47 import static java.util.Collections.singleton;
48 import static org.apache.maven.artifact.versioning.VersionRange.createFromVersion;
49 import static org.apache.maven.artifact.versioning.VersionRange.createFromVersionSpec;
50 import static org.apache.maven.plugin.surefire.SurefireDependencyResolver.PROVIDER_GROUP_ID;
51 import static org.fest.assertions.Assertions.assertThat;
52 import static org.mockito.Mockito.any;
53 import static org.mockito.Mockito.eq;
54 import static org.mockito.Mockito.isNull;
55 import static org.mockito.Mockito.mock;
56 import static org.mockito.Mockito.when;
57 import static org.powermock.reflect.Whitebox.invokeMethod;
58
59
60
61
62 public class SurefireDependencyResolverTest
63 {
64 @Rule
65 public final ExpectedException expectedException = ExpectedException.none();
66
67 @Test
68 public void shouldNotBeWithinRangeNullArtifact()
69 {
70 boolean result = SurefireDependencyResolver.isWithinVersionSpec( null, "[4.7,)" );
71 assertThat( result )
72 .isFalse();
73 }
74
75 @Test
76 public void shouldNotBeWithinRange() throws InvalidVersionSpecificationException
77 {
78 Artifact api = createArtifact( "junit", "junit", "4.6" );
79 boolean result = SurefireDependencyResolver.isWithinVersionSpec( api, "[4.7,)" );
80 assertThat( result )
81 .isFalse();
82 }
83
84 @Test
85 public void shouldBeWithinRange() throws InvalidVersionSpecificationException
86 {
87 Artifact api = createArtifact( "junit", "junit", "4.7" );
88 boolean result = SurefireDependencyResolver.isWithinVersionSpec( api, "[4.7,)" );
89 assertThat( result )
90 .isTrue();
91 }
92
93 @Test
94 public void shouldBeFarWithinRange() throws InvalidVersionSpecificationException
95 {
96 Artifact api = createArtifact( "junit", "junit", "4.13" );
97 boolean result = SurefireDependencyResolver.isWithinVersionSpec( api, "[4.7,)" );
98 assertThat( result )
99 .isTrue();
100 }
101
102 @Test
103 public void shouldBeFailWithinRange() throws InvalidVersionSpecificationException
104 {
105 Artifact api = createArtifact( "junit", "junit", "" );
106 expectedException.expect( RuntimeException.class );
107 expectedException.expectMessage( "Bug in plugin. Please report with stacktrace" );
108 SurefireDependencyResolver.isWithinVersionSpec( api, "[4.7,)" );
109 }
110
111 @Test
112 public void testResolveArtifact() throws InvalidVersionSpecificationException
113 {
114 final Artifact provider = createArtifact( "surefire-junit-platform" );
115 RepositorySystem repositorySystem = mock( RepositorySystem.class );
116 final ArtifactResolutionResult expectedResult = mock( ArtifactResolutionResult.class );
117 when( repositorySystem.resolve( any( ArtifactResolutionRequest.class ) ) )
118 .then( new Answer<ArtifactResolutionResult>()
119 {
120 @Override
121 public ArtifactResolutionResult answer( InvocationOnMock invocation )
122 {
123 Object[] args = invocation.getArguments();
124 assertThat( args )
125 .hasSize( 1 );
126 ArtifactResolutionRequest request = (ArtifactResolutionRequest) args[0];
127 assertThat( request.getArtifact() )
128 .isSameAs( provider );
129 assertThat( request.isResolveTransitively() )
130 .isTrue();
131 assertThat( request.getArtifactDependencies() )
132 .isNull();
133 assertThat( request.getRemoteRepositories() )
134 .isNull();
135 assertThat( request.getLocalRepository() )
136 .isNull();
137 assertThat( request.getCache() )
138 .isNull();
139 assertThat( request.getCollectionFilter() )
140 .isNull();
141 assertThat( request.getManagedVersionMap() )
142 .isNull();
143 assertThat( request.getMirrors() )
144 .isEmpty();
145 assertThat( request.getProxies() )
146 .isEmpty();
147 assertThat( request.getResolutionFilter() )
148 .isNull();
149 assertThat( request.getServers() )
150 .isEmpty();
151 return expectedResult;
152 }
153 } );
154
155 SurefireDependencyResolver surefireDependencyResolver =
156 new SurefireDependencyResolver( repositorySystem, null, null, null, null, null, null );
157
158 ArtifactResolutionResult actualResult = surefireDependencyResolver.resolvePluginArtifact( provider );
159
160 assertThat( actualResult )
161 .isSameAs( expectedResult );
162 }
163
164 @Test
165 public void testGetProviderClasspath() throws Exception
166 {
167 Artifact api = createArtifact( "surefire-api" );
168 api.setFile( new File( "" ) );
169
170 final Artifact provider = createArtifact( "surefire-junit-platform" );
171 provider.setFile( new File( "" ) );
172
173 Artifact ext = createArtifact( "org.apiguardian", "apiguardian-api" );
174 ext.setFile( new File( "" ) );
175
176 Artifact logger = createArtifact( "surefire-logger-api" );
177 logger.setFile( new File( "" ) );
178
179 Set<Artifact> providerArtifacts = new LinkedHashSet<>();
180 providerArtifacts.add( api );
181 providerArtifacts.add( provider );
182 providerArtifacts.add( ext );
183 providerArtifacts.add( logger );
184
185 final String providerVersion = "5.3.1";
186
187 final ArtifactResolutionResult result = mock( ArtifactResolutionResult.class );
188 when( result.getArtifacts() )
189 .thenReturn( providerArtifacts );
190
191 RepositorySystem repositorySystem = mock( RepositorySystem.class );
192 when( repositorySystem.resolve( any( ArtifactResolutionRequest.class ) ) )
193 .then( new Answer<ArtifactResolutionResult>()
194 {
195 @Override
196 public ArtifactResolutionResult answer( InvocationOnMock invocation )
197 {
198 Object[] args = invocation.getArguments();
199 assertThat( args )
200 .hasSize( 1 );
201 ArtifactResolutionRequest request = (ArtifactResolutionRequest) args[0];
202 assertThat( request.getArtifact() )
203 .isSameAs( provider );
204 assertThat( request.isResolveTransitively() )
205 .isTrue();
206 assertThat( request.getArtifactDependencies() )
207 .isNull();
208 assertThat( request.getRemoteRepositories() )
209 .isNull();
210 assertThat( request.getLocalRepository() )
211 .isNull();
212 assertThat( request.getCache() )
213 .isNull();
214 assertThat( request.getCollectionFilter() )
215 .isNull();
216 assertThat( request.getManagedVersionMap() )
217 .isNull();
218 assertThat( request.getMirrors() )
219 .isEmpty();
220 assertThat( request.getProxies() )
221 .isEmpty();
222 assertThat( request.getResolutionFilter() )
223 .isNull();
224 assertThat( request.getServers() )
225 .isEmpty();
226 return result;
227 }
228 } );
229 when( repositorySystem.createDependencyArtifact( any( Dependency.class ) ) )
230 .then( new Answer<Artifact>()
231 {
232 @Override
233 public Artifact answer( InvocationOnMock invocation )
234 {
235 Object[] args = invocation.getArguments();
236 assertThat( args )
237 .hasSize( 1 );
238 Dependency request = (Dependency) args[0];
239 assertThat( request.getGroupId() )
240 .isEqualTo( "org.apache.maven.surefire" );
241 assertThat( request.getArtifactId() )
242 .isEqualTo( "surefire-junit-platform" );
243 assertThat( request.getVersion() )
244 .isEqualTo( providerVersion );
245 assertThat( request.getType() )
246 .isEqualTo( "jar" );
247 assertThat( request.getScope() )
248 .isEqualTo( "test" );
249 return provider;
250 }
251 } );
252
253 ConsoleLogger log = mock( ConsoleLogger.class );
254
255 SurefireDependencyResolver surefireDependencyResolver =
256 new SurefireDependencyResolver( repositorySystem, log, null, null, null, null, null );
257
258 when( log.isDebugEnabled() )
259 .thenReturn( true );
260
261 Set<Artifact> classpath = surefireDependencyResolver.getProviderClasspath( "surefire-junit-platform", "5.3.1" );
262
263 assertThat( classpath )
264 .hasSize( 4 );
265
266 Iterator<Artifact> it = classpath.iterator();
267
268 assertThat( it.next() )
269 .isSameAs( provider );
270
271 assertThat( it.next() )
272 .isSameAs( api );
273
274 assertThat( it.next() )
275 .isSameAs( logger );
276
277 assertThat( it.next() )
278 .isSameAs( ext );
279 }
280
281 @Test
282 public void testAddProviderToClasspath() throws Exception
283 {
284 final Artifact plugin = createArtifact( "maven-surefire-plugin" );
285 final Artifact common = createArtifact( "maven-surefire-common" );
286 final Artifact api = createArtifact( "surefire-api" );
287 final Artifact provider = createArtifact( "surefire-junit-platform" );
288 final Artifact ext = createArtifact( "org.apiguardian", "apiguardian-api" );
289 final Artifact logger = createArtifact( "surefire-logger-api" );
290
291 Set<Artifact> pluginArtifacts = new LinkedHashSet<>();
292 pluginArtifacts.add( plugin );
293 pluginArtifacts.add( common );
294 pluginArtifacts.add( api );
295 pluginArtifacts.add( logger );
296
297 ArtifactFactory artifactFactory = mock( ArtifactFactory.class );
298 VersionRange pluginVersion = createFromVersion( "3.0.0" );
299 when( artifactFactory.createDependencyArtifact( eq( "org.apache.maven.surefire" ),
300 eq( "maven-surefire-plugin" ),
301 eq( pluginVersion ),
302 eq( "jar" ),
303 isNull( String.class ),
304 eq( "compile" ) ) )
305 .thenReturn( plugin );
306
307 final ArtifactResolutionResult pluginResult = mock( ArtifactResolutionResult.class );
308 when( pluginResult.getArtifacts() )
309 .thenReturn( pluginArtifacts );
310
311 final ArtifactResolutionResult apiResult = mock( ArtifactResolutionResult.class );
312 when( apiResult.getArtifacts() )
313 .thenReturn( singleton( api ) );
314
315 final ArtifactResolutionResult loggerResult = mock( ArtifactResolutionResult.class );
316 when( loggerResult.getArtifacts() )
317 .thenReturn( singleton( logger ) );
318
319 final ArtifactResolutionResult extResult = mock( ArtifactResolutionResult.class );
320 when( extResult.getArtifacts() )
321 .thenReturn( singleton( ext ) );
322
323 final ArtifactResolutionResult providerResult = mock( ArtifactResolutionResult.class );
324 when( providerResult.getArtifacts() )
325 .thenReturn( new HashSet<>( asList( provider, api, logger, ext ) ) );
326
327 RepositorySystem repositorySystem = mock( RepositorySystem.class );
328 when( repositorySystem.resolve( any( ArtifactResolutionRequest.class ) ) )
329 .then( new Answer<ArtifactResolutionResult>()
330 {
331 @Override
332 public ArtifactResolutionResult answer( InvocationOnMock invocation )
333 {
334 Object[] args = invocation.getArguments();
335 assertThat( args ).hasSize( 1 );
336 ArtifactResolutionRequest request = (ArtifactResolutionRequest) args[0];
337 Artifact artifactToResolve = request.getArtifact();
338 if ( artifactToResolve == plugin )
339 {
340 return pluginResult;
341 }
342 else if ( artifactToResolve == provider )
343 {
344 return providerResult;
345 }
346 else if ( artifactToResolve == api )
347 {
348 return apiResult;
349 }
350 else if ( artifactToResolve == logger )
351 {
352 return loggerResult;
353 }
354 else if ( artifactToResolve == ext )
355 {
356 return extResult;
357 }
358 throw new AssertionError( "what artifact are we going to resolve? " + artifactToResolve );
359 }
360 } );
361
362 SurefireDependencyResolver surefireDependencyResolver =
363 new SurefireDependencyResolver( repositorySystem, null, null, null, null, null, null );
364
365 Map<String, Artifact> pluginArtifactsMapping = new HashMap<>();
366 pluginArtifactsMapping.put( plugin.getGroupId() + ":" + plugin.getArtifactId(), plugin );
367 pluginArtifactsMapping.put( common.getGroupId() + ":" + common.getArtifactId(), common );
368 pluginArtifactsMapping.put( api.getGroupId() + ":" + api.getArtifactId(), api );
369 pluginArtifactsMapping.put( logger.getGroupId() + ":" + logger.getArtifactId(), logger );
370 pluginArtifactsMapping.put( provider.getGroupId() + ":" + provider.getArtifactId(), provider );
371 pluginArtifactsMapping.put( ext.getGroupId() + ":" + ext.getArtifactId(), ext );
372
373 Set<Artifact> cp =
374 surefireDependencyResolver.addProviderToClasspath( pluginArtifactsMapping, plugin, api, logger );
375
376 assertThat( cp )
377 .hasSize( 4 )
378 .containsOnly( provider, api, logger, ext );
379 }
380
381 @Test
382 public void shouldOrderedProviderArtifacts() throws Exception
383 {
384 Artifact api = createArtifact( "surefire-api" );
385 Artifact provider = createArtifact( "surefire-junit-platform" );
386 Artifact ext = createArtifact( "org.apiguardian", "apiguardian-api" );
387 Artifact logger = createArtifact( "surefire-logger-api" );
388
389 Set<Artifact> providerArtifacts = new LinkedHashSet<>();
390 providerArtifacts.add( api );
391 providerArtifacts.add( provider );
392 providerArtifacts.add( ext );
393 providerArtifacts.add( logger );
394
395 Iterator<Artifact> it = providerArtifacts.iterator();
396
397 assertThat( it.next() )
398 .isEqualTo( api );
399
400 assertThat( it.next() )
401 .isEqualTo( provider );
402
403 assertThat( it.next() )
404 .isEqualTo( ext );
405
406 assertThat( it.next() )
407 .isEqualTo( logger );
408
409 Set<Artifact> actual =
410 invokeMethod( SurefireDependencyResolver.class, "orderProviderArtifacts", providerArtifacts );
411
412 Set<Artifact> expected = new LinkedHashSet<>();
413 expected.add( provider );
414 expected.add( api );
415 expected.add( logger );
416 expected.add( ext );
417
418 assertThat( actual )
419 .isEqualTo( expected );
420 }
421
422 private static Artifact createArtifact( String artifactId ) throws InvalidVersionSpecificationException
423 {
424 return createArtifact( PROVIDER_GROUP_ID, artifactId );
425 }
426
427
428 private static Artifact createArtifact( String groupId, String artifactId )
429 throws InvalidVersionSpecificationException
430 {
431 return createArtifact( groupId, artifactId, "1" );
432 }
433
434 private static Artifact createArtifact( String groupId, String artifactId, String version )
435 throws InvalidVersionSpecificationException
436 {
437 VersionRange versionSpec = createFromVersionSpec( version );
438 return new DefaultArtifact( groupId, artifactId, versionSpec, "compile", "jar", "", null );
439 }
440 }