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.RunListener;
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 RunListener createReporter()
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>(), false, "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>(), false, "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 testNullRunOrderParameters()
123 {
124 SurefireReflector surefireReflector = getReflector();
125 Object foo = getFoo();
126
127 surefireReflector.setRunOrderParameters( foo, null );
128 assertTrue( isCalled( foo ) );
129 assertNull( ( (Foo) foo ).getRunOrderCalculator() );
130 }
131
132 public void testTestSuiteDefinition()
133 {
134 SurefireReflector surefireReflector = getReflector();
135 Object foo = getFoo();
136
137 TestRequest testSuiteDefinition =
138 new TestRequest( asList( new File( "file1" ), new File( "file2" ) ),
139 new File( "TestSOurce" ), new TestListResolver( "aUserRequestedTest#aMethodRequested" ) );
140 surefireReflector.setTestSuiteDefinition( foo, testSuiteDefinition );
141 assertTrue( isCalled( foo ) );
142 assertNotNull( ( (Foo) foo ).getTestRequest() );
143 }
144
145 public void testNullTestSuiteDefinition()
146 {
147 SurefireReflector surefireReflector = getReflector();
148 Object foo = getFoo();
149 surefireReflector.setTestSuiteDefinition( foo, null );
150 assertTrue( isCalled( foo ) );
151 assertNull( ( (Foo) foo ).getTestRequest() );
152 }
153
154 public void testProviderProperties()
155 {
156 SurefireReflector surefireReflector = getReflector();
157 Object foo = getFoo();
158
159 surefireReflector.setProviderProperties( foo, new HashMap<String, String>() );
160 assertTrue( isCalled( foo ) );
161 }
162
163 public void testReporterConfiguration()
164 {
165 SurefireReflector surefireReflector = getReflector();
166 Object foo = getFoo();
167
168 ReporterConfiguration reporterConfiguration = getReporterConfiguration();
169 surefireReflector.setReporterConfigurationAware( foo, reporterConfiguration );
170 assertTrue( isCalled( foo ) );
171 }
172
173 private ReporterConfiguration getReporterConfiguration()
174 {
175 return new ReporterConfiguration( new File( "CDE" ), true );
176 }
177
178 public void testTestClassLoader()
179 {
180 SurefireReflector surefireReflector = getReflector();
181 Object foo = getFoo();
182
183 surefireReflector.setTestClassLoader( foo, getClass().getClassLoader() );
184 assertTrue( isCalled( foo ) );
185 }
186
187 public void testTestClassLoaderAware()
188 {
189 SurefireReflector surefireReflector = getReflector();
190 Object foo = getFoo();
191
192 surefireReflector.setTestClassLoaderAware( foo, getClass().getClassLoader() );
193 assertTrue( isCalled( foo ) );
194 }
195
196 public void testArtifactInfo()
197 {
198 SurefireReflector surefireReflector = getReflector();
199 Object foo = getFoo();
200
201 TestArtifactInfo testArtifactInfo = new TestArtifactInfo( "12.3", "test" );
202 surefireReflector.setTestArtifactInfo( foo, testArtifactInfo );
203 assertTrue( isCalled( foo ) );
204 }
205
206 public void testNullArtifactInfo()
207 {
208 SurefireReflector surefireReflector = getReflector();
209 Object foo = getFoo();
210
211 surefireReflector.setTestArtifactInfo( foo, null );
212 assertTrue( isCalled( foo ) );
213 assertNull( ( (Foo) foo ).getTestArtifactInfo() );
214 }
215
216 public void testArtifactInfoAware()
217 {
218 SurefireReflector surefireReflector = getReflector();
219 Object foo = getFoo();
220
221 TestArtifactInfo testArtifactInfo = new TestArtifactInfo( "12.3", "test" );
222 surefireReflector.setTestArtifactInfoAware( foo, testArtifactInfo );
223 assertTrue( isCalled( foo ) );
224 assertEquals( testArtifactInfo.getClassifier(), "test" );
225 assertEquals( testArtifactInfo.getVersion(), "12.3" );
226 }
227
228 public void testReporterFactory()
229 {
230 SurefireReflector surefireReflector = getReflector();
231 Object foo = getFoo();
232
233 ReporterFactory reporterFactory = new ReporterFactory()
234 {
235 @Override
236 public RunListener createReporter()
237 {
238 return null;
239 }
240
241 @Override
242 public RunResult close()
243 {
244 return null;
245 }
246 };
247
248 surefireReflector.setReporterFactory( foo, reporterFactory );
249 assertTrue( isCalled( foo ) );
250 }
251
252 public void testReporterFactoryAware()
253 {
254 SurefireReflector surefireReflector = getReflector();
255 Object foo = getFoo();
256
257 ReporterFactory reporterFactory = new ReporterFactory()
258 {
259 @Override
260 public RunListener createReporter()
261 {
262 return null;
263 }
264
265 @Override
266 public RunResult close()
267 {
268 return null;
269 }
270 };
271
272 surefireReflector.setReporterFactoryAware( foo, reporterFactory );
273 assertTrue( isCalled( foo ) );
274 assertSame( ( (Foo) foo ).getReporterFactory(), reporterFactory );
275 }
276
277 @SuppressWarnings( "checkstyle:magicnumber" )
278 public void testConvertIfRunResult()
279 {
280 RunResult runResult = new RunResult( 20, 1, 2, 3, 4, "IOException", true );
281 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
282 RunResult obj = (RunResult) reflector.convertIfRunResult( runResult );
283 assertEquals( obj.getCompletedCount(), 20 );
284 assertEquals( obj.getErrors(), 1 );
285 assertEquals( obj.getFailures(), 2 );
286 assertEquals( obj.getSkipped(), 3 );
287 assertFalse( obj.isErrorFree() );
288 assertFalse( obj.isInternalError() );
289 assertEquals( obj.getFailsafeCode(), (Integer) RunResult.FAILURE );
290
291 assertNull( reflector.convertIfRunResult( null ) );
292 assertEquals( reflector.convertIfRunResult( "" ), "" );
293 }
294
295 public void testInstantiateProvider()
296 {
297 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
298 Object booterParams = getFoo();
299 Object provider = reflector.instantiateProvider( DummyProvider.class.getName(), booterParams );
300 assertNotNull( provider );
301 assertEquals( provider.getClass(), DummyProvider.class );
302 }
303
304 public void testSetMainCliOptions()
305 {
306 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
307 Object booterParams = getFoo();
308 reflector.setMainCliOptions( booterParams, asList( SHOW_ERRORS, LOGGING_LEVEL_DEBUG ) );
309 assertEquals( ( (BaseProviderFactory) booterParams ).getMainCliOptions().size(), 2 );
310 assertEquals( ( (BaseProviderFactory) booterParams ).getMainCliOptions().get( 0 ), SHOW_ERRORS );
311 assertEquals( ( (BaseProviderFactory) booterParams ).getMainCliOptions().get( 1 ), LOGGING_LEVEL_DEBUG );
312 }
313
314 public void testSetSkipAfterFailureCount()
315 {
316 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
317 Foo booterParams = (Foo) getFoo();
318 assertEquals( booterParams.getSkipAfterFailureCount(), 0 );
319 reflector.setSkipAfterFailureCount( booterParams, 5 );
320 assertEquals( booterParams.getSkipAfterFailureCount(), 5 );
321 }
322
323 @SuppressWarnings( "checkstyle:magicnumber" )
324 public void testSetSystemExitTimeout()
325 {
326 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
327 Foo booterParams = (Foo) getFoo();
328 assertNull( booterParams.getSystemExitTimeout() );
329 reflector.setSystemExitTimeout( booterParams, 60 );
330 assertEquals( booterParams.getSystemExitTimeout(), (Integer) 60 );
331 }
332
333 public void testSetTestSuiteDefinitionAware()
334 {
335 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
336 Foo booterParams = (Foo) getFoo();
337 TestRequest request = new TestRequest( Collections.emptyList(), null, null );
338 reflector.setTestSuiteDefinitionAware( booterParams, request );
339 assertTrue( booterParams.isCalled() );
340 assertNotNull( booterParams.getTestRequest() );
341 assertTrue( booterParams.getTestRequest().getSuiteXmlFiles().isEmpty() );
342 assertNull( booterParams.getTestRequest().getTestSourceDirectory() );
343 assertNull( booterParams.getTestRequest().getTestListResolver() );
344 assertEquals( booterParams.getTestRequest().getRerunFailingTestsCount(), 0 );
345 }
346
347 public void testSetProviderPropertiesAware()
348 {
349 SurefireReflector reflector = new SurefireReflector( Thread.currentThread().getContextClassLoader() );
350 Foo booterParams = (Foo) getFoo();
351 reflector.setProviderPropertiesAware( booterParams, Collections.singletonMap( "k", "v" ) );
352 assertTrue( booterParams.isCalled() );
353 assertNotNull( booterParams.getProviderProperties() );
354 assertEquals( booterParams.getProviderProperties().size(), 1 );
355 assertEquals( booterParams.getProviderProperties().get( "k" ), "v" );
356 }
357
358 private SurefireReflector getReflector()
359 {
360 return new SurefireReflector( getClass().getClassLoader() );
361 }
362
363 private Object getFoo()
364 {
365 return new Foo();
366 }
367
368 private Boolean isCalled( Object foo )
369 {
370 final Method isCalled;
371 try
372 {
373 isCalled = foo.getClass().getMethod( "isCalled" );
374 return (Boolean) isCalled.invoke( foo );
375 }
376 catch ( ReflectiveOperationException e )
377 {
378 throw new RuntimeException( e );
379 }
380 }
381
382
383
384
385 public static final class DummyProvider implements SurefireProvider
386 {
387 public DummyProvider( ProviderParameters providerParameters )
388 {
389 }
390
391 @Override
392 public Iterable<Class<?>> getSuites()
393 {
394 return null;
395 }
396
397 @Override
398 public RunResult invoke( Object forkTestSet )
399 {
400 return null;
401 }
402
403 @Override
404 public void cancel()
405 {
406
407 }
408 }
409 }