1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.plugin.surefire;
20
21 import java.io.File;
22 import java.io.IOException;
23 import java.nio.file.Path;
24 import java.nio.file.Paths;
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.HashMap;
29 import java.util.HashSet;
30 import java.util.LinkedHashMap;
31 import java.util.LinkedHashSet;
32 import java.util.LinkedList;
33 import java.util.List;
34 import java.util.Map;
35 import java.util.Properties;
36 import java.util.Set;
37
38 import org.apache.commons.io.FileUtils;
39 import org.apache.maven.artifact.Artifact;
40 import org.apache.maven.artifact.DefaultArtifact;
41 import org.apache.maven.artifact.handler.ArtifactHandler;
42 import org.apache.maven.artifact.handler.DefaultArtifactHandler;
43 import org.apache.maven.artifact.versioning.VersionRange;
44 import org.apache.maven.execution.MavenSession;
45 import org.apache.maven.model.Dependency;
46 import org.apache.maven.model.Plugin;
47 import org.apache.maven.plugin.MojoFailureException;
48 import org.apache.maven.plugin.descriptor.PluginDescriptor;
49 import org.apache.maven.plugin.surefire.AbstractSurefireMojo.JUnitPlatformProviderInfo;
50 import org.apache.maven.plugin.surefire.booterclient.Platform;
51 import org.apache.maven.plugin.surefire.log.PluginConsoleLogger;
52 import org.apache.maven.project.MavenProject;
53 import org.apache.maven.surefire.api.suite.RunResult;
54 import org.apache.maven.surefire.api.util.DefaultScanResult;
55 import org.apache.maven.surefire.api.util.SureFireFileManager;
56 import org.apache.maven.surefire.booter.ClassLoaderConfiguration;
57 import org.apache.maven.surefire.booter.Classpath;
58 import org.apache.maven.surefire.booter.ModularClasspathConfiguration;
59 import org.apache.maven.surefire.booter.StartupConfiguration;
60 import org.apache.maven.surefire.extensions.ForkNodeFactory;
61 import org.apache.maven.surefire.providerapi.ProviderInfo;
62 import org.apache.maven.toolchain.Toolchain;
63 import org.codehaus.plexus.languages.java.jpms.JavaModuleDescriptor;
64 import org.codehaus.plexus.languages.java.jpms.LocationManager;
65 import org.codehaus.plexus.languages.java.jpms.ResolvePathRequest;
66 import org.codehaus.plexus.languages.java.jpms.ResolvePathResult;
67 import org.codehaus.plexus.languages.java.jpms.ResolvePathsRequest;
68 import org.codehaus.plexus.languages.java.jpms.ResolvePathsResult;
69 import org.codehaus.plexus.logging.Logger;
70 import org.junit.Before;
71 import org.junit.Rule;
72 import org.junit.Test;
73 import org.junit.rules.ExpectedException;
74 import org.junit.rules.TemporaryFolder;
75 import org.junit.runner.RunWith;
76 import org.mockito.ArgumentCaptor;
77 import org.mockito.Mock;
78 import org.powermock.core.classloader.annotations.PowerMockIgnore;
79 import org.powermock.core.classloader.annotations.PrepareForTest;
80 import org.powermock.modules.junit4.PowerMockRunner;
81
82 import static java.io.File.separatorChar;
83 import static java.nio.charset.StandardCharsets.UTF_8;
84 import static java.nio.file.Files.write;
85 import static java.util.Arrays.asList;
86 import static java.util.Collections.emptyList;
87 import static java.util.Collections.emptyMap;
88 import static java.util.Collections.singleton;
89 import static java.util.Collections.singletonList;
90 import static org.apache.maven.artifact.ArtifactUtils.artifactMapByVersionlessId;
91 import static org.apache.maven.artifact.versioning.VersionRange.createFromVersion;
92 import static org.apache.maven.artifact.versioning.VersionRange.createFromVersionSpec;
93 import static org.apache.maven.surefire.shared.lang3.JavaVersion.JAVA_9;
94 import static org.apache.maven.surefire.shared.lang3.JavaVersion.JAVA_RECENT;
95 import static org.apache.maven.surefire.shared.lang3.SystemUtils.IS_OS_WINDOWS;
96 import static org.assertj.core.api.Assertions.assertThat;
97 import static org.codehaus.plexus.languages.java.jpms.ModuleNameSource.MODULEDESCRIPTOR;
98 import static org.mockito.ArgumentMatchers.any;
99 import static org.mockito.ArgumentMatchers.anyString;
100 import static org.mockito.ArgumentMatchers.eq;
101 import static org.mockito.Mockito.times;
102 import static org.mockito.Mockito.verify;
103 import static org.mockito.Mockito.when;
104 import static org.powermock.api.mockito.PowerMockito.doNothing;
105 import static org.powermock.api.mockito.PowerMockito.doReturn;
106 import static org.powermock.api.mockito.PowerMockito.mock;
107 import static org.powermock.api.mockito.PowerMockito.spy;
108 import static org.powermock.api.mockito.PowerMockito.verifyPrivate;
109 import static org.powermock.reflect.Whitebox.invokeMethod;
110 import static org.powermock.reflect.Whitebox.setInternalState;
111
112
113
114
115 @RunWith(PowerMockRunner.class)
116 @PrepareForTest(AbstractSurefireMojo.class)
117 @PowerMockIgnore({"org.jacoco.agent.rt.*", "com.vladium.emma.rt.*"})
118 public class AbstractSurefireMojoTest {
119 @Rule
120 public final ExpectedException e = ExpectedException.none();
121
122 @Rule
123 public final TemporaryFolder tempFolder = new TemporaryFolder();
124
125 @Mock
126 private ArtifactHandler handler;
127
128 private final Mojo mojo = new Mojo();
129
130 @Before
131 public void setupMojo() {
132 Artifact mojoArtifact = mojo.getMojoArtifact();
133
134 mojo.setPluginArtifactMap(new LinkedHashMap<>());
135 mojo.getPluginArtifactMap().put(mojoArtifact.getGroupId() + ":" + mojoArtifact.getArtifactId(), mojoArtifact);
136 Artifact forkedBooter = new DefaultArtifact(
137 "org.apache.maven.surefire",
138 "surefire-booter",
139 mojoArtifact.getVersion(),
140 null,
141 "jar",
142 null,
143 mock(ArtifactHandler.class));
144 mojo.getPluginArtifactMap().put("org.apache.maven.surefire:surefire-booter", forkedBooter);
145
146 mojo.setProjectArtifactMap(new LinkedHashMap<>());
147
148 MavenSession session = mock(MavenSession.class);
149 mojo.setSession(session);
150
151 PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
152 Plugin plugin = new Plugin();
153 plugin.setGroupId(mojoArtifact.getGroupId());
154 plugin.setArtifactId(mojoArtifact.getArtifactId());
155 plugin.setVersion(mojoArtifact.getVersion());
156 when(pluginDescriptor.getPlugin()).thenReturn(plugin);
157 mojo.setPluginDescriptor(pluginDescriptor);
158 }
159
160 @Test
161 public void noModuleDescriptorFile() throws Exception {
162 AbstractSurefireMojo mojo = spy(new Mojo());
163 mojo.setMainBuildPath(tempFolder.newFolder());
164 File testClassesDir = tempFolder.newFolder();
165 mojo.setTestClassesDirectory(testClassesDir);
166 File jdkHome = new File(System.getProperty("java.home"));
167 ResolvePathResultWrapper wrapper = invokeMethod(mojo, "findModuleDescriptor", jdkHome);
168
169 assertThat(wrapper).isNotNull();
170
171 assertThat(wrapper.getResolvePathResult()).isNull();
172
173 assertThat((boolean) invokeMethod(mojo, "existsModuleDescriptor", wrapper))
174 .isEqualTo(false);
175
176 when(mojo.useModulePath()).thenReturn(true);
177
178 File jvmExecutable = new File(jdkHome, IS_OS_WINDOWS ? "bin\\java.exe" : "bin/java");
179 JdkAttributes jdkAttributes = new JdkAttributes(jvmExecutable, jdkHome, true);
180 Platform platform = new Platform().withJdkExecAttributesForTests(jdkAttributes);
181 assertThat((boolean) invokeMethod(mojo, "canExecuteProviderWithModularPath", platform, wrapper))
182 .isEqualTo(false);
183 }
184
185 @Test
186 public void correctModuleDescriptor() throws Exception {
187 AbstractSurefireMojo mojo = spy(new Mojo());
188 LocationManager locationManager = mock(LocationManager.class);
189 ResolvePathResult result = mock(ResolvePathResult.class);
190 when(result.getModuleNameSource()).thenReturn(MODULEDESCRIPTOR);
191 JavaModuleDescriptor descriptor = mock(JavaModuleDescriptor.class);
192 when(result.getModuleDescriptor()).thenReturn(descriptor);
193 when(locationManager.resolvePath(any(ResolvePathRequest.class))).thenReturn(result);
194 doReturn(locationManager).when(mojo, "getLocationManager");
195 File classesDir = tempFolder.newFolder();
196 mojo.setMainBuildPath(classesDir);
197 File testClassesDir = tempFolder.newFolder();
198 mojo.setTestClassesDirectory(testClassesDir);
199 File descriptorFile = new File(classesDir, "module-info.class");
200 assertThat(descriptorFile.createNewFile()).isTrue();
201 File jdkHome = new File(System.getProperty("java.home"));
202 ResolvePathResultWrapper wrapper = invokeMethod(mojo, "findModuleDescriptor", jdkHome);
203
204 assertThat(wrapper).isNotNull();
205
206 assertThat(wrapper.getResolvePathResult()).isSameAs(result);
207
208 assertThat(wrapper.getResolvePathResult().getModuleNameSource()).isSameAs(MODULEDESCRIPTOR);
209
210 assertThat(wrapper.getResolvePathResult().getModuleDescriptor()).isSameAs(descriptor);
211
212 assertThat((boolean) invokeMethod(mojo, "existsModuleDescriptor", wrapper))
213 .isEqualTo(true);
214
215 when(mojo.useModulePath()).thenReturn(true);
216
217 File jvmExecutable = new File(jdkHome, IS_OS_WINDOWS ? "bin\\java.exe" : "bin/java");
218 JdkAttributes jdkAttributes = new JdkAttributes(jvmExecutable, jdkHome, true);
219 Platform platform = new Platform().withJdkExecAttributesForTests(jdkAttributes);
220 assertThat((boolean) invokeMethod(mojo, "canExecuteProviderWithModularPath", platform, wrapper))
221 .isEqualTo(true);
222
223 jdkAttributes = new JdkAttributes(jvmExecutable, jdkHome, false);
224 platform = new Platform().withJdkExecAttributesForTests(jdkAttributes);
225 assertThat((boolean) invokeMethod(mojo, "canExecuteProviderWithModularPath", platform, wrapper))
226 .isEqualTo(false);
227
228 when(mojo.useModulePath()).thenReturn(false);
229
230 jdkAttributes = new JdkAttributes(jvmExecutable, jdkHome, true);
231 platform = new Platform().withJdkExecAttributesForTests(jdkAttributes);
232 assertThat((boolean) invokeMethod(mojo, "canExecuteProviderWithModularPath", platform, wrapper))
233 .isEqualTo(false);
234 }
235
236 @Test
237 @SuppressWarnings("checkstyle:magicnumber")
238 public void corruptedModuleDescriptor() throws Exception {
239 if (!JAVA_RECENT.atLeast(JAVA_9)) {
240 return;
241 }
242
243 AbstractSurefireMojo mojo = spy(new Mojo());
244 doReturn(new LocationManager()).when(mojo, "getLocationManager");
245 File classesDir = tempFolder.newFolder();
246 mojo.setMainBuildPath(classesDir);
247 File testClassesDir = tempFolder.newFolder();
248 mojo.setTestClassesDirectory(testClassesDir);
249
250 File descriptorFile = new File(classesDir, "module-info.class");
251 assertThat(descriptorFile.createNewFile()).isTrue();
252 write(descriptorFile.toPath(), new byte[] {(byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE});
253
254 File jdkHome = new File(System.getProperty("java.home"));
255 ResolvePathResultWrapper wrapper = invokeMethod(mojo, "findModuleDescriptor", jdkHome);
256
257 assertThat(wrapper).isNotNull();
258
259 assertThat(wrapper.getResolvePathResult()).isNull();
260
261 assertThat((boolean) invokeMethod(mojo, "existsModuleDescriptor", wrapper))
262 .isEqualTo(false);
263 }
264
265 @Test
266 public void shouldShowArray() throws Exception {
267 Logger logger = mock(Logger.class);
268 when(logger.isDebugEnabled()).thenReturn(true);
269 doNothing().when(logger).debug(anyString());
270
271 AbstractSurefireMojo mojo = spy(this.mojo);
272
273 when(mojo.getConsoleLogger()).thenReturn(new PluginConsoleLogger(logger));
274
275 Object[] array = {"ABC", "XYZ"};
276 invokeMethod(mojo, "showArray", array, "prefix");
277
278 ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
279 verify(logger, times(2)).debug(argument.capture());
280 assertThat(argument.getAllValues()).containsExactly("Setting prefix [ABC]", "Setting prefix [XYZ]");
281 }
282
283 @Test
284 public void shouldShowMap() throws Exception {
285 Logger logger = mock(Logger.class);
286 when(logger.isDebugEnabled()).thenReturn(true);
287 doNothing().when(logger).debug(anyString());
288
289 AbstractSurefireMojo mojo = spy(this.mojo);
290
291 when(mojo.getConsoleLogger()).thenReturn(new PluginConsoleLogger(logger));
292
293 Map<String, String> map = new LinkedHashMap<>();
294 map.put("ABC", "123");
295 map.put("XYZ", "987");
296 invokeMethod(mojo, "showMap", map, "prefix");
297
298 ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
299 verify(logger, times(2)).debug(argument.capture());
300 assertThat(argument.getAllValues()).containsExactly("Setting prefix [ABC]=[123]", "Setting prefix [XYZ]=[987]");
301 }
302
303 @Test
304 public void shouldRetainInPluginArtifacts() throws Exception {
305 Artifact provider = new DefaultArtifact("g", "a", createFromVersionSpec("1"), "compile", "jar", "", null);
306 Artifact common = new DefaultArtifact("g", "c", createFromVersionSpec("1"), "compile", "jar", "", null);
307 Artifact api = new DefaultArtifact("g", "a", createFromVersionSpec("1"), "compile", "jar", "", null);
308
309 Set<Artifact> providerArtifacts = singleton(provider);
310 Artifact[] inPluginArtifacts = {common, api};
311 Set<Artifact> inPluginClasspath = invokeMethod(
312 AbstractSurefireMojo.class, "retainInProcArtifactsUnique", providerArtifacts, inPluginArtifacts);
313
314 assertThat(inPluginClasspath).containsOnly(common);
315 }
316
317 @Test
318 public void shouldRetainInProcArtifactsUnique() throws Exception {
319 Artifact provider = new DefaultArtifact("g", "p", createFromVersionSpec("1"), "compile", "jar", "", null);
320 Artifact common = new DefaultArtifact("g", "c", createFromVersionSpec("1"), "compile", "jar", "", null);
321 Artifact api = new DefaultArtifact("g", "a", createFromVersionSpec("1"), "compile", "jar", "", null);
322
323 Set<Artifact> providerArtifacts = singleton(provider);
324 Artifact[] inPluginArtifacts = {common, api};
325 Set<Artifact> inPluginClasspath = invokeMethod(
326 AbstractSurefireMojo.class, "retainInProcArtifactsUnique", providerArtifacts, inPluginArtifacts);
327
328 assertThat(inPluginClasspath).containsOnly(common, api);
329 }
330
331 @Test
332 public void shouldCreateInProcClasspath() throws Exception {
333 Artifact provider = new DefaultArtifact("g", "p", createFromVersionSpec("1"), "compile", "jar", "", null);
334 provider.setFile(mockFile("provider.jar"));
335
336 Artifact common = new DefaultArtifact("g", "c", createFromVersionSpec("1"), "compile", "jar", "", null);
337 common.setFile(mockFile("maven-surefire-common.jar"));
338
339 Artifact api = new DefaultArtifact("g", "a", createFromVersionSpec("1"), "compile", "jar", "", null);
340 api.setFile(mockFile("surefire-api.jar"));
341
342 Set<Artifact> newArtifacts = new LinkedHashSet<>();
343 newArtifacts.add(common);
344 newArtifacts.add(api);
345
346 Classpath providerClasspath = new Classpath(singleton(provider.getFile().getAbsolutePath()));
347
348 Classpath inPluginClasspath =
349 invokeMethod(AbstractSurefireMojo.class, "createInProcClasspath", providerClasspath, newArtifacts);
350
351 Classpath expectedClasspath = new Classpath(asList(
352 provider.getFile().getAbsolutePath(),
353 common.getFile().getAbsolutePath(),
354 api.getFile().getAbsolutePath()));
355
356 assertThat((Object) inPluginClasspath).isEqualTo(expectedClasspath);
357 }
358
359 @Test
360 public void shouldGenerateTestClasspath() throws Exception {
361 AbstractSurefireMojo mojo = spy(this.mojo);
362
363 when(mojo.getMainBuildPath()).thenReturn(new File("target" + separatorChar + "classes"));
364 when(mojo.getTestClassesDirectory()).thenReturn(new File("target" + separatorChar + "test-classes"));
365 when(mojo.getClasspathDependencyScopeExclude()).thenReturn("runtime");
366 when(mojo.getClasspathDependencyExcludes()).thenReturn(new String[] {"g3:a3"});
367 doReturn(mock(Artifact.class)).when(mojo, "getTestNgArtifact");
368
369 Set<Artifact> artifacts = new HashSet<>();
370
371 Artifact a1 = mock(Artifact.class);
372 when(a1.getGroupId()).thenReturn("g1");
373 when(a1.getArtifactId()).thenReturn("a1");
374 when(a1.getVersion()).thenReturn("1");
375 when(a1.getScope()).thenReturn("runtime");
376 when(a1.getDependencyConflictId()).thenReturn("g1:a1:jar");
377 when(a1.getId()).thenReturn("g1:a1:jar:1");
378 artifacts.add(a1);
379
380 ArtifactHandler artifactHandler = mock(ArtifactHandler.class);
381 when(artifactHandler.isAddedToClasspath()).thenReturn(true);
382
383 Artifact a2 = mock(Artifact.class);
384 when(a2.getGroupId()).thenReturn("g2");
385 when(a2.getArtifactId()).thenReturn("a2");
386 when(a2.getVersion()).thenReturn("2");
387 when(a2.getScope()).thenReturn("test");
388 when(a2.getDependencyConflictId()).thenReturn("g2:a2:jar");
389 when(a2.getId()).thenReturn("g2:a2:jar:2");
390 when(a2.getFile()).thenReturn(new File("a2-2.jar"));
391 when(a2.getArtifactHandler()).thenReturn(artifactHandler);
392 artifacts.add(a2);
393
394 Artifact a3 = mock(Artifact.class);
395 when(a3.getGroupId()).thenReturn("g3");
396 when(a3.getArtifactId()).thenReturn("a3");
397 when(a3.getVersion()).thenReturn("3");
398 when(a3.getScope()).thenReturn("test");
399 when(a3.getDependencyConflictId()).thenReturn("g3:a3:jar");
400 when(a3.getId()).thenReturn("g3:a3:jar:3");
401 when(a3.getFile()).thenReturn(new File("a3-3.jar"));
402 when(a3.getArtifactHandler()).thenReturn(artifactHandler);
403 artifacts.add(a3);
404
405 MavenProject project = mock(MavenProject.class);
406 when(project.getArtifacts()).thenReturn(artifacts);
407 when(mojo.getProject()).thenReturn(project);
408
409 TestClassPath cp = invokeMethod(mojo, "generateTestClasspath");
410
411 verifyPrivate(mojo, times(1)).invoke("generateTestClasspath");
412 verify(mojo, times(1)).getMainBuildPath();
413 verify(mojo, times(1)).getTestClassesDirectory();
414 verify(mojo, times(3)).getClasspathDependencyScopeExclude();
415 verify(mojo, times(2)).getClasspathDependencyExcludes();
416 verify(mojo, times(1)).getAdditionalClasspathElements();
417
418 assertThat(cp.toClasspath().getClassPath()).hasSize(3);
419 assertThat(cp.toClasspath().getClassPath().get(0)).endsWith("test-classes");
420 assertThat(cp.toClasspath().getClassPath().get(1)).endsWith("classes");
421 assertThat(cp.toClasspath().getClassPath().get(2)).endsWith("a2-2.jar");
422 }
423
424 @Test
425 @SuppressWarnings("checkstyle:linelength")
426 public void shouldHaveStartupConfigForNonModularClasspath() throws Exception {
427 AbstractSurefireMojo mojo = spy(this.mojo);
428
429 Artifact common = new DefaultArtifact(
430 "org.apache.maven.surefire",
431 "maven-surefire-common",
432 createFromVersion("1"),
433 "runtime",
434 "jar",
435 "",
436 handler);
437 common.setFile(mockFile("maven-surefire-common.jar"));
438
439 Artifact ext = new DefaultArtifact(
440 "org.apache.maven.surefire",
441 "surefire-extensions-api",
442 createFromVersion("1"),
443 "runtime",
444 "jar",
445 "",
446 handler);
447 ext.setFile(mockFile("surefire-extensions-api.jar"));
448
449 Artifact api = new DefaultArtifact(
450 "org.apache.maven.surefire", "surefire-api", createFromVersion("1"), "runtime", "jar", "", handler);
451 api.setFile(mockFile("surefire-api.jar"));
452
453 Artifact loggerApi = new DefaultArtifact(
454 "org.apache.maven.surefire",
455 "surefire-logger-api",
456 createFromVersion("1"),
457 "runtime",
458 "jar",
459 "",
460 handler);
461 loggerApi.setFile(mockFile("surefire-logger-api.jar"));
462
463 Artifact spi = new DefaultArtifact(
464 "org.apache.maven.surefire",
465 "surefire-extensions-spi",
466 createFromVersion("1"),
467 "runtime",
468 "jar",
469 "",
470 handler);
471 spi.setFile(mockFile("surefire-extensions-spi.jar"));
472
473 Artifact booter = new DefaultArtifact(
474 "org.apache.maven.surefire", "surefire-booter", createFromVersion("1"), "runtime", "jar", "", handler);
475 booter.setFile(mockFile("surefire-booter.jar"));
476
477 Artifact utils = new DefaultArtifact(
478 "org.apache.maven.surefire",
479 "surefire-shared-utils",
480 createFromVersion("1"),
481 "runtime",
482 "jar",
483 "",
484 handler);
485 utils.setFile(mockFile("surefire-shared-utils.jar"));
486
487 Map<String, Artifact> providerArtifactsMap = new HashMap<>();
488 providerArtifactsMap.put("org.apache.maven.surefire:maven-surefire-common", common);
489 providerArtifactsMap.put("org.apache.maven.surefire:surefire-extensions-api", ext);
490 providerArtifactsMap.put("org.apache.maven.surefire:surefire-api", api);
491 providerArtifactsMap.put("org.apache.maven.surefire:surefire-logger-api", loggerApi);
492 providerArtifactsMap.put("org.apache.maven.surefire:surefire-extensions-spi", spi);
493 providerArtifactsMap.put("org.apache.maven.surefire:surefire-booter", booter);
494 providerArtifactsMap.put("org.apache.maven.surefire:surefire-shared-utils", utils);
495
496 when(mojo.getPluginArtifactMap()).thenReturn(providerArtifactsMap);
497
498 when(handler.isAddedToClasspath()).thenReturn(true);
499
500 VersionRange v1 = createFromVersion("4.12");
501 Artifact junit = new DefaultArtifact("junit", "junit", v1, "test", "jar", "", handler);
502 junit.setFile(mockFile("junit.jar"));
503
504 VersionRange v2 = createFromVersion("1.3.0");
505 Artifact hamcrest = new DefaultArtifact("org.hamcrest", "hamcrest-core", v2, "test", "jar", "", handler);
506 hamcrest.setFile(mockFile("hamcrest.jar"));
507
508 File classesDir = mockFile("classes");
509 File testClassesDir = mockFile("test-classes");
510 TestClassPath testClasspath = new TestClassPath(asList(junit, hamcrest), classesDir, testClassesDir, null);
511
512 doReturn(testClasspath).when(mojo, "generateTestClasspath");
513 doReturn(1).when(mojo, "getEffectiveForkCount");
514 doReturn(true).when(mojo, "effectiveIsEnableAssertions");
515 when(mojo.isChildDelegation()).thenReturn(false);
516
517 ClassLoaderConfiguration classLoaderConfiguration = new ClassLoaderConfiguration(false, true);
518
519 VersionRange v3 = createFromVersion("1");
520 Artifact provider = new DefaultArtifact("x", "surefire-provider", v3, "runtime", "jar", "", handler);
521 provider.setFile(mockFile("surefire-provider.jar"));
522 Set<Artifact> providerArtifacts = singleton(provider);
523
524 Logger logger = mock(Logger.class);
525 when(logger.isDebugEnabled()).thenReturn(true);
526 doNothing().when(logger).debug(anyString());
527 when(mojo.getConsoleLogger()).thenReturn(new PluginConsoleLogger(logger));
528
529 ProviderInfo providerInfo = mock(ProviderInfo.class);
530 when(providerInfo.getProviderName()).thenReturn("org.asf.Provider");
531 when(providerInfo.getProviderClasspath()).thenReturn(providerArtifacts);
532
533 StartupConfiguration conf = invokeMethod(
534 mojo, "newStartupConfigWithClasspath", classLoaderConfiguration, providerInfo, testClasspath);
535
536 verify(mojo, times(1)).effectiveIsEnableAssertions();
537 verify(mojo, times(1)).isChildDelegation();
538 ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
539 verify(logger, times(6)).debug(argument.capture());
540 assertThat(argument.getAllValues())
541 .containsExactly(
542 "test classpath: test-classes classes junit.jar hamcrest.jar",
543 "provider classpath: surefire-provider.jar",
544 "test(compact) classpath: test-classes classes junit.jar hamcrest.jar",
545 "provider(compact) classpath: surefire-provider.jar",
546 "in-process classpath: surefire-provider.jar maven-surefire-common.jar surefire-booter.jar surefire-extensions-api.jar surefire-api.jar surefire-extensions-spi.jar surefire-logger-api.jar surefire-shared-utils.jar",
547 "in-process(compact) classpath: surefire-provider.jar maven-surefire-common.jar surefire-booter.jar surefire-extensions-api.jar surefire-api.jar surefire-extensions-spi.jar surefire-logger-api.jar surefire-shared-utils.jar");
548
549 assertThat(conf.getClassLoaderConfiguration()).isSameAs(classLoaderConfiguration);
550
551 assertThat((Object) conf.getClasspathConfiguration().getTestClasspath()).isEqualTo(testClasspath.toClasspath());
552
553 Collection<String> files = new ArrayList<>();
554 for (Artifact providerArtifact : providerArtifacts) {
555 files.add(providerArtifact.getFile().getAbsolutePath());
556 }
557 assertThat((Object) conf.getClasspathConfiguration().getProviderClasspath())
558 .isEqualTo(new Classpath(files));
559
560 assertThat((Object) conf.getClasspathConfiguration().isClassPathConfig())
561 .isEqualTo(true);
562
563 assertThat((Object) conf.getClasspathConfiguration().isModularPathConfig())
564 .isEqualTo(false);
565
566 assertThat((Object) conf.getClasspathConfiguration().isEnableAssertions())
567 .isEqualTo(true);
568
569 assertThat(conf.getProviderClassName()).isEqualTo("org.asf.Provider");
570 }
571
572 @Test
573 public void providerClasspathCachingIsNotSharedAcrossMojoInstances() throws Exception {
574 ProviderInfo providerInfo = mock(ProviderInfo.class);
575 when(providerInfo.getProviderName()).thenReturn("test-provider");
576 Artifact provider =
577 new DefaultArtifact("com.example", "provider", createFromVersion("1"), "runtime", "jar", "", handler);
578 provider.setFile(mockFile("original-test-provider.jar"));
579 Set<Artifact> providerClasspath = singleton(provider);
580 when(providerInfo.getProviderClasspath()).thenReturn(providerClasspath);
581
582 StartupConfiguration startupConfiguration = startupConfigurationForProvider(providerInfo);
583 assertThat(startupConfiguration
584 .getClasspathConfiguration()
585 .getProviderClasspath()
586 .getClassPath())
587 .containsExactly("original-test-provider.jar");
588
589 provider.setFile(mockFile("modified-test-provider.jar"));
590 startupConfiguration = startupConfigurationForProvider(providerInfo);
591 assertThat(startupConfiguration
592 .getClasspathConfiguration()
593 .getProviderClasspath()
594 .getClassPath())
595 .containsExactly("modified-test-provider.jar");
596 }
597
598 private StartupConfiguration startupConfigurationForProvider(ProviderInfo providerInfo) throws Exception {
599 AbstractSurefireMojo mojo = spy(new Mojo());
600
601 Logger logger = mock(Logger.class);
602 when(logger.isDebugEnabled()).thenReturn(true);
603 doNothing().when(logger).debug(anyString());
604 when(mojo.getConsoleLogger()).thenReturn(new PluginConsoleLogger(logger));
605
606 File classesDir = mockFile("classes");
607 File testClassesDir = mockFile("test-classes");
608 TestClassPath testClassPath =
609 new TestClassPath(new ArrayList<Artifact>(), classesDir, testClassesDir, Collections.emptyList());
610
611 Artifact common = new DefaultArtifact(
612 "org.apache.maven.surefire",
613 "maven-surefire-common",
614 createFromVersion("1"),
615 "runtime",
616 "jar",
617 "",
618 handler);
619 common.setFile(mockFile("maven-surefire-common.jar"));
620
621 Artifact ext = new DefaultArtifact(
622 "org.apache.maven.surefire",
623 "surefire-extensions-api",
624 createFromVersion("1"),
625 "runtime",
626 "jar",
627 "",
628 handler);
629 ext.setFile(mockFile("surefire-extensions-api.jar"));
630
631 Artifact api = new DefaultArtifact(
632 "org.apache.maven.surefire", "surefire-api", createFromVersion("1"), "runtime", "jar", "", handler);
633 api.setFile(mockFile("surefire-api.jar"));
634
635 Artifact loggerApi = new DefaultArtifact(
636 "org.apache.maven.surefire",
637 "surefire-logger-api",
638 createFromVersion("1"),
639 "runtime",
640 "jar",
641 "",
642 handler);
643 loggerApi.setFile(mockFile("surefire-logger-api.jar"));
644
645 Artifact spi = new DefaultArtifact(
646 "org.apache.maven.surefire",
647 "surefire-extensions-spi",
648 createFromVersion("1"),
649 "runtime",
650 "jar",
651 "",
652 handler);
653 spi.setFile(mockFile("surefire-extensions-spi.jar"));
654
655 Artifact booter = new DefaultArtifact(
656 "org.apache.maven.surefire", "surefire-booter", createFromVersion("1"), "runtime", "jar", "", handler);
657 booter.setFile(mockFile("surefire-booter.jar"));
658
659 Artifact utils = new DefaultArtifact(
660 "org.apache.maven.surefire",
661 "surefire-shared-utils",
662 createFromVersion("1"),
663 "runtime",
664 "jar",
665 "",
666 handler);
667 utils.setFile(mockFile("surefire-shared-utils.jar"));
668
669 Map<String, Artifact> providerArtifactsMap = new HashMap<>();
670 providerArtifactsMap.put("org.apache.maven.surefire:maven-surefire-common", common);
671 providerArtifactsMap.put("org.apache.maven.surefire:surefire-extensions-api", ext);
672 providerArtifactsMap.put("org.apache.maven.surefire:surefire-api", api);
673 providerArtifactsMap.put("org.apache.maven.surefire:surefire-logger-api", loggerApi);
674 providerArtifactsMap.put("org.apache.maven.surefire:surefire-extensions-spi", spi);
675 providerArtifactsMap.put("org.apache.maven.surefire:surefire-booter", booter);
676 providerArtifactsMap.put("org.apache.maven.surefire:surefire-shared-utils", utils);
677
678 when(mojo.getPluginArtifactMap()).thenReturn(providerArtifactsMap);
679
680 doReturn(1).when(mojo, "getEffectiveForkCount");
681
682 return invokeMethod(
683 mojo, "createStartupConfiguration", providerInfo, false, null, null, testClassPath, null, null);
684 }
685
686 @Test
687 public void shouldCreateStartupConfigWithModularPath() throws Exception {
688 String baseDir = System.getProperty("user.dir");
689
690 Mojo mojo = new Mojo();
691
692
693
694 LocationManager locationManager = mock(LocationManager.class);
695 ResolvePathsResult resolvePathsResult = mock(ResolvePathsResult.class);
696 when(locationManager.resolvePaths(any(ResolvePathsRequest.class))).thenReturn(resolvePathsResult);
697 when(resolvePathsResult.getPathExceptions()).thenReturn(emptyMap());
698 when(resolvePathsResult.getClasspathElements()).thenReturn(emptyList());
699 when(resolvePathsResult.getModulepathElements()).thenReturn(emptyMap());
700
701 mojo.setLogger(mock(Logger.class));
702 mojo.setUseModulePath(true);
703 setInternalState(mojo, "locationManager", locationManager);
704
705 File jdkHome = new File(System.getProperty("java.home"));
706 File jvmExecutable = new File(jdkHome, IS_OS_WINDOWS ? "bin\\java.exe" : "bin/java");
707 JdkAttributes jdkAttributes = new JdkAttributes(jvmExecutable, jdkHome, true);
708 Platform platform = new Platform().withJdkExecAttributesForTests(jdkAttributes);
709
710 File classesDirectory = new File(baseDir, "mock-dir");
711 File testClassesDirectory = new File(baseDir, "mock-dir");
712 mojo.setTestClassesDirectory(testClassesDirectory);
713 TestClassPath testClassPath = new TestClassPath(
714 Collections.<Artifact>emptySet(), classesDirectory, testClassesDirectory, Collections.emptyList());
715
716 ProviderInfo providerInfo = mock(ProviderInfo.class);
717 when(providerInfo.getProviderName()).thenReturn("provider mock");
718 when(providerInfo.getProviderClasspath()).thenReturn(Collections.<Artifact>emptySet());
719
720 DefaultScanResult defaultScanResult = mock(DefaultScanResult.class);
721 when(defaultScanResult.getClasses()).thenReturn(Collections.<String>emptyList());
722
723 Path pathToModularDescriptor =
724 Paths.get(baseDir, "src", "test", "resources", "org", "apache", "maven", "plugin", "surefire");
725 mojo.setMainBuildPath(pathToModularDescriptor.toFile());
726
727 Map<String, Artifact> artifacts = new HashMap<>();
728 Artifact dummyArtifact = mock(Artifact.class);
729 when(dummyArtifact.getFile()).thenReturn(new File(baseDir, "mock-file"));
730 artifacts.put("org.apache.maven.surefire:maven-surefire-common", dummyArtifact);
731 artifacts.put("org.apache.maven.surefire:surefire-extensions-api", dummyArtifact);
732 artifacts.put("org.apache.maven.surefire:surefire-api", dummyArtifact);
733 artifacts.put("org.apache.maven.surefire:surefire-logger-api", dummyArtifact);
734 artifacts.put("org.apache.maven.surefire:surefire-extensions-spi", dummyArtifact);
735 artifacts.put("org.apache.maven.surefire:surefire-booter", dummyArtifact);
736 artifacts.put("org.apache.maven.surefire:surefire-shared-utils", dummyArtifact);
737 mojo.setPluginArtifactMap(artifacts);
738
739 ResolvePathResult resolvePathResult = mock(ResolvePathResult.class);
740 JavaModuleDescriptor desc = mock(JavaModuleDescriptor.class);
741 when(desc.name()).thenReturn("");
742 when(resolvePathResult.getModuleDescriptor()).thenReturn(desc);
743 ResolvePathResultWrapper wrapper = new ResolvePathResultWrapper(resolvePathResult, true);
744
745
746 StartupConfiguration actualConfig = invokeMethod(
747 mojo,
748 "createStartupConfiguration",
749 new Class[] {
750 ProviderInfo.class,
751 boolean.class,
752 ClassLoaderConfiguration.class,
753 DefaultScanResult.class,
754 TestClassPath.class,
755 Platform.class,
756 ResolvePathResultWrapper.class
757 },
758 providerInfo,
759 true,
760 mock(ClassLoaderConfiguration.class),
761 defaultScanResult,
762 testClassPath,
763 platform,
764 wrapper);
765
766 assertThat(actualConfig).isNotNull();
767
768 assertThat(actualConfig.getClasspathConfiguration()).isInstanceOf(ModularClasspathConfiguration.class);
769 }
770
771 @Test
772 public void shouldExistTmpDirectory() throws IOException {
773 String systemTmpDir = System.getProperty("java.io.tmpdir");
774 String usrDir = new File(System.getProperty("user.dir")).getCanonicalPath();
775
776 String tmpDir = "surefireX" + System.currentTimeMillis();
777
778
779 new File(systemTmpDir, tmpDir).delete();
780
781 File targetDir = new File(usrDir, "target");
782
783 new File(targetDir, tmpDir).delete();
784
785 AbstractSurefireMojo mojo = mock(AbstractSurefireMojo.class);
786 Logger logger = mock(Logger.class);
787 when(logger.isDebugEnabled()).thenReturn(false);
788 when(logger.isErrorEnabled()).thenReturn(false);
789 doNothing().when(logger).debug(anyString());
790 doNothing().when(logger).error(anyString(), any(Throwable.class));
791 when(mojo.getConsoleLogger()).thenReturn(new PluginConsoleLogger(logger));
792 when(mojo.getTempDir()).thenReturn(tmpDir);
793 when(mojo.getProjectBuildDirectory()).thenReturn(targetDir);
794 when(mojo.createSurefireBootDirectoryInTemp()).thenCallRealMethod();
795 when(mojo.createSurefireBootDirectoryInBuild()).thenCallRealMethod();
796 when(mojo.getSurefireTempDir()).thenCallRealMethod();
797
798 File bootDir = mojo.createSurefireBootDirectoryInTemp();
799 assertThat(bootDir).isNotNull();
800 assertThat(bootDir).isDirectory();
801
802 assertThat(new File(systemTmpDir, bootDir.getName())).isDirectory();
803 assertThat(bootDir.getName()).startsWith(tmpDir);
804
805 File buildTmp = mojo.createSurefireBootDirectoryInBuild();
806 assertThat(buildTmp).isNotNull();
807 assertThat(buildTmp).isDirectory();
808 assertThat(buildTmp.getParentFile().getCanonicalFile().getParent()).isEqualTo(usrDir);
809 assertThat(buildTmp.getName()).isEqualTo(tmpDir);
810
811 File tmp = mojo.getSurefireTempDir();
812 assertThat(tmp).isNotNull();
813 assertThat(tmp).isDirectory();
814 assertThat(IS_OS_WINDOWS ? new File(systemTmpDir, bootDir.getName()) : new File(targetDir, tmpDir))
815 .isDirectory();
816 }
817
818 @Test
819 public void shouldSmartlyResolveJUnit5ProviderWithJUnit4() throws Exception {
820 MavenProject mavenProject = new MavenProject();
821 mavenProject.setArtifact(new DefaultArtifact(
822 "dummy", "pom", createFromVersion("1.0.0"), null, "jar", null, mock(ArtifactHandler.class)));
823 mojo.setProject(mavenProject);
824
825 final VersionRange surefireVersion = createFromVersion("1");
826
827 Artifact testClasspathJUnit = new DefaultArtifact(
828 "junit", "junit", createFromVersion("4.12"), null, "jar", null, mock(ArtifactHandler.class));
829
830 Artifact testClasspathHamcrest = new DefaultArtifact(
831 "org.hamcrest",
832 "hamcrest-core",
833 createFromVersion("1.3"),
834 null,
835 "jar",
836 null,
837 mock(ArtifactHandler.class));
838
839 setProjectDepedenciesToMojo(testClasspathJUnit, testClasspathHamcrest);
840
841 Collection<Artifact> testArtifacts = new ArrayList<>();
842 testArtifacts.add(testClasspathJUnit);
843 testArtifacts.add(testClasspathHamcrest);
844
845 File classesDirectory = new File("target/classes");
846
847 File testClassesDirectory = new File("target/test-classes");
848
849 TestClassPath testClasspathWrapper =
850 new TestClassPath(testArtifacts, classesDirectory, testClassesDirectory, null);
851
852 SurefireDependencyResolver dependencyResolver = mock(SurefireDependencyResolver.class);
853 mojo.setSurefireDependencyResolver(dependencyResolver);
854
855 when(dependencyResolver.getProviderClasspathAsMap(any(), any(), anyString(), anyString()))
856 .thenReturn(artifactMapByVersionlessId(createSurefireProviderResolutionResult(surefireVersion)));
857
858 when(dependencyResolver.resolveArtifacts(any(), any(), any(Artifact.class)))
859 .thenReturn(createExpectedJUnitPlatformLauncherResolutionResult());
860
861 final Artifact pluginDep1 = new DefaultArtifact(
862 "org.junit.vintage", "junit-vintage-engine", createFromVersion("5.4.0"), null, "jar", "", null);
863
864 final Artifact pluginDep2 = new DefaultArtifact(
865 "org.apiguardian", "apiguardian-api", createFromVersion("1.0.0"), null, "jar", "", null);
866
867 final Artifact pluginDep3 = new DefaultArtifact(
868 "org.junit.platform",
869 "junit-platform-engine",
870 createFromVersion("1.4.0"),
871 null,
872 "jar",
873 null,
874 mock(ArtifactHandler.class));
875
876 final Artifact pluginDep4 = new DefaultArtifact(
877 "junit", "junit", createFromVersion("4.12"), null, "jar", null, mock(ArtifactHandler.class));
878
879 final Artifact pluginDep5 = new DefaultArtifact(
880 "org.hamcrest",
881 "hamcrest-core",
882 createFromVersion("1.3"),
883 null,
884 "jar",
885 null,
886 mock(ArtifactHandler.class));
887
888 final Artifact pluginDep6 = new DefaultArtifact(
889 "org.opentest4j",
890 "opentest4j",
891 createFromVersion("1.1.1"),
892 null,
893 "jar",
894 null,
895 mock(ArtifactHandler.class));
896
897 final Artifact pluginDep7 = new DefaultArtifact(
898 "org.junit.platform",
899 "junit-platform-commons",
900 createFromVersion("1.4.0"),
901 null,
902 "jar",
903 null,
904 mock(ArtifactHandler.class));
905
906 addPluginDependencies(pluginDep1, pluginDep2, pluginDep3, pluginDep4, pluginDep5, pluginDep6, pluginDep7);
907
908 mojo.setLogger(mock(Logger.class));
909
910 Set<Artifact> pluginDependencyArtifacts = new HashSet<>();
911 pluginDependencyArtifacts.add(pluginDep1);
912 pluginDependencyArtifacts.add(pluginDep2);
913 pluginDependencyArtifacts.add(pluginDep3);
914 pluginDependencyArtifacts.add(pluginDep4);
915 pluginDependencyArtifacts.add(pluginDep5);
916 pluginDependencyArtifacts.add(pluginDep6);
917 pluginDependencyArtifacts.add(pluginDep7);
918
919 when(dependencyResolver.resolvePluginDependencies(any(), any(), any(), any()))
920 .thenReturn(artifactMapByVersionlessId(pluginDependencyArtifacts));
921
922 PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
923 mojo.setPluginDescriptor(pluginDescriptor);
924 Plugin p = mock(Plugin.class);
925 when(pluginDescriptor.getPlugin()).thenReturn(p);
926
927 Artifact junitPlatformArtifact = invokeMethod(mojo, "getJUnit5Artifact");
928 assertThat(junitPlatformArtifact.getGroupId()).isEqualTo("org.junit.platform");
929 assertThat(junitPlatformArtifact.getArtifactId()).isEqualTo("junit-platform-engine");
930 assertThat(junitPlatformArtifact.getVersion()).isEqualTo("1.4.0");
931
932 JUnitPlatformProviderInfo prov =
933 mojo.createJUnitPlatformProviderInfo(junitPlatformArtifact, testClasspathWrapper);
934
935 assertThat(prov.isApplicable()).isTrue();
936
937 Artifact expectedProvider = new DefaultArtifact(
938 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
939 Artifact expectedCommonJava5 = new DefaultArtifact(
940 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
941 Artifact expectedLauncher = new DefaultArtifact(
942 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.4.0"), null, "jar", "", null);
943 Artifact expectedApiguardian = new DefaultArtifact(
944 "org.apiguardian", "apiguardian-api", createFromVersion("1.0.0"), null, "jar", "", null);
945 Artifact expectedJUnit5Engine = new DefaultArtifact(
946 "org.junit.platform", "junit-platform-engine", createFromVersion("1.4.0"), null, "jar", "", null);
947 Artifact expectedOpentest4j =
948 new DefaultArtifact("org.opentest4j", "opentest4j", createFromVersion("1.1.1"), null, "jar", "", null);
949 Artifact expectedPlatformCommons = new DefaultArtifact(
950 "org.junit.platform", "junit-platform-commons", createFromVersion("1.4.0"), null, "jar", "", null);
951 Artifact expectedEngine = new DefaultArtifact(
952 "org.junit.vintage", "junit-vintage-engine", createFromVersion("5.4.0"), null, "jar", "", null);
953
954 assertThat(prov.getProviderClasspath())
955 .hasSize(8)
956 .containsOnly(
957 expectedProvider,
958 expectedCommonJava5,
959 expectedLauncher,
960 expectedApiguardian,
961 expectedJUnit5Engine,
962 expectedOpentest4j,
963 expectedPlatformCommons,
964 expectedEngine);
965
966 assertThat(testClasspathWrapper.getTestDependencies())
967 .hasSize(2)
968 .containsEntry("junit:junit", testClasspathJUnit)
969 .containsEntry("org.hamcrest:hamcrest-core", testClasspathHamcrest);
970 }
971
972 @Test
973 public void shouldSmartlyResolveJUnit5ProviderWithVintage() throws Exception {
974 MavenProject mavenProject = new MavenProject();
975 mavenProject.setArtifact(new DefaultArtifact(
976 "dummy", "pom", createFromVersion("1.0.0"), null, "jar", null, mock(ArtifactHandler.class)));
977 mojo.setProject(mavenProject);
978
979 VersionRange surefireVersion = createFromVersion("1");
980
981 Artifact testClasspathSomeTestArtifact = new DefaultArtifact(
982 "third.party", "artifact", createFromVersion("1.0"), null, "jar", null, mock(ArtifactHandler.class));
983
984 Artifact testClasspathVintage = new DefaultArtifact(
985 "org.junit.vintage",
986 "junit-vintage-engine",
987 createFromVersion("5.4.0"),
988 null,
989 "jar",
990 null,
991 mock(ArtifactHandler.class));
992
993 Artifact testClasspathApiguardian = new DefaultArtifact(
994 "org.apiguardian",
995 "apiguardian-api",
996 createFromVersion("1.0.0"),
997 null,
998 "jar",
999 null,
1000 mock(ArtifactHandler.class));
1001
1002 Artifact testClasspathPlatformEng = new DefaultArtifact(
1003 "org.junit.platform",
1004 "junit-platform-engine",
1005 createFromVersion("1.4.0"),
1006 null,
1007 "jar",
1008 null,
1009 mock(ArtifactHandler.class));
1010
1011 Artifact testClasspathJUnit4 = new DefaultArtifact(
1012 "junit", "junit", createFromVersion("4.12"), null, "jar", null, mock(ArtifactHandler.class));
1013
1014 Artifact testClasspathHamcrest = new DefaultArtifact(
1015 "org.hamcrest",
1016 "hamcrest-core",
1017 createFromVersion("1.3"),
1018 null,
1019 "jar",
1020 null,
1021 mock(ArtifactHandler.class));
1022
1023 Artifact testClasspathOpentest4j = new DefaultArtifact(
1024 "org.opentest4j",
1025 "opentest4j",
1026 createFromVersion("1.1.1"),
1027 null,
1028 "jar",
1029 null,
1030 mock(ArtifactHandler.class));
1031
1032 Artifact testClasspathCommons = new DefaultArtifact(
1033 "org.junit.platform",
1034 "junit-platform-commons",
1035 createFromVersion("1.4.0"),
1036 null,
1037 "jar",
1038 null,
1039 mock(ArtifactHandler.class));
1040
1041 Collection<Artifact> testArtifacts = asList(
1042 testClasspathSomeTestArtifact,
1043 testClasspathVintage,
1044 testClasspathApiguardian,
1045 testClasspathPlatformEng,
1046 testClasspathJUnit4,
1047 testClasspathHamcrest,
1048 testClasspathOpentest4j,
1049 testClasspathCommons);
1050
1051 setProjectDepedenciesToMojo(testArtifacts.toArray(new Artifact[testArtifacts.size()]));
1052
1053 File classesDirectory = new File("target/classes");
1054
1055 File testClassesDirectory = new File("target/test-classes");
1056
1057 TestClassPath testClasspathWrapper =
1058 new TestClassPath(testArtifacts, classesDirectory, testClassesDirectory, null);
1059
1060 SurefireDependencyResolver dependencyResolver = mock(SurefireDependencyResolver.class);
1061 mojo.setSurefireDependencyResolver(dependencyResolver);
1062
1063 when(dependencyResolver.getProviderClasspathAsMap(any(), any(), anyString(), anyString()))
1064 .thenReturn(artifactMapByVersionlessId(createSurefireProviderResolutionResult(surefireVersion)));
1065
1066 when(dependencyResolver.resolveArtifacts(any(), any(), any(Artifact.class)))
1067 .thenReturn(createExpectedJUnitPlatformLauncherResolutionResult());
1068
1069 mojo.setLogger(mock(Logger.class));
1070
1071 PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
1072 mojo.setPluginDescriptor(pluginDescriptor);
1073 Plugin p = mock(Plugin.class);
1074 when(pluginDescriptor.getPlugin()).thenReturn(p);
1075 when(p.getDependencies()).thenReturn(Collections.<Dependency>emptyList());
1076
1077 Artifact junitPlatformArtifact = invokeMethod(mojo, "getJUnit5Artifact");
1078 assertThat(junitPlatformArtifact.getGroupId()).isEqualTo("org.junit.platform");
1079 assertThat(junitPlatformArtifact.getArtifactId()).isEqualTo("junit-platform-commons");
1080 assertThat(junitPlatformArtifact.getVersion()).isEqualTo("1.4.0");
1081
1082 JUnitPlatformProviderInfo prov =
1083 mojo.createJUnitPlatformProviderInfo(junitPlatformArtifact, testClasspathWrapper);
1084
1085 assertThat(prov.isApplicable()).isTrue();
1086
1087 Artifact expectedProvider = new DefaultArtifact(
1088 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
1089 Artifact expectedCommonJava5 = new DefaultArtifact(
1090 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
1091 Artifact expectedLauncher = new DefaultArtifact(
1092 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.4.0"), null, "jar", "", null);
1093 assertThat(prov.getProviderClasspath())
1094 .hasSize(3)
1095 .containsOnly(expectedProvider, expectedCommonJava5, expectedLauncher);
1096
1097 assertThat(testClasspathWrapper.getTestDependencies())
1098 .hasSize(8)
1099 .containsEntry("third.party:artifact", testClasspathSomeTestArtifact)
1100 .containsEntry("org.junit.vintage:junit-vintage-engine", testClasspathVintage)
1101 .containsEntry("org.apiguardian:apiguardian-api", testClasspathApiguardian)
1102 .containsEntry("org.junit.platform:junit-platform-engine", testClasspathPlatformEng)
1103 .containsEntry("junit:junit", testClasspathJUnit4)
1104 .containsEntry("org.hamcrest:hamcrest-core", testClasspathHamcrest)
1105 .containsEntry("org.opentest4j:opentest4j", testClasspathOpentest4j)
1106 .containsEntry("org.junit.platform:junit-platform-commons", testClasspathCommons);
1107 }
1108
1109 @Test
1110 public void shouldSmartlyResolveJUnit5ProviderWithJUnit5Commons() throws Exception {
1111 MavenProject mavenProject = new MavenProject();
1112 mavenProject.setArtifact(new DefaultArtifact(
1113 "dummy", "pom", createFromVersion("1.0.0"), null, "jar", null, mock(ArtifactHandler.class)));
1114 mojo.setProject(mavenProject);
1115
1116 final VersionRange surefireVersion = createFromVersion("1");
1117
1118 Artifact testClasspathSomeTestArtifact = new DefaultArtifact(
1119 "third.party", "artifact", createFromVersion("1.0"), null, "jar", null, mock(ArtifactHandler.class));
1120
1121 Artifact testClasspathCommons = new DefaultArtifact(
1122 "org.junit.platform",
1123 "junit-platform-commons",
1124 createFromVersion("1.4.0"),
1125 null,
1126 "jar",
1127 null,
1128 mock(ArtifactHandler.class));
1129
1130 Artifact testClasspathApiguardian = new DefaultArtifact(
1131 "org.apiguardian",
1132 "apiguardian-api",
1133 createFromVersion("1.0.0"),
1134 null,
1135 "jar",
1136 null,
1137 mock(ArtifactHandler.class));
1138
1139 Collection<Artifact> testArtifacts =
1140 asList(testClasspathSomeTestArtifact, testClasspathApiguardian, testClasspathCommons);
1141
1142 setProjectDepedenciesToMojo(testArtifacts.toArray(new Artifact[testArtifacts.size()]));
1143
1144 File classesDirectory = new File("target/classes");
1145
1146 File testClassesDirectory = new File("target/test-classes");
1147
1148 TestClassPath testClasspathWrapper =
1149 new TestClassPath(testArtifacts, classesDirectory, testClassesDirectory, null);
1150
1151 SurefireDependencyResolver dependencyResolver = mock(SurefireDependencyResolver.class);
1152 mojo.setSurefireDependencyResolver(dependencyResolver);
1153
1154 when(dependencyResolver.getProviderClasspathAsMap(any(), any(), anyString(), anyString()))
1155 .thenReturn(artifactMapByVersionlessId(createSurefireProviderResolutionResult(surefireVersion)));
1156
1157 when(dependencyResolver.resolveArtifacts(any(), any(), any(Artifact.class)))
1158 .thenReturn(createExpectedJUnitPlatformLauncherResolutionResult());
1159
1160 mojo.setLogger(mock(Logger.class));
1161
1162 invokeMethod(mojo, "setupStuff");
1163
1164 PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
1165 mojo.setPluginDescriptor(pluginDescriptor);
1166 Plugin p = mock(Plugin.class);
1167 when(pluginDescriptor.getPlugin()).thenReturn(p);
1168 when(p.getDependencies()).thenReturn(Collections.<Dependency>emptyList());
1169
1170 Artifact junitPlatformArtifact = invokeMethod(mojo, "getJUnit5Artifact");
1171 assertThat(junitPlatformArtifact.getGroupId()).isEqualTo("org.junit.platform");
1172 assertThat(junitPlatformArtifact.getArtifactId()).isEqualTo("junit-platform-commons");
1173 assertThat(junitPlatformArtifact.getVersion()).isEqualTo("1.4.0");
1174
1175 JUnitPlatformProviderInfo prov =
1176 mojo.createJUnitPlatformProviderInfo(junitPlatformArtifact, testClasspathWrapper);
1177
1178 assertThat(prov.isApplicable()).isTrue();
1179
1180 Set<Artifact> resolvedProviderArtifacts = prov.getProviderClasspath();
1181
1182 Artifact provider = new DefaultArtifact(
1183 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
1184 Artifact java5 = new DefaultArtifact(
1185 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
1186 Artifact launcher = new DefaultArtifact(
1187 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.4.0"), null, "jar", "", null);
1188 Artifact engine = new DefaultArtifact(
1189 "org.junit.platform", "junit-platform-engine", createFromVersion("1.4.0"), null, "jar", "", null);
1190 Artifact opentest4j =
1191 new DefaultArtifact("org.opentest4j", "opentest4j", createFromVersion("1.1.1"), null, "jar", "", null);
1192 assertThat(resolvedProviderArtifacts).hasSize(5).containsOnly(provider, java5, launcher, engine, opentest4j);
1193
1194 assertThat(testClasspathWrapper.getTestDependencies())
1195 .hasSize(3)
1196 .containsEntry("third.party:artifact", testClasspathSomeTestArtifact)
1197 .containsEntry("org.junit.platform:junit-platform-commons", testClasspathCommons)
1198 .containsEntry("org.apiguardian:apiguardian-api", testClasspathApiguardian);
1199 }
1200
1201 @Test
1202 public void shouldSmartlyResolveJUnit5ProviderWithJUnit5Engine() throws Exception {
1203 MavenProject mavenProject = new MavenProject();
1204 mavenProject.setArtifact(new DefaultArtifact(
1205 "dummy", "pom", createFromVersion("1.0.0"), null, "jar", null, mock(ArtifactHandler.class)));
1206 mojo.setProject(mavenProject);
1207
1208 final VersionRange surefireVersion = createFromVersion("1");
1209
1210 final Artifact testClasspathSomeTestArtifact = new DefaultArtifact(
1211 "third.party", "artifact", createFromVersion("1.0"), null, "jar", null, mock(ArtifactHandler.class));
1212
1213 final Artifact testClasspathJUnit5 = new DefaultArtifact(
1214 "org.junit.platform",
1215 "junit-platform-engine",
1216 createFromVersion("1.4.0"),
1217 null,
1218 "jar",
1219 null,
1220 mock(ArtifactHandler.class));
1221
1222 final Artifact testClasspathApiguardian = new DefaultArtifact(
1223 "org.apiguardian",
1224 "apiguardian-api",
1225 createFromVersion("1.0.0"),
1226 null,
1227 "jar",
1228 null,
1229 mock(ArtifactHandler.class));
1230
1231 final Artifact testClasspathCommons = new DefaultArtifact(
1232 "org.junit.platform",
1233 "junit-platform-commons",
1234 createFromVersion("1.4.0"),
1235 null,
1236 "jar",
1237 null,
1238 mock(ArtifactHandler.class));
1239
1240 final Artifact testClasspathOpentest4j = new DefaultArtifact(
1241 "org.opentest4j",
1242 "opentest4j",
1243 createFromVersion("1.1.1"),
1244 null,
1245 "jar",
1246 null,
1247 mock(ArtifactHandler.class));
1248
1249 Collection<Artifact> testArtifacts = asList(
1250 testClasspathSomeTestArtifact,
1251 testClasspathJUnit5,
1252 testClasspathApiguardian,
1253 testClasspathCommons,
1254 testClasspathOpentest4j);
1255
1256 setProjectDepedenciesToMojo(testArtifacts.toArray(new Artifact[testArtifacts.size()]));
1257
1258 File classesDirectory = new File("target/classes");
1259
1260 File testClassesDirectory = new File("target/test-classes");
1261
1262 TestClassPath testClasspathWrapper =
1263 new TestClassPath(testArtifacts, classesDirectory, testClassesDirectory, null);
1264
1265 SurefireDependencyResolver dependencyResolver = mock(SurefireDependencyResolver.class);
1266 mojo.setSurefireDependencyResolver(dependencyResolver);
1267
1268 when(dependencyResolver.getProviderClasspathAsMap(any(), any(), anyString(), anyString()))
1269 .thenReturn(artifactMapByVersionlessId(createSurefireProviderResolutionResult(surefireVersion)));
1270
1271 when(dependencyResolver.resolveArtifacts(any(), any(), any(Artifact.class)))
1272 .thenReturn(createExpectedJUnitPlatformLauncherResolutionResult());
1273
1274 mojo.setLogger(mock(Logger.class));
1275
1276 invokeMethod(mojo, "setupStuff");
1277
1278 Artifact junitPlatformArtifact = invokeMethod(mojo, "getJUnit5Artifact");
1279 assertThat(junitPlatformArtifact.getGroupId()).isEqualTo("org.junit.platform");
1280 assertThat(junitPlatformArtifact.getArtifactId()).isEqualTo("junit-platform-commons");
1281 assertThat(junitPlatformArtifact.getVersion()).isEqualTo("1.4.0");
1282
1283 JUnitPlatformProviderInfo prov =
1284 mojo.createJUnitPlatformProviderInfo(junitPlatformArtifact, testClasspathWrapper);
1285
1286 assertThat(prov.isApplicable()).isTrue();
1287
1288 Artifact surefireProvider = new DefaultArtifact(
1289 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
1290
1291 Artifact java5 = new DefaultArtifact(
1292 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
1293 Artifact launcher = new DefaultArtifact(
1294 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.4.0"), null, "jar", "", null);
1295
1296 Set<Artifact> resolvedProviderArtifacts = prov.getProviderClasspath();
1297
1298 assertThat(resolvedProviderArtifacts).hasSize(3).containsOnly(surefireProvider, java5, launcher);
1299
1300 assertThat(testClasspathWrapper.getTestDependencies())
1301 .hasSize(5)
1302 .containsEntry("third.party:artifact", testClasspathSomeTestArtifact)
1303 .containsEntry("org.junit.platform:junit-platform-engine", testClasspathJUnit5)
1304 .containsEntry("org.apiguardian:apiguardian-api", testClasspathApiguardian)
1305 .containsEntry("org.junit.platform:junit-platform-commons", testClasspathCommons)
1306 .containsEntry("org.opentest4j:opentest4j", testClasspathOpentest4j);
1307 }
1308
1309 @Test
1310 public void shouldSmartlyResolveJUnit5ProviderWithJupiterApi() throws Exception {
1311 MavenProject mavenProject = new MavenProject();
1312 mavenProject.setArtifact(new DefaultArtifact(
1313 "dummy", "pom", createFromVersion("1.0.0"), null, "jar", null, mock(ArtifactHandler.class)));
1314 mojo.setProject(mavenProject);
1315
1316 final VersionRange surefireVersion = createFromVersion("1");
1317
1318 final Artifact testClasspathSomeTestArtifact = new DefaultArtifact(
1319 "third.party", "artifact", createFromVersion("1.0"), null, "jar", null, mock(ArtifactHandler.class));
1320
1321 final Artifact testClasspathJupiterApi = new DefaultArtifact(
1322 "org.junit.jupiter",
1323 "junit-jupiter-api",
1324 createFromVersion("5.4.0"),
1325 null,
1326 "jar",
1327 null,
1328 mock(ArtifactHandler.class));
1329
1330 final Artifact testClasspathApiguardian = new DefaultArtifact(
1331 "org.apiguardian",
1332 "apiguardian-api",
1333 createFromVersion("1.0.0"),
1334 null,
1335 "jar",
1336 null,
1337 mock(ArtifactHandler.class));
1338
1339 final Artifact testClasspathCommons = new DefaultArtifact(
1340 "org.junit.platform",
1341 "junit-platform-commons",
1342 createFromVersion("1.4.0"),
1343 null,
1344 "jar",
1345 null,
1346 mock(ArtifactHandler.class));
1347
1348 final Artifact testClasspathOpentest4j = new DefaultArtifact(
1349 "org.opentest4j",
1350 "opentest4j",
1351 createFromVersion("1.1.1"),
1352 null,
1353 "jar",
1354 null,
1355 mock(ArtifactHandler.class));
1356
1357 Collection<Artifact> testArtifacts = asList(
1358 testClasspathSomeTestArtifact,
1359 testClasspathJupiterApi,
1360 testClasspathApiguardian,
1361 testClasspathCommons,
1362 testClasspathOpentest4j);
1363
1364 setProjectDepedenciesToMojo(testArtifacts.toArray(new Artifact[testArtifacts.size()]));
1365
1366 File classesDirectory = new File("target/classes");
1367
1368 File testClassesDirectory = new File("target/test-classes");
1369
1370 TestClassPath testClasspathWrapper =
1371 new TestClassPath(testArtifacts, classesDirectory, testClassesDirectory, null);
1372
1373 SurefireDependencyResolver dependencyResolver = mock(SurefireDependencyResolver.class);
1374 mojo.setSurefireDependencyResolver(dependencyResolver);
1375
1376 when(dependencyResolver.getProviderClasspathAsMap(any(), any(), anyString(), anyString()))
1377 .thenReturn(artifactMapByVersionlessId(createSurefireProviderResolutionResult(surefireVersion)));
1378
1379 Artifact jUnitPlatformLauncherArtifact = new DefaultArtifact(
1380 "org.junit.platform",
1381 "junit-platform-launcher",
1382 createFromVersion("1.4.0"),
1383 null,
1384 "jar",
1385 null,
1386 mock(ArtifactHandler.class));
1387
1388 when(dependencyResolver.resolveArtifacts(any(), any(), eq(jUnitPlatformLauncherArtifact)))
1389 .thenReturn(createExpectedJUnitPlatformLauncherResolutionResult());
1390
1391 Artifact jupiterEngineArtifact = new DefaultArtifact(
1392 "org.junit.jupiter",
1393 "junit-jupiter-engine",
1394 createFromVersion("5.4.0"),
1395 null,
1396 "jar",
1397 null,
1398 mock(ArtifactHandler.class));
1399
1400 when(dependencyResolver.resolveArtifacts(any(), any(), eq(jupiterEngineArtifact)))
1401 .thenReturn(createJupiterEngineResolutionResult());
1402
1403 mojo.setLogger(mock(Logger.class));
1404
1405 PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
1406 mojo.setPluginDescriptor(pluginDescriptor);
1407 Plugin p = mock(Plugin.class);
1408 when(pluginDescriptor.getPlugin()).thenReturn(p);
1409 when(p.getDependencies()).thenReturn(Collections.<Dependency>emptyList());
1410
1411 Artifact junitPlatformArtifact = invokeMethod(mojo, "getJUnit5Artifact");
1412 assertThat(junitPlatformArtifact.getGroupId()).isEqualTo("org.junit.platform");
1413 assertThat(junitPlatformArtifact.getArtifactId()).isEqualTo("junit-platform-commons");
1414 assertThat(junitPlatformArtifact.getVersion()).isEqualTo("1.4.0");
1415
1416 JUnitPlatformProviderInfo prov =
1417 mojo.createJUnitPlatformProviderInfo(junitPlatformArtifact, testClasspathWrapper);
1418
1419 assertThat(prov.isApplicable()).isTrue();
1420
1421 final Artifact surefireProvider = new DefaultArtifact(
1422 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
1423
1424 Artifact java5 = new DefaultArtifact(
1425 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
1426 Artifact launcher = new DefaultArtifact(
1427 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.4.0"), null, "jar", "", null);
1428 Artifact jupiterEngine = new DefaultArtifact(
1429 "org.junit.jupiter",
1430 "junit-jupiter-engine",
1431 createFromVersion("5.4.0"),
1432 null,
1433 "jar",
1434 "",
1435 null);
1436 Artifact platformEngine = new DefaultArtifact(
1437 "org.junit.platform", "junit-platform-engine", createFromVersion("1.4.0"), null, "jar", "", null);
1438
1439 Set<Artifact> resolvedProviderArtifacts = prov.getProviderClasspath();
1440
1441 assertThat(resolvedProviderArtifacts)
1442 .hasSize(5)
1443 .containsOnly(surefireProvider, java5, launcher, jupiterEngine, platformEngine);
1444
1445 assertThat(testClasspathWrapper.getTestDependencies())
1446 .hasSize(5)
1447 .containsEntry("third.party:artifact", testClasspathSomeTestArtifact)
1448 .containsEntry("org.junit.jupiter:junit-jupiter-api", testClasspathJupiterApi)
1449 .containsEntry("org.apiguardian:apiguardian-api", testClasspathApiguardian)
1450 .containsEntry("org.junit.platform:junit-platform-commons", testClasspathCommons)
1451 .containsEntry("org.opentest4j:opentest4j", testClasspathOpentest4j);
1452 }
1453
1454 @Test
1455 public void shouldSmartlyResolveJUnit5ProviderWithJupiterEngine() throws Exception {
1456 MavenProject mavenProject = new MavenProject();
1457 mavenProject.setArtifact(new DefaultArtifact(
1458 "dummy", "pom", createFromVersion("1.0.0"), null, "jar", null, mock(ArtifactHandler.class)));
1459 mojo.setProject(mavenProject);
1460
1461 final VersionRange surefireVersion = createFromVersion("1");
1462
1463 final Artifact testClasspathSomeTestArtifact = new DefaultArtifact(
1464 "third.party", "artifact", createFromVersion("1.0"), null, "jar", null, mock(ArtifactHandler.class));
1465
1466 final Artifact testClasspathJupiterEngine = new DefaultArtifact(
1467 "org.junit.jupiter",
1468 "junit-jupiter-engine",
1469 createFromVersion("5.4.0"),
1470 null,
1471 "jar",
1472 null,
1473 mock(ArtifactHandler.class));
1474
1475 final Artifact testClasspathPlatformEngine = new DefaultArtifact(
1476 "org.junit.platform",
1477 "junit-platform-engine",
1478 createFromVersion("1.4.0"),
1479 null,
1480 "jar",
1481 null,
1482 mock(ArtifactHandler.class));
1483
1484 final Artifact testClasspathJupiterApi = new DefaultArtifact(
1485 "org.junit.jupiter",
1486 "junit-jupiter-api",
1487 createFromVersion("5.4.0"),
1488 null,
1489 "jar",
1490 null,
1491 mock(ArtifactHandler.class));
1492
1493 final Artifact testClasspathApiguardian = new DefaultArtifact(
1494 "org.apiguardian",
1495 "apiguardian-api",
1496 createFromVersion("1.0.0"),
1497 null,
1498 "jar",
1499 null,
1500 mock(ArtifactHandler.class));
1501
1502 final Artifact testClasspathCommons = new DefaultArtifact(
1503 "org.junit.platform",
1504 "junit-platform-commons",
1505 createFromVersion("1.4.0"),
1506 null,
1507 "jar",
1508 null,
1509 mock(ArtifactHandler.class));
1510
1511 final Artifact testClasspathOpentest4j = new DefaultArtifact(
1512 "org.opentest4j",
1513 "opentest4j",
1514 createFromVersion("1.1.1"),
1515 null,
1516 "jar",
1517 null,
1518 mock(ArtifactHandler.class));
1519
1520 Collection<Artifact> testArtifacts = asList(
1521 testClasspathSomeTestArtifact,
1522 testClasspathJupiterEngine,
1523 testClasspathPlatformEngine,
1524 testClasspathJupiterApi,
1525 testClasspathApiguardian,
1526 testClasspathCommons,
1527 testClasspathOpentest4j);
1528
1529 setProjectDepedenciesToMojo(testArtifacts.toArray(new Artifact[testArtifacts.size()]));
1530
1531 File classesDirectory = new File("target/classes");
1532
1533 File testClassesDirectory = new File("target/test-classes");
1534
1535 TestClassPath testClasspathWrapper =
1536 new TestClassPath(testArtifacts, classesDirectory, testClassesDirectory, null);
1537
1538 SurefireDependencyResolver dependencyResolver = mock(SurefireDependencyResolver.class);
1539 mojo.setSurefireDependencyResolver(dependencyResolver);
1540
1541 when(dependencyResolver.getProviderClasspathAsMap(any(), any(), anyString(), anyString()))
1542 .thenReturn(artifactMapByVersionlessId(createSurefireProviderResolutionResult(surefireVersion)));
1543
1544 when(dependencyResolver.resolveArtifacts(any(), any(), any(Artifact.class)))
1545 .thenReturn(createExpectedJUnitPlatformLauncherResolutionResult());
1546
1547 mojo.setLogger(mock(Logger.class));
1548
1549 Artifact junitPlatformArtifact = invokeMethod(mojo, "getJUnit5Artifact");
1550 assertThat(junitPlatformArtifact.getGroupId()).isEqualTo("org.junit.platform");
1551 assertThat(junitPlatformArtifact.getArtifactId()).isEqualTo("junit-platform-commons");
1552 assertThat(junitPlatformArtifact.getVersion()).isEqualTo("1.4.0");
1553
1554 JUnitPlatformProviderInfo prov =
1555 mojo.createJUnitPlatformProviderInfo(junitPlatformArtifact, testClasspathWrapper);
1556
1557 assertThat(prov.isApplicable()).isTrue();
1558
1559 Artifact surefireProvider = new DefaultArtifact(
1560 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
1561 Artifact java5 = new DefaultArtifact(
1562 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
1563 Artifact launcher = new DefaultArtifact(
1564 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.4.0"), null, "jar", "", null);
1565
1566 Set<Artifact> resolvedProviderArtifacts = prov.getProviderClasspath();
1567
1568 assertThat(resolvedProviderArtifacts).hasSize(3).containsOnly(surefireProvider, java5, launcher);
1569
1570 assertThat(testClasspathWrapper.getTestDependencies())
1571 .hasSize(7)
1572 .containsEntry("third.party:artifact", testClasspathSomeTestArtifact)
1573 .containsEntry("org.junit.jupiter:junit-jupiter-engine", testClasspathJupiterEngine)
1574 .containsEntry("org.junit.platform:junit-platform-engine", testClasspathPlatformEngine)
1575 .containsEntry("org.junit.jupiter:junit-jupiter-api", testClasspathJupiterApi)
1576 .containsEntry("org.apiguardian:apiguardian-api", testClasspathApiguardian)
1577 .containsEntry("org.junit.platform:junit-platform-commons", testClasspathCommons)
1578 .containsEntry("org.opentest4j:opentest4j", testClasspathOpentest4j);
1579 }
1580
1581 @Test
1582 public void shouldSmartlyResolveJUnit5ProviderWithJupiterEngineInPluginDependencies() throws Exception {
1583 final VersionRange surefireVersion = createFromVersion("1");
1584
1585 final Artifact plugin = new DefaultArtifact(
1586 "org.apache.maven.surefire",
1587 "maven-surefire-plugin",
1588 surefireVersion,
1589 null,
1590 "jar",
1591 null,
1592 mock(ArtifactHandler.class));
1593
1594 final Artifact forkedBooter = new DefaultArtifact(
1595 "org.apache.maven.surefire",
1596 "surefire-booter",
1597 surefireVersion,
1598 null,
1599 "jar",
1600 null,
1601 mock(ArtifactHandler.class));
1602
1603 final Artifact pluginDepJupiterEngine = new DefaultArtifact(
1604 "org.junit.jupiter", "junit-jupiter-engine", createFromVersion("5.4.0"), null, "jar", "", null);
1605
1606 final Artifact pluginDepPlatformEngine = new DefaultArtifact(
1607 "org.junit.platform",
1608 "junit-platform-engine",
1609 createFromVersion("1.4.0"),
1610 null,
1611 "jar",
1612 null,
1613 mock(ArtifactHandler.class));
1614
1615 final Artifact pluginDepJupiterApi = new DefaultArtifact(
1616 "org.junit.jupiter",
1617 "junit-jupiter-api",
1618 createFromVersion("5.4.0"),
1619 null,
1620 "jar",
1621 null,
1622 mock(ArtifactHandler.class));
1623
1624 final Artifact pluginDepApiguardian = new DefaultArtifact(
1625 "org.apiguardian",
1626 "apiguardian-api",
1627 createFromVersion("1.0.0"),
1628 null,
1629 "jar",
1630 null,
1631 mock(ArtifactHandler.class));
1632
1633 final Artifact pluginDepCommons = new DefaultArtifact(
1634 "org.junit.platform",
1635 "junit-platform-commons",
1636 createFromVersion("1.4.0"),
1637 null,
1638 "jar",
1639 null,
1640 mock(ArtifactHandler.class));
1641
1642 final Artifact pluginDepOpentest4j = new DefaultArtifact(
1643 "org.opentest4j",
1644 "opentest4j",
1645 createFromVersion("1.1.1"),
1646 null,
1647 "jar",
1648 null,
1649 mock(ArtifactHandler.class));
1650
1651 addPluginDependencies(
1652 plugin,
1653 forkedBooter,
1654 pluginDepJupiterEngine,
1655 pluginDepPlatformEngine,
1656 pluginDepJupiterApi,
1657 pluginDepApiguardian,
1658 pluginDepCommons,
1659 pluginDepOpentest4j);
1660
1661 MavenProject mavenProject = new MavenProject();
1662 mavenProject.setArtifact(new DefaultArtifact(
1663 "dummy", "pom", createFromVersion("1.0.0"), null, "jar", null, mock(ArtifactHandler.class)));
1664 mojo.setProject(mavenProject);
1665
1666 final Artifact testClasspathSomeTestArtifact = new DefaultArtifact(
1667 "third.party", "artifact", createFromVersion("1.0"), null, "jar", null, mock(ArtifactHandler.class));
1668
1669 final Artifact testClasspathJupiterApi = new DefaultArtifact(
1670 "org.junit.jupiter",
1671 "junit-jupiter-api",
1672 createFromVersion("5.3.0"),
1673 null,
1674 "jar",
1675 null,
1676 mock(ArtifactHandler.class));
1677
1678 final Artifact testClasspathApiguardian = new DefaultArtifact(
1679 "org.apiguardian",
1680 "apiguardian-api",
1681 createFromVersion("1.0.0"),
1682 null,
1683 "jar",
1684 null,
1685 mock(ArtifactHandler.class));
1686
1687 final Artifact testClasspathCommons = new DefaultArtifact(
1688 "org.junit.platform",
1689 "junit-platform-commons",
1690 createFromVersion("1.4.0"),
1691 null,
1692 "jar",
1693 null,
1694 mock(ArtifactHandler.class));
1695
1696 final Artifact testClasspathOpentest4j = new DefaultArtifact(
1697 "org.opentest4j",
1698 "opentest4j",
1699 createFromVersion("1.1.1"),
1700 null,
1701 "jar",
1702 null,
1703 mock(ArtifactHandler.class));
1704
1705 Collection<Artifact> testArtifacts = asList(
1706 testClasspathSomeTestArtifact,
1707 testClasspathJupiterApi,
1708 testClasspathApiguardian,
1709 testClasspathCommons,
1710 testClasspathOpentest4j);
1711
1712 setProjectDepedenciesToMojo(testArtifacts.toArray(new Artifact[testArtifacts.size()]));
1713
1714 File classesDirectory = new File("target/classes");
1715
1716 File testClassesDirectory = new File("target/test-classes");
1717
1718 TestClassPath testClasspathWrapper =
1719 new TestClassPath(testArtifacts, classesDirectory, testClassesDirectory, null);
1720
1721 SurefireDependencyResolver dependencyResolver = mock(SurefireDependencyResolver.class);
1722 mojo.setSurefireDependencyResolver(dependencyResolver);
1723
1724 when(dependencyResolver.getProviderClasspathAsMap(any(), any(), anyString(), anyString()))
1725 .thenReturn(artifactMapByVersionlessId(createSurefireProviderResolutionResult(surefireVersion)));
1726
1727 when(dependencyResolver.resolveArtifacts(any(), any(), any(Artifact.class)))
1728 .thenReturn(createExpectedJUnitPlatformLauncherResolutionResult());
1729
1730 mojo.setLogger(mock(Logger.class));
1731
1732 Set<Artifact> pluginDepJupiterEngineArtifacts = new HashSet<>();
1733 pluginDepJupiterEngineArtifacts.add(pluginDepJupiterEngine);
1734 pluginDepJupiterEngineArtifacts.add(pluginDepPlatformEngine);
1735 pluginDepJupiterEngineArtifacts.add(pluginDepJupiterApi);
1736 pluginDepJupiterEngineArtifacts.add(pluginDepApiguardian);
1737 pluginDepJupiterEngineArtifacts.add(pluginDepCommons);
1738 pluginDepJupiterEngineArtifacts.add(pluginDepOpentest4j);
1739
1740 when(dependencyResolver.resolvePluginDependencies(any(), any(), any(), any()))
1741 .thenReturn(artifactMapByVersionlessId(pluginDepJupiterEngineArtifacts));
1742
1743 Artifact junitPlatformArtifact = invokeMethod(mojo, "getJUnit5Artifact");
1744 assertThat(junitPlatformArtifact.getGroupId()).isEqualTo("org.junit.platform");
1745 assertThat(junitPlatformArtifact.getArtifactId()).isEqualTo("junit-platform-engine");
1746 assertThat(junitPlatformArtifact.getVersion()).isEqualTo("1.4.0");
1747
1748 JUnitPlatformProviderInfo prov =
1749 mojo.createJUnitPlatformProviderInfo(junitPlatformArtifact, testClasspathWrapper);
1750
1751 assertThat(prov.isApplicable()).isTrue();
1752
1753 PluginDescriptor pluginDescriptor = mock(PluginDescriptor.class);
1754 mojo.setPluginDescriptor(pluginDescriptor);
1755 Plugin p = mock(Plugin.class);
1756 when(pluginDescriptor.getPlugin()).thenReturn(p);
1757 List<Dependency> directPluginDependencies = toDependencies(pluginDepJupiterEngine);
1758 when(p.getDependencies()).thenReturn(directPluginDependencies);
1759
1760 Artifact surefireProvider = new DefaultArtifact(
1761 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
1762 Artifact java5 = new DefaultArtifact(
1763 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
1764 Artifact launcher = new DefaultArtifact(
1765 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.4.0"), null, "jar", "", null);
1766 Artifact jupiterEngine = new DefaultArtifact(
1767 "org.junit.jupiter", "junit-jupiter-engine", createFromVersion("5.4.0"), null, "jar", "", null);
1768 Artifact platformEngine = new DefaultArtifact(
1769 "org.junit.platform", "junit-platform-engine", createFromVersion("1.4.0"), null, "jar", "", null);
1770
1771 Set<Artifact> resolvedProviderArtifacts = prov.getProviderClasspath();
1772
1773 assertThat(resolvedProviderArtifacts)
1774 .hasSize(5)
1775 .containsOnly(surefireProvider, java5, launcher, jupiterEngine, platformEngine);
1776
1777 assertThat(testClasspathWrapper.getTestDependencies())
1778 .hasSize(5)
1779 .containsEntry("third.party:artifact", testClasspathSomeTestArtifact)
1780 .containsEntry("org.junit.jupiter:junit-jupiter-api", testClasspathJupiterApi)
1781 .containsEntry("org.apiguardian:apiguardian-api", testClasspathApiguardian)
1782 .containsEntry("org.junit.platform:junit-platform-commons", testClasspathCommons)
1783 .containsEntry("org.opentest4j:opentest4j", testClasspathOpentest4j);
1784 }
1785
1786 @Test
1787 public void shouldConvertJunitEngineParameters() throws Exception {
1788 Properties properties = new Properties();
1789 setInternalState(mojo, "properties", properties);
1790
1791 invokeMethod(mojo, "convertJunitEngineParameters");
1792 assertThat(properties).isEmpty();
1793
1794 mojo.setIncludeJUnit5Engines(new String[0]);
1795 mojo.setExcludeJUnit5Engines(new String[0]);
1796 invokeMethod(mojo, "convertJunitEngineParameters");
1797 assertThat(properties).isEmpty();
1798
1799 mojo.setIncludeJUnit5Engines(new String[] {"e1", "e2"});
1800 invokeMethod(mojo, "convertJunitEngineParameters");
1801 assertThat(properties).containsEntry("includejunit5engines", "e1,e2");
1802
1803 mojo.setExcludeJUnit5Engines(new String[] {"e1", "e2"});
1804 invokeMethod(mojo, "convertJunitEngineParameters");
1805 assertThat(properties).containsEntry("excludejunit5engines", "e1,e2");
1806 }
1807
1808 private static Set<Artifact> createJUnitPlatformLauncherResolutionResult(
1809 Artifact junit5Engine, Artifact apiguardian, Artifact commons, Artifact opentest4j) {
1810 Set<Artifact> resolvedLauncherArtifacts = new HashSet<>();
1811 Artifact launcher = new DefaultArtifact(
1812 "org.junit.platform", "junit-platform-launcher", commons.getVersionRange(), null, "jar", "", null);
1813 resolvedLauncherArtifacts.add(launcher);
1814 resolvedLauncherArtifacts.add(apiguardian);
1815 resolvedLauncherArtifacts.add(junit5Engine);
1816 resolvedLauncherArtifacts.add(commons);
1817 resolvedLauncherArtifacts.add(opentest4j);
1818 resolvedLauncherArtifacts.remove(null);
1819 return resolvedLauncherArtifacts;
1820 }
1821
1822 private static Set<Artifact> createJupiterEngineResolutionResult() {
1823 Set<Artifact> resolvedLauncherArtifacts = new HashSet<>();
1824 resolvedLauncherArtifacts.add(new DefaultArtifact(
1825 "org.junit.jupiter", "junit-jupiter-engine", createFromVersion("5.4.0"), null, "jar", "", null));
1826 resolvedLauncherArtifacts.add(new DefaultArtifact(
1827 "org.junit.jupiter", "junit-jupiter-api", createFromVersion("5.4.0"), null, "jar", "", null));
1828 resolvedLauncherArtifacts.add(new DefaultArtifact(
1829 "org.junit.platform", "junit-platform-engine", createFromVersion("1.4.0"), null, "jar", "", null));
1830 resolvedLauncherArtifacts.add(new DefaultArtifact(
1831 "org.apiguardian", "apiguardian-api", createFromVersion("1.0.0"), null, "jar", "", null));
1832 resolvedLauncherArtifacts.add(
1833 new DefaultArtifact("org.opentest4j", "opentest4j", createFromVersion("1.1.1"), null, "jar", "", null));
1834 resolvedLauncherArtifacts.add(new DefaultArtifact(
1835 "org.junit.platform", "junit-platform-commons", createFromVersion("1.4.0"), null, "jar", "", null));
1836 return resolvedLauncherArtifacts;
1837 }
1838
1839 private static Set<Artifact> createExpectedJUnitPlatformLauncherResolutionResult() {
1840 Artifact engine = new DefaultArtifact(
1841 "org.junit.platform", "junit-platform-engine", createFromVersion("1.4.0"), null, "jar", "", null);
1842 Artifact commons = new DefaultArtifact(
1843 "org.junit.platform", "junit-platform-commons", createFromVersion("1.4.0"), null, "jar", "", null);
1844 Artifact apiguardian = new DefaultArtifact(
1845 "org.apiguardian", "apiguardian-api", createFromVersion("1.0.0"), null, "jar", "", null);
1846 Artifact opentest4j =
1847 new DefaultArtifact("org.opentest4j", "opentest4j", createFromVersion("1.1.1"), null, "jar", "", null);
1848 return createJUnitPlatformLauncherResolutionResult(engine, apiguardian, commons, opentest4j);
1849 }
1850
1851 private static Set<Artifact> createSurefireProviderResolutionResult(VersionRange surefireVersion) {
1852
1853 Artifact provider = new DefaultArtifact(
1854 "org.apache.maven.surefire", "surefire-junit-platform", surefireVersion, null, "jar", "", null);
1855 Artifact java5 = new DefaultArtifact(
1856 "org.apache.maven.surefire", "common-java5", surefireVersion, null, "jar", "", null);
1857 Artifact launcher = new DefaultArtifact(
1858 "org.junit.platform", "junit-platform-launcher", createFromVersion("1.3.2"), null, "jar", "", null);
1859 Artifact apiguardian = new DefaultArtifact(
1860 "org.apiguardian", "apiguardian-api", createFromVersion("1.0.0"), null, "jar", "", null);
1861 Artifact engine = new DefaultArtifact(
1862 "org.junit.platform", "junit-platform-engine", createFromVersion("1.3.2"), null, "jar", "", null);
1863 Artifact commons = new DefaultArtifact(
1864 "org.junit.platform", "junit-platform-commons", createFromVersion("1.3.2"), null, "jar", "", null);
1865 Artifact opentest4j =
1866 new DefaultArtifact("org.opentest4j", "opentest4j", createFromVersion("1.1.1"), null, "jar", "", null);
1867
1868 Set<Artifact> providerArtifacts = new HashSet<>();
1869 providerArtifacts.add(provider);
1870 providerArtifacts.add(java5);
1871 providerArtifacts.add(launcher);
1872 providerArtifacts.add(apiguardian);
1873 providerArtifacts.add(engine);
1874 providerArtifacts.add(commons);
1875 providerArtifacts.add(opentest4j);
1876
1877 return providerArtifacts;
1878 }
1879
1880 @Test
1881 public void shouldVerifyConfigParameters() throws Exception {
1882 Mojo mojo = new Mojo() {
1883 @Override
1884 public File getTestClassesDirectory() {
1885 return new File(System.getProperty("user.dir"), "target/test-classes");
1886 }
1887
1888 @Override
1889 protected String getEnableProcessChecker() {
1890 return "fake";
1891 }
1892 };
1893
1894 e.expect(MojoFailureException.class);
1895 e.expectMessage("Unexpected value 'fake' in the configuration parameter 'enableProcessChecker'.");
1896 mojo.verifyParameters();
1897 }
1898
1899 private void setProjectDepedenciesToMojo(Artifact... deps) {
1900 for (Artifact dep : deps) {
1901 mojo.getProjectArtifactMap().put(dep.getGroupId() + ":" + dep.getArtifactId(), dep);
1902 }
1903 }
1904
1905 private void addPluginDependencies(Artifact... deps) {
1906 for (Artifact dep : deps) {
1907 mojo.getPluginArtifactMap().put(dep.getGroupId() + ":" + dep.getArtifactId(), dep);
1908 }
1909 }
1910
1911
1912
1913
1914 public static class Mojo extends AbstractSurefireMojo implements SurefireReportParameters {
1915 private File mainBuildPath;
1916
1917 private File testClassesDirectory;
1918
1919 private boolean useModulePath;
1920
1921 private int failOnFlakeCount;
1922
1923 private String[] includeJUnit5Engines;
1924
1925 private String[] excludeJUnit5Engines;
1926
1927 private List<Artifact> projectTestArtifacts;
1928
1929 private File includesFile;
1930
1931 private File excludesFile;
1932
1933 private List<String> includes;
1934
1935 private List<String> excludes;
1936
1937 private String test;
1938
1939 private boolean testFailureIgnore;
1940
1941 private JUnitPlatformProviderInfo createJUnitPlatformProviderInfo(
1942 Artifact junitPlatformArtifact, TestClassPath testClasspathWrapper) {
1943 return new JUnitPlatformProviderInfo(null, junitPlatformArtifact, testClasspathWrapper);
1944 }
1945
1946 void setProjectTestArtifacts(List<Artifact> projectTestArtifacts) {
1947 this.projectTestArtifacts = projectTestArtifacts;
1948 }
1949
1950 @Override
1951 List<Artifact> getProjectTestArtifacts() {
1952 return projectTestArtifacts;
1953 }
1954
1955 @Override
1956 protected void logDebugOrCliShowErrors(String s) {
1957
1958 }
1959
1960 @Override
1961 protected String getPluginName() {
1962 return null;
1963 }
1964
1965 @Override
1966 protected int getRerunFailingTestsCount() {
1967 return 0;
1968 }
1969
1970 @Override
1971 public boolean isSkipTests() {
1972 return false;
1973 }
1974
1975 @Override
1976 public void setSkipTests(boolean skipTests) {}
1977
1978 @Override
1979 public boolean isSkipExec() {
1980 return false;
1981 }
1982
1983 @Override
1984 public void setSkipExec(boolean skipExec) {}
1985
1986 @Override
1987 public boolean isSkip() {
1988 return false;
1989 }
1990
1991 @Override
1992 public void setSkip(boolean skip) {}
1993
1994 @Override
1995 public boolean isTestFailureIgnore() {
1996 return testFailureIgnore;
1997 }
1998
1999 @Override
2000 public void setTestFailureIgnore(boolean testFailureIgnore) {
2001 this.testFailureIgnore = testFailureIgnore;
2002 }
2003
2004 @Override
2005 public File getBasedir() {
2006 return null;
2007 }
2008
2009 @Override
2010 public void setBasedir(File basedir) {}
2011
2012 @Override
2013 public File getTestClassesDirectory() {
2014 return testClassesDirectory;
2015 }
2016
2017 @Override
2018 public void setTestClassesDirectory(File testClassesDirectory) {
2019 this.testClassesDirectory = testClassesDirectory;
2020 }
2021
2022 @Override
2023 public File getMainBuildPath() {
2024 return mainBuildPath;
2025 }
2026
2027 @Override
2028 public void setMainBuildPath(File mainBuildPath) {
2029 this.mainBuildPath = mainBuildPath;
2030 }
2031
2032 @Override
2033 public File getReportsDirectory() {
2034 return null;
2035 }
2036
2037 @Override
2038 public void setReportsDirectory(File reportsDirectory) {}
2039
2040 @Override
2041 public String getTest() {
2042 return test;
2043 }
2044
2045 @Override
2046 public void setTest(String test) {
2047 this.test = test;
2048 }
2049
2050 @Override
2051 public List<String> getIncludes() {
2052 return includes;
2053 }
2054
2055 @Override
2056 public void setIncludes(List<String> includes) {
2057 this.includes = includes;
2058 }
2059
2060 void setIncludesFile(File includesFile) {
2061 this.includesFile = includesFile;
2062 }
2063
2064 @Override
2065 public File getIncludesFile() {
2066 return includesFile;
2067 }
2068
2069 @Override
2070 public List<String> getExcludes() {
2071 return excludes;
2072 }
2073
2074 @Override
2075 public void setExcludes(List<String> excludes) {
2076 this.excludes = excludes;
2077 }
2078
2079 @Override
2080 public boolean isPrintSummary() {
2081 return false;
2082 }
2083
2084 @Override
2085 public void setPrintSummary(boolean printSummary) {}
2086
2087 @Override
2088 public String getReportFormat() {
2089 return null;
2090 }
2091
2092 @Override
2093 public void setReportFormat(String reportFormat) {}
2094
2095 @Override
2096 public boolean isUseFile() {
2097 return false;
2098 }
2099
2100 @Override
2101 public void setUseFile(boolean useFile) {}
2102
2103 @Override
2104 public String getDebugForkedProcess() {
2105 return null;
2106 }
2107
2108 @Override
2109 public void setDebugForkedProcess(String debugForkedProcess) {}
2110
2111 @Override
2112 public int getForkedProcessTimeoutInSeconds() {
2113 return 0;
2114 }
2115
2116 @Override
2117 public void setForkedProcessTimeoutInSeconds(int forkedProcessTimeoutInSeconds) {}
2118
2119 @Override
2120 public int getForkedProcessExitTimeoutInSeconds() {
2121 return 0;
2122 }
2123
2124 @Override
2125 public void setForkedProcessExitTimeoutInSeconds(int forkedProcessTerminationTimeoutInSeconds) {}
2126
2127 @Override
2128 public double getParallelTestsTimeoutInSeconds() {
2129 return 0;
2130 }
2131
2132 @Override
2133 public void setParallelTestsTimeoutInSeconds(double parallelTestsTimeoutInSeconds) {}
2134
2135 @Override
2136 public double getParallelTestsTimeoutForcedInSeconds() {
2137 return 0;
2138 }
2139
2140 @Override
2141 public void setParallelTestsTimeoutForcedInSeconds(double parallelTestsTimeoutForcedInSeconds) {}
2142
2143 @Override
2144 public boolean isUseSystemClassLoader() {
2145 return false;
2146 }
2147
2148 @Override
2149 public void setUseSystemClassLoader(boolean useSystemClassLoader) {}
2150
2151 @Override
2152 public boolean isUseManifestOnlyJar() {
2153 return false;
2154 }
2155
2156 @Override
2157 public void setUseManifestOnlyJar(boolean useManifestOnlyJar) {}
2158
2159 @Override
2160 public String getEncoding() {
2161 return null;
2162 }
2163
2164 @Override
2165 public void setEncoding(String encoding) {}
2166
2167 @Override
2168 public boolean getFailIfNoSpecifiedTests() {
2169 return false;
2170 }
2171
2172 @Override
2173 public void setFailIfNoSpecifiedTests(boolean failIfNoSpecifiedTests) {}
2174
2175 @Override
2176 public int getSkipAfterFailureCount() {
2177 return 0;
2178 }
2179
2180 @Override
2181 public String getShutdown() {
2182 return null;
2183 }
2184
2185 void setExcludesFile(File excludesFile) {
2186 this.excludesFile = excludesFile;
2187 }
2188
2189 @Override
2190 public File getExcludesFile() {
2191 return excludesFile;
2192 }
2193
2194 @Override
2195 protected List<File> suiteXmlFiles() {
2196 return null;
2197 }
2198
2199 @Override
2200 protected boolean hasSuiteXmlFiles() {
2201 return false;
2202 }
2203
2204 @Override
2205 protected String[] getExcludedEnvironmentVariables() {
2206 return new String[0];
2207 }
2208
2209 @Override
2210 public File[] getSuiteXmlFiles() {
2211 return new File[0];
2212 }
2213
2214 @Override
2215 public void setSuiteXmlFiles(File[] suiteXmlFiles) {}
2216
2217 @Override
2218 public String getRunOrder() {
2219 return null;
2220 }
2221
2222 @Override
2223 public void setRunOrder(String runOrder) {}
2224
2225 @Override
2226 public Long getRunOrderRandomSeed() {
2227 return null;
2228 }
2229
2230 @Override
2231 public void setRunOrderRandomSeed(Long runOrderRandomSeed) {}
2232
2233 @Override
2234 protected void handleSummary(RunResult summary, Exception firstForkException) {}
2235
2236 @Override
2237 protected boolean isSkipExecution() {
2238 return false;
2239 }
2240
2241 @Override
2242 protected String[] getDefaultIncludes() {
2243 return new String[0];
2244 }
2245
2246 @Override
2247 protected String getReportSchemaLocation() {
2248 return null;
2249 }
2250
2251 @Override
2252 protected boolean useModulePath() {
2253 return useModulePath;
2254 }
2255
2256 @Override
2257 protected void setUseModulePath(boolean useModulePath) {
2258 this.useModulePath = useModulePath;
2259 }
2260
2261 @Override
2262 protected String getEnableProcessChecker() {
2263 return null;
2264 }
2265
2266 @Override
2267 protected ForkNodeFactory getForkNode() {
2268 return null;
2269 }
2270
2271 @Override
2272 protected Artifact getMojoArtifact() {
2273 return new DefaultArtifact(
2274 "org.apache.maven.surefire",
2275 "maven-surefire-plugin",
2276 createFromVersion("1"),
2277 null,
2278 "jar",
2279 null,
2280 mock(ArtifactHandler.class));
2281 }
2282
2283 @Override
2284 public File getSystemPropertiesFile() {
2285 return null;
2286 }
2287
2288 @Override
2289 public void setSystemPropertiesFile(File systemPropertiesFile) {}
2290
2291 public void setToolchain(Toolchain toolchain) {
2292 setInternalState(this, "toolchain", toolchain);
2293 }
2294
2295 public void setJvm(String jvm) {
2296 setInternalState(this, "jvm", jvm);
2297 }
2298
2299 @Override
2300 public int getFailOnFlakeCount() {
2301 return failOnFlakeCount;
2302 }
2303
2304 @Override
2305 public void setFailOnFlakeCount(int failOnFlakeCount) {
2306 this.failOnFlakeCount = failOnFlakeCount;
2307 }
2308
2309 @Override
2310 public String[] getIncludeJUnit5Engines() {
2311 return includeJUnit5Engines;
2312 }
2313
2314 @Override
2315 public void setIncludeJUnit5Engines(String[] includeJUnit5Engines) {
2316 this.includeJUnit5Engines = includeJUnit5Engines;
2317 }
2318
2319 @Override
2320 public String[] getExcludeJUnit5Engines() {
2321 return excludeJUnit5Engines;
2322 }
2323
2324 @Override
2325 public void setExcludeJUnit5Engines(String[] excludeJUnit5Engines) {
2326 this.excludeJUnit5Engines = excludeJUnit5Engines;
2327 }
2328 }
2329
2330 @Test
2331 public void shouldNotPerformMethodFilteringOnIncludes() throws Exception {
2332 Mojo plugin = new Mojo();
2333
2334 File includesExcludes = SureFireFileManager.createTempFile("surefire", "includes");
2335 FileUtils.write(includesExcludes, "AnotherTest#method", UTF_8);
2336 plugin.setIncludesFile(includesExcludes);
2337
2338 List<String> includes = new LinkedList<>();
2339 includes.add("AnotherTest#method ");
2340 plugin.setIncludes(includes);
2341
2342 VersionRange version = VersionRange.createFromVersion("1.0");
2343 ArtifactHandler handler = new DefaultArtifactHandler();
2344 Artifact testDeps = new DefaultArtifact("g", "a", version, "compile", "jar", null, handler);
2345 File artifactFile = SureFireFileManager.createTempFile("surefire", ".jar");
2346 artifactFile.deleteOnExit();
2347 testDeps.setFile(artifactFile);
2348 plugin.setProjectTestArtifacts(singletonList(testDeps));
2349 plugin.setDependenciesToScan(new String[] {"g:a"});
2350
2351 e.expectMessage("Method filter prohibited in includes|excludes parameter: AnotherTest#method ");
2352 plugin.scanDependencies();
2353 }
2354
2355 @Test
2356 public void shouldFilterTestsOnIncludesFile() throws Exception {
2357 Mojo plugin = new Mojo();
2358
2359 plugin.setLogger(mock(Logger.class));
2360
2361 File includes = SureFireFileManager.createTempFile("surefire", "includes");
2362 FileUtils.write(includes, "AnotherTest#method", UTF_8);
2363 plugin.setIncludesFile(includes);
2364
2365 VersionRange version = VersionRange.createFromVersion("1.0");
2366 ArtifactHandler handler = new DefaultArtifactHandler();
2367 Artifact testDeps = new DefaultArtifact("g", "a", version, "compile", "test-jar", null, handler);
2368 File artifactFile = SureFireFileManager.createTempFile("surefire", "classes");
2369 String classDir = artifactFile.getCanonicalPath();
2370 assertThat(artifactFile.delete()).isTrue();
2371 File classes = new File(classDir);
2372 assertThat(classes.mkdir()).isTrue();
2373 testDeps.setFile(classes);
2374 assertThat(new File(classes, "AnotherTest.class").createNewFile()).isTrue();
2375 plugin.setProjectTestArtifacts(singletonList(testDeps));
2376 plugin.setDependenciesToScan(new String[] {"g:a"});
2377
2378 DefaultScanResult result = plugin.scanDependencies();
2379 assertThat(result.getClasses()).hasSize(1);
2380 assertThat(result.getClasses().iterator().next()).isEqualTo("AnotherTest");
2381 }
2382
2383 @Test
2384 public void shouldFilterTestsOnExcludesFile() throws Exception {
2385 Mojo plugin = new Mojo();
2386
2387 plugin.setLogger(mock(Logger.class));
2388
2389 File excludes = SureFireFileManager.createTempFile("surefire", "-excludes");
2390 FileUtils.write(excludes, "AnotherTest", UTF_8);
2391 plugin.setExcludesFile(excludes);
2392
2393 VersionRange version = VersionRange.createFromVersion("1.0");
2394 ArtifactHandler handler = new DefaultArtifactHandler();
2395 Artifact testDeps = new DefaultArtifact("g", "a", version, "compile", "test-jar", null, handler);
2396 File artifactFile = SureFireFileManager.createTempFile("surefire", "-classes");
2397 String classDir = artifactFile.getCanonicalPath();
2398 assertThat(artifactFile.delete()).isTrue();
2399 File classes = new File(classDir);
2400 assertThat(classes.mkdir()).isTrue();
2401 testDeps.setFile(classes);
2402 assertThat(new File(classes, "AnotherTest.class").createNewFile()).isTrue();
2403 plugin.setProjectTestArtifacts(singletonList(testDeps));
2404 plugin.setDependenciesToScan(new String[] {"g:a"});
2405
2406 DefaultScanResult result = plugin.scanDependencies();
2407 assertThat(result.getClasses()).isEmpty();
2408 }
2409
2410 @Test
2411 public void shouldFilterTestsOnExcludes() throws Exception {
2412 Mojo plugin = new Mojo();
2413
2414 plugin.setLogger(mock(Logger.class));
2415
2416 plugin.setExcludes(singletonList("AnotherTest"));
2417
2418 VersionRange version = VersionRange.createFromVersion("1.0");
2419 ArtifactHandler handler = new DefaultArtifactHandler();
2420 Artifact testDeps = new DefaultArtifact("g", "a", version, "compile", "jar", null, handler);
2421 File artifactFile = SureFireFileManager.createTempFile("surefire", "-classes");
2422 String classDir = artifactFile.getCanonicalPath();
2423 assertThat(artifactFile.delete()).isTrue();
2424 File classes = new File(classDir);
2425 assertThat(classes.mkdir()).isTrue();
2426 testDeps.setFile(classes);
2427 assertThat(new File(classes, "AnotherTest.class").createNewFile()).isTrue();
2428 plugin.setProjectTestArtifacts(singletonList(testDeps));
2429 plugin.setDependenciesToScan(new String[] {"g:a"});
2430
2431 DefaultScanResult result = plugin.scanDependencies();
2432 assertThat(result.getClasses()).isEmpty();
2433 }
2434
2435 @Test
2436 public void shouldUseOnlySpecificTests() throws Exception {
2437 Mojo plugin = new Mojo();
2438
2439 plugin.setLogger(mock(Logger.class));
2440
2441 File includes = SureFireFileManager.createTempFile("surefire", "-includes");
2442 FileUtils.write(includes, "AnotherTest", UTF_8);
2443 plugin.setIncludesFile(includes);
2444 plugin.setTest("DifferentTest");
2445
2446 VersionRange version = VersionRange.createFromVersion("1.0");
2447 ArtifactHandler handler = new DefaultArtifactHandler();
2448 Artifact testDeps = new DefaultArtifact("g", "a", version, "compile", "test-jar", null, handler);
2449 File artifactFile = SureFireFileManager.createTempFile("surefire", "-classes");
2450 String classDir = artifactFile.getCanonicalPath();
2451 assertThat(artifactFile.delete()).isTrue();
2452 File classes = new File(classDir);
2453 assertThat(classes.mkdir()).isTrue();
2454 testDeps.setFile(classes);
2455 assertThat(new File(classes, "AnotherTest.class").createNewFile()).isTrue();
2456 plugin.setProjectTestArtifacts(singletonList(testDeps));
2457 plugin.setDependenciesToScan(new String[] {"g:a"});
2458
2459 DefaultScanResult result = plugin.scanDependencies();
2460 assertThat(result.getClasses()).isEmpty();
2461 }
2462
2463 private static File mockFile(String absolutePath) {
2464 File f = mock(File.class);
2465 when(f.getAbsolutePath()).thenReturn(absolutePath);
2466 return f;
2467 }
2468
2469 private static Dependency toDependency(Artifact artifact) {
2470 Dependency dependency = new Dependency();
2471 dependency.setGroupId(artifact.getGroupId());
2472 dependency.setArtifactId(artifact.getArtifactId());
2473 dependency.setVersion(artifact.getBaseVersion());
2474 dependency.setType("jar");
2475 return dependency;
2476 }
2477
2478 private static List<Dependency> toDependencies(Artifact... artifacts) {
2479 List<Dependency> dependencies = new ArrayList<>();
2480 for (Artifact artifact : artifacts) {
2481 dependencies.add(toDependency(artifact));
2482 }
2483 return dependencies;
2484 }
2485 }