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