1 package org.apache.maven.surefire.booter;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import junit.framework.TestCase;
23 import org.apache.maven.surefire.api.booter.BaseProviderFactory;
24 import org.apache.maven.surefire.api.provider.ProviderParameters;
25 import org.apache.maven.surefire.api.provider.SurefireProvider;
26 import org.apache.maven.surefire.api.report.ReporterConfiguration;
27 import org.apache.maven.surefire.api.report.ReporterFactory;
28 import org.apache.maven.surefire.api.report.TestReportListener;
29 import org.apache.maven.surefire.api.suite.RunResult;
30 import org.apache.maven.surefire.api.testset.DirectoryScannerParameters;
31 import org.apache.maven.surefire.api.testset.RunOrderParameters;
32 import org.apache.maven.surefire.api.testset.TestArtifactInfo;
33 import org.apache.maven.surefire.api.testset.TestListResolver;
34 import org.apache.maven.surefire.api.testset.TestRequest;
35 import org.apache.maven.surefire.api.util.RunOrder;
36
37 import java.io.File;
38 import java.lang.reflect.Method;
39 import java.util.ArrayList;
40 import java.util.Collections;
41 import java.util.HashMap;
42
43 import static java.util.Arrays.asList;
44 import static org.apache.maven.surefire.api.cli.CommandLineOption.LOGGING_LEVEL_DEBUG;
45 import static org.apache.maven.surefire.api.cli.CommandLineOption.SHOW_ERRORS;
46
47
48
49
50 public class SurefireReflectorTest
51 extends TestCase
52 {
53 public void testShouldCreateFactoryWithoutException()
54 {
55 ReporterFactory factory = new ReporterFactory()
56 {
57 @Override
58 public TestReportListener createTestReportListener()
59 {
60 return null;
61 }
62
63 @Override
64 public RunResult close()
65 {
66 return null;
67 }
68 };
69 ClassLoader cl = Thread.currentThread().getContextClassLoader();
70 SurefireReflector reflector = new SurefireReflector( cl );
71 BaseProviderFactory bpf = (BaseProviderFactory) reflector.createBooterConfiguration( cl, true );
72 bpf.setReporterFactory( factory );
73 assertNotNull( bpf.getReporterFactory() );
74 assertSame( factory, bpf.getReporterFactory() );
75 }
76
77 public void testSetDirectoryScannerParameters()
78 {
79 SurefireReflector surefireReflector = getReflector();
80 Object foo = getFoo();
81
82 DirectoryScannerParameters directoryScannerParameters =
83 new DirectoryScannerParameters( new File( "ABC" ), new ArrayList<String>(), new ArrayList<String>(),
84 new ArrayList<String>(), "hourly" );
85 surefireReflector.setDirectoryScannerParameters( foo, directoryScannerParameters );
86 assertTrue( isCalled( foo ) );
87 assertNotNull( ( (Foo) foo ).getDirectoryScannerParameters() );
88 }
89
90 public void testNullSetDirectoryScannerParameters()
91 {
92 SurefireReflector surefireReflector = getReflector();
93 Object foo = getFoo();
94
95 surefireReflector.setDirectoryScannerParameters( foo, null );
96 assertTrue( isCalled( foo ) );
97 assertNull( ( (Foo) foo ).getDirectoryScannerParameters() );
98 }
99
100 public void testSetIfDirScannerAware()
101 {
102 SurefireReflector surefireReflector = getReflector();
103 Object foo = getFoo();
104
105 DirectoryScannerParameters directoryScannerParameters =
106 new DirectoryScannerParameters( new File( "ABC" ), new ArrayList<String>(), new ArrayList<String>(),
107 new ArrayList<String>(), "hourly" );
108 surefireReflector.setIfDirScannerAware( foo, directoryScannerParameters );
109 assertTrue( isCalled( foo ) );
110 }
111
112 public void testRunOrderParameters()
113 {
114 SurefireReflector surefireReflector = getReflector();
115 Object foo = getFoo();
116
117 RunOrderParameters runOrderParameters = new RunOrderParameters( RunOrder.DEFAULT, new File( "." ) );
118 surefireReflector.setRunOrderParameters( foo, runOrderParameters );
119 assertTrue( isCalled( foo ) );
120 }
121
122 public void testRunOrderParametersWithRunOrderRandomSeed()
123 {
124 SurefireReflector surefireReflector = getReflector();
125 Object foo = getFoo();
126
127
128 Long runOrderRandomSeed = 5L;
129
130 RunOrderParameters runOrderParameters = new RunOrderParameters( RunOrder.DEFAULT, new File( "." ),
131 runOrderRandomSeed );
132 surefireReflector.setRunOrderParameters( foo, runOrderParameters );
133 assertTrue( isCalled( foo ) );
134 }
135
136 public void testNullRunOrderParameters()
137 {
138 SurefireReflector surefireReflector = getReflector();
139 Object foo = getFoo();
140
141 surefireReflector.setRunOrderParameters( foo, null );
142 assertTrue( isCalled( foo ) );
143 try
144 {
145 ( (Foo) foo ).getRunOrderCalculator();
146 }
147 catch ( NullPointerException e )
148 {
149 return;
150 }
151 fail();
152 }
153
154 public void testTestSuiteDefinition()
155 {
156 SurefireReflector surefireReflector = getReflector();
157 Object foo = getFoo();
158
159 TestRequest testSuiteDefinition =
160 new TestRequest( asList( new File( "file1" ), new File( "file2" ) ),
161 new File( "TestSOurce" ), new TestListResolver( "aUserRequestedTest#aMethodRequested" ) );
162 surefireReflector.setTestSuiteDefinition( foo, testSuiteDefinition );
163 assertTrue( isCalled( foo ) );
164 assertNotNull( ( (Foo) foo ).getTestRequest() );
165 }
166
167 public void testNullTestSuiteDefinition()
168 {
169 SurefireReflector surefireReflector = getReflector();
170 Object foo = getFoo();
171 surefireReflector.setTestSuiteDefinition( foo, null );
172 assertTrue( isCalled( foo ) );
173 assertNull( ( (Foo) foo ).getTestRequest() );
174 }
175
176 public void testProviderProperties()
177 {
178 SurefireReflector surefireReflector = getReflector();
179 Object foo = getFoo();
180
181 surefireReflector.setProviderProperties( foo, new HashMap<String, String>() );
182 assertTrue( isCalled( foo ) );
183 }
184
185 public void testReporterConfiguration()
186 {
187 SurefireReflector surefireReflector = getReflector();
188 Object foo = getFoo();
189
190 ReporterConfiguration reporterConfiguration = getReporterConfiguration();
191 surefireReflector.setReporterConfigurationAware( foo, reporterConfiguration );
192 assertTrue( isCalled( foo ) );
193 }
194
195 private ReporterConfiguration getReporterConfiguration()
196 {
197 return new ReporterConfiguration( new File( "CDE" ), true );
198 }
199
200 public void testTestClassLoader()
201 {
202 SurefireReflector surefireReflector = getReflector();
203 Object foo = getFoo();
204
205 surefireReflector.setTestClassLoader( foo, getClass().getClassLoader() );
206 assertTrue( isCalled( foo ) );
207 }
208
209 public void testTestClassLoaderAware()
210 {
211 SurefireReflector surefireReflector = getReflector();
212 Object foo = getFoo();
213
214 surefireReflector.setTestClassLoaderAware( foo, getClass().getClassLoader() );
215 assertTrue( isCalled( foo ) );
216 }
217
218 public void testArtifactInfo()
219 {
220 SurefireReflector surefireReflector = getReflector();
221 Object foo = getFoo();
222
223 TestArtifactInfo testArtifactInfo = new TestArtifactInfo( "12.3", "test" );
224 surefireReflector.setTestArtifactInfo( foo, testArtifactInfo );
225 assertTrue( isCalled( foo ) );
226 }
227
228 public void testNullArtifactInfo()
229 {
230 SurefireReflector surefireReflector = getReflector();
231 Object foo = getFoo();
232
233 surefireReflector.setTestArtifactInfo( foo, null );
234 assertTrue( isCalled( foo ) );
235 assertNull( ( (Foo) foo ).getTestArtifactInfo() );
236 }
237
238 public void testArtifactInfoAware()
239 {
240 SurefireReflector surefireReflector = getReflector();
241 Object foo = getFoo();
242
243 TestArtifactInfo testArtifactInfo = new TestArtifactInfo( "12.3", "test" );
244 surefireReflector.setTestArtifactInfoAware( foo, testArtifactInfo );
245 assertTrue( isCalled( foo ) );
246 assertEquals( testArtifactInfo.getClassifier(), "test" );
247 assertEquals( testArtifactInfo.getVersion(), "12.3" );
248 }
249
250 public void testReporterFactory()
251 {
252 SurefireReflector surefireReflector = getReflector();
253 Object foo = getFoo();
254
255 ReporterFactory reporterFactory = new ReporterFactory()
256 {
257 @Override
258 public TestReportListener createTestReportListener()
259 {
260 return null;
261 }
262
263 @Override
264 public RunResult close()
265 {
266 return null;
267 }
268 };
269
270 surefireReflector.setReporterFactory( foo, reporterFactory );
271 assertTrue( isCalled( foo ) );
272 }
273
274 public void testReporterFactoryAware()
275 {
276 SurefireReflector surefireReflector = getReflector();
277 Object foo = getFoo();
278
279 ReporterFactory reporterFactory = new ReporterFactory()
280 {
281 @Override
282 public TestReportListener createTestReportListener()
283 {
284 return null;
285 }
286
287 @Override
288 public RunResult close()
289 {
290 return null;
291 }
292 };
293
294 surefireReflector.setReporterFactoryAware( foo, reporterFactory );
295 assertTrue( isCalled( foo ) );
296 assertSame( ( (Foo) foo ).getReporterFactory(), reporterFactory );
297 }
298
299 @SuppressWarnings( "checkstyle:magicnumber" )
300 public void testConvertIfRunResult()
301 {
302 RunResult runResult = new RunResult( 20, 1, 2, 3, 4, "IOException", true );
303 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
304 RunResult obj = (RunResult) reflector.convertIfRunResult( runResult );
305 assertEquals( obj.getCompletedCount(), 20 );
306 assertEquals( obj.getErrors(), 1 );
307 assertEquals( obj.getFailures(), 2 );
308 assertEquals( obj.getSkipped(), 3 );
309 assertFalse( obj.isErrorFree() );
310 assertFalse( obj.isInternalError() );
311 assertEquals( obj.getFailsafeCode(), (Integer) RunResult.FAILURE );
312
313 assertNull( reflector.convertIfRunResult( null ) );
314 assertEquals( reflector.convertIfRunResult( "" ), "" );
315 }
316
317 public void testInstantiateProvider()
318 {
319 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
320 Object booterParams = getFoo();
321 Object provider = reflector.instantiateProvider( DummyProvider.class.getName(), booterParams );
322 assertNotNull( provider );
323 assertEquals( provider.getClass(), DummyProvider.class );
324 }
325
326 public void testSetMainCliOptions()
327 {
328 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
329 Object booterParams = getFoo();
330 reflector.setMainCliOptions( booterParams, asList( SHOW_ERRORS, LOGGING_LEVEL_DEBUG ) );
331 assertEquals( ( (BaseProviderFactory) booterParams ).getMainCliOptions().size(), 2 );
332 assertEquals( ( (BaseProviderFactory) booterParams ).getMainCliOptions().get( 0 ), SHOW_ERRORS );
333 assertEquals( ( (BaseProviderFactory) booterParams ).getMainCliOptions().get( 1 ), LOGGING_LEVEL_DEBUG );
334 }
335
336 public void testSetSkipAfterFailureCount()
337 {
338 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
339 Foo booterParams = (Foo) getFoo();
340 assertEquals( booterParams.getSkipAfterFailureCount(), 0 );
341 reflector.setSkipAfterFailureCount( booterParams, 5 );
342 assertEquals( booterParams.getSkipAfterFailureCount(), 5 );
343 }
344
345 @SuppressWarnings( "checkstyle:magicnumber" )
346 public void testSetSystemExitTimeout()
347 {
348 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
349 Foo booterParams = (Foo) getFoo();
350 assertNull( booterParams.getSystemExitTimeout() );
351 reflector.setSystemExitTimeout( booterParams, 60 );
352 assertEquals( booterParams.getSystemExitTimeout(), (Integer) 60 );
353 }
354
355 public void testSetTestSuiteDefinitionAware()
356 {
357 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
358 Foo booterParams = (Foo) getFoo();
359 TestRequest request = new TestRequest( Collections.emptyList(), null, null );
360 reflector.setTestSuiteDefinitionAware( booterParams, request );
361 assertTrue( booterParams.isCalled() );
362 assertNotNull( booterParams.getTestRequest() );
363 assertTrue( booterParams.getTestRequest().getSuiteXmlFiles().isEmpty() );
364 assertNull( booterParams.getTestRequest().getTestSourceDirectory() );
365 assertNull( booterParams.getTestRequest().getTestListResolver() );
366 assertEquals( booterParams.getTestRequest().getRerunFailingTestsCount(), 0 );
367 }
368
369 public void testSetProviderPropertiesAware()
370 {
371 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
372 Foo booterParams = (Foo) getFoo();
373 reflector.setProviderPropertiesAware( booterParams, Collections.singletonMap( "k", "v" ) );
374 assertTrue( booterParams.isCalled() );
375 assertNotNull( booterParams.getProviderProperties() );
376 assertEquals( booterParams.getProviderProperties().size(), 1 );
377 assertEquals( booterParams.getProviderProperties().get( "k" ), "v" );
378 }
379
380 private SurefireReflector getReflector()
381 {
382 return new SurefireReflector( getClass().getClassLoader() );
383 }
384
385 private Object getFoo()
386 {
387 return new Foo();
388 }
389
390 private Boolean isCalled( Object foo )
391 {
392 final Method isCalled;
393 try
394 {
395 isCalled = foo.getClass().getMethod( "isCalled" );
396 return (Boolean) isCalled.invoke( foo );
397 }
398 catch ( ReflectiveOperationException e )
399 {
400 throw new RuntimeException( e );
401 }
402 }
403
404
405
406
407 public static final class DummyProvider implements SurefireProvider
408 {
409 public DummyProvider( ProviderParameters providerParameters )
410 {
411 }
412
413 @Override
414 public Iterable<Class<?>> getSuites()
415 {
416 return null;
417 }
418
419 @Override
420 public RunResult invoke( Object forkTestSet )
421 {
422 return null;
423 }
424
425 @Override
426 public void cancel()
427 {
428
429 }
430 }
431 }