1 package org.apache.maven.plugin.surefire.booterclient.output;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import org.apache.maven.plugin.surefire.booterclient.MockReporter;
23 import org.apache.maven.plugin.surefire.booterclient.lazytestprovider.NotifiableTestStream;
24 import org.apache.maven.plugin.surefire.extensions.EventConsumerThread;
25 import org.apache.maven.plugin.surefire.log.api.ConsoleLogger;
26 import org.apache.maven.plugin.surefire.report.DefaultReporterFactory;
27 import org.apache.maven.surefire.api.booter.Shutdown;
28 import org.apache.maven.surefire.api.event.ConsoleDebugEvent;
29 import org.apache.maven.surefire.api.event.ConsoleErrorEvent;
30 import org.apache.maven.surefire.api.event.ConsoleInfoEvent;
31 import org.apache.maven.surefire.api.event.ConsoleWarningEvent;
32 import org.apache.maven.surefire.api.event.ControlByeEvent;
33 import org.apache.maven.surefire.api.event.ControlNextTestEvent;
34 import org.apache.maven.surefire.api.event.ControlStopOnNextTestEvent;
35 import org.apache.maven.surefire.api.event.Event;
36 import org.apache.maven.surefire.api.event.StandardStreamErrEvent;
37 import org.apache.maven.surefire.api.event.StandardStreamErrWithNewLineEvent;
38 import org.apache.maven.surefire.api.event.StandardStreamOutEvent;
39 import org.apache.maven.surefire.api.event.StandardStreamOutWithNewLineEvent;
40 import org.apache.maven.surefire.api.event.SystemPropertyEvent;
41 import org.apache.maven.surefire.api.event.TestAssumptionFailureEvent;
42 import org.apache.maven.surefire.api.event.TestErrorEvent;
43 import org.apache.maven.surefire.api.event.TestFailedEvent;
44 import org.apache.maven.surefire.api.event.TestSkippedEvent;
45 import org.apache.maven.surefire.api.event.TestStartingEvent;
46 import org.apache.maven.surefire.api.event.TestSucceededEvent;
47 import org.apache.maven.surefire.api.event.TestsetCompletedEvent;
48 import org.apache.maven.surefire.api.event.TestsetStartingEvent;
49 import org.apache.maven.surefire.extensions.EventHandler;
50 import org.apache.maven.surefire.extensions.ForkNodeArguments;
51 import org.apache.maven.surefire.extensions.util.CountdownCloseable;
52 import org.apache.maven.surefire.api.report.ReportEntry;
53 import org.apache.maven.surefire.api.report.SafeThrowable;
54 import org.apache.maven.surefire.api.report.SimpleReportEntry;
55 import org.apache.maven.surefire.api.report.StackTraceWriter;
56 import org.apache.maven.surefire.api.report.TestSetReportEntry;
57 import org.junit.Test;
58 import org.mockito.ArgumentCaptor;
59
60 import javax.annotation.Nonnull;
61 import java.io.ByteArrayInputStream;
62 import java.io.Closeable;
63 import java.io.File;
64 import java.nio.channels.ReadableByteChannel;
65 import java.util.concurrent.BlockingQueue;
66 import java.util.concurrent.LinkedBlockingQueue;
67 import java.util.concurrent.TimeUnit;
68
69 import static java.nio.channels.Channels.newChannel;
70 import static java.nio.charset.StandardCharsets.UTF_8;
71 import static org.apache.maven.surefire.shared.codec.binary.Base64.encodeBase64String;
72 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_DEBUG;
73 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_ERR;
74 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_INFO;
75 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.CONSOLE_WARN;
76 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.SET_COMPLETED;
77 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.SET_STARTING;
78 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.STDERR;
79 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.STDOUT;
80 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_ASSUMPTION_FAIL;
81 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_ERROR;
82 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_FAILED;
83 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_SKIPPED;
84 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_STARTING;
85 import static org.apache.maven.plugin.surefire.booterclient.MockReporter.TEST_SUCCEEDED;
86 import static org.apache.maven.surefire.api.booter.ForkedProcessEventType.BOOTERCODE_BYE;
87 import static org.apache.maven.surefire.api.booter.ForkedProcessEventType.BOOTERCODE_CONSOLE_ERROR;
88 import static org.apache.maven.surefire.api.report.RunMode.NORMAL_RUN;
89 import static org.fest.assertions.Assertions.assertThat;
90 import static org.fest.assertions.MapAssert.entry;
91 import static org.mockito.ArgumentMatchers.anyString;
92 import static org.mockito.Mockito.any;
93 import static org.mockito.Mockito.eq;
94 import static org.mockito.Mockito.mock;
95 import static org.mockito.Mockito.never;
96 import static org.mockito.Mockito.times;
97 import static org.mockito.Mockito.verify;
98 import static org.mockito.Mockito.verifyNoMoreInteractions;
99 import static org.mockito.Mockito.verifyZeroInteractions;
100 import static org.mockito.Mockito.when;
101
102
103
104
105
106
107
108 public class ForkClientTest
109 {
110 private static final int ELAPSED_TIME = 102;
111
112 @Test( expected = NullPointerException.class )
113 public void shouldFailOnNPE()
114 {
115 String cwd = System.getProperty( "user.dir" );
116 File target = new File( cwd, "target" );
117 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
118 when( factory.getReportsDirectory() )
119 .thenReturn( new File( target, "surefire-reports" ) );
120 ForkClient client = new ForkClient( factory, null, 0 );
121 client.handleEvent( null );
122 }
123
124 @Test
125 public void shouldLogJvmMessage() throws Exception
126 {
127 String nativeStream = "Listening for transport dt_socket at address: bla";
128 EH eventHandler = new EH();
129 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
130 ConsoleLogger logger = mock( ConsoleLogger.class );
131 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
132 when( arguments.getConsoleLogger() ).thenReturn( logger );
133 when( logger.isDebugEnabled() ).thenReturn( false );
134 when( logger.isInfoEnabled() ).thenReturn( true );
135 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
136 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
137 {
138 t.start();
139
140 countdown.awaitClosed();
141
142 verify( logger )
143 .info( "Listening for transport dt_socket at address: bla" );
144 }
145
146 assertThat( eventHandler.sizeOfEventCache() )
147 .isEqualTo( 0 );
148
149 verify( logger ).isDebugEnabled();
150
151 verify( logger ).isInfoEnabled();
152
153 verifyNoMoreInteractions( logger );
154 }
155
156 @Test
157 public void shouldLogJvmError1() throws Exception
158 {
159 String nativeStream = "\nCould not create the Java Virtual Machine\n";
160 EH eventHandler = new EH();
161 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
162 ConsoleLogger logger = mock( ConsoleLogger.class );
163 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
164 when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) );
165 when( arguments.getConsoleLogger() ).thenReturn( logger );
166 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
167 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
168 {
169 t.start();
170
171 countdown.awaitClosed();
172
173 verify( logger )
174 .error( "Could not create the Java Virtual Machine" );
175 }
176
177 assertThat( eventHandler.sizeOfEventCache() )
178 .isEqualTo( 0 );
179
180 verify( logger ).isDebugEnabled();
181
182 verifyNoMoreInteractions( logger );
183 }
184
185 @Test
186 public void shouldLogJvmError2() throws Exception
187 {
188 String nativeStream = "\nError occurred during initialization of VM\n";
189 EH eventHandler = new EH();
190 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
191 ConsoleLogger logger = mock( ConsoleLogger.class );
192 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
193 when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) );
194 when( arguments.getConsoleLogger() ).thenReturn( logger );
195 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
196 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
197 {
198 t.start();
199
200 countdown.awaitClosed();
201
202 verify( logger )
203 .error( "Error occurred during initialization of VM" );
204 }
205
206 assertThat( eventHandler.sizeOfEventCache() )
207 .isEqualTo( 0 );
208
209 verify( logger ).isDebugEnabled();
210
211 verifyNoMoreInteractions( logger );
212 }
213
214 @Test
215 public void shouldLogJvmError3() throws Exception
216 {
217 String nativeStream = "\nError: A fatal exception has occurred. Program will exit.\n";
218 EH eventHandler = new EH();
219 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
220 ConsoleLogger logger = mock( ConsoleLogger.class );
221 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
222 when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) );
223 when( arguments.getConsoleLogger() ).thenReturn( logger );
224 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
225 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
226 {
227 t.start();
228
229 countdown.awaitClosed();
230
231 verify( logger )
232 .error( "Error: A fatal exception has occurred. Program will exit." );
233 }
234
235 assertThat( eventHandler.sizeOfEventCache() )
236 .isEqualTo( 0 );
237
238 verify( logger ).isDebugEnabled();
239
240 verifyNoMoreInteractions( logger );
241 }
242
243 @Test
244 public void shouldLogJvmError4() throws Exception
245 {
246 String nativeStream = "\nCould not reserve enough space for object heap\n";
247 EH eventHandler = new EH();
248 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
249 ConsoleLogger logger = mock( ConsoleLogger.class );
250 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
251 when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) );
252 when( arguments.getConsoleLogger() ).thenReturn( logger );
253 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
254 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
255 {
256 t.start();
257
258 countdown.awaitClosed();
259
260 verify( logger )
261 .error( "Could not reserve enough space for object heap" );
262 }
263
264 assertThat( eventHandler.sizeOfEventCache() )
265 .isEqualTo( 0 );
266
267 verify( logger ).isDebugEnabled();
268
269 verifyNoMoreInteractions( logger );
270 }
271
272 @Test
273 public void shouldLogJvmError5() throws Exception
274 {
275 String nativeStream = "\njava.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api";
276 EH eventHandler = new EH();
277 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
278 ConsoleLogger logger = mock( ConsoleLogger.class );
279 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
280 when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) );
281 when( arguments.getConsoleLogger() ).thenReturn( logger );
282 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
283 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
284 {
285 t.start();
286
287 countdown.awaitClosed();
288
289 verify( logger )
290 .error( "java.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api" );
291 }
292
293 assertThat( eventHandler.sizeOfEventCache() )
294 .isEqualTo( 0 );
295
296 verify( logger ).isDebugEnabled();
297
298 verifyNoMoreInteractions( logger );
299 }
300
301 @Test
302 public void shouldLogJvmError6() throws Exception
303 {
304 String nativeStream = "\njava.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api";
305 EH eventHandler = new EH();
306 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
307 ConsoleLogger logger = mock( ConsoleLogger.class );
308 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
309 when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) );
310 when( arguments.getConsoleLogger() ).thenReturn( logger );
311 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
312 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
313 {
314 t.start();
315
316 countdown.awaitClosed();
317
318 verify( logger )
319 .error( "java.lang.module.FindException: Module java.ws.rs not found, required by com.foo.api" );
320 }
321
322 assertThat( eventHandler.sizeOfEventCache() )
323 .isEqualTo( 0 );
324
325 verify( logger ).isDebugEnabled();
326
327 verifyNoMoreInteractions( logger );
328 }
329
330 @Test
331 public void shouldLogUnorderedErrors() throws Exception
332 {
333 String nativeStream = "unordered error";
334 EH eventHandler = new EH();
335 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
336 ConsoleLogger logger = mock( ConsoleLogger.class );
337 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
338 when( arguments.getConsoleLogger() ).thenReturn( logger );
339 when( logger.isDebugEnabled() )
340 .thenReturn( true );
341 when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) );
342 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
343 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
344 {
345 t.start();
346
347 countdown.awaitClosed();
348
349 verify( logger )
350 .debug( "unordered error" );
351 }
352
353 assertThat( eventHandler.sizeOfEventCache() )
354 .isEqualTo( 0 );
355
356 verify( logger ).isDebugEnabled();
357
358 ArgumentCaptor<String> dumpText = ArgumentCaptor.forClass( String.class );
359 verify( arguments ).dumpStreamText( dumpText.capture() );
360 String msg = "Corrupted STDOUT by directly writing to native stream in forked JVM 0. Stream 'unordered error'.";
361 assertThat( dumpText.getValue() )
362 .isEqualTo( msg );
363
364 ArgumentCaptor<String> warningText = ArgumentCaptor.forClass( String.class );
365 verify( arguments ).logWarningAtEnd( warningText.capture() );
366 assertThat( warningText.getValue() )
367 .startsWith( "Corrupted STDOUT by directly writing to native stream in forked JVM 0. "
368 + "See FAQ web page and the dump file" );
369
370 verifyNoMoreInteractions( logger );
371 }
372
373 @Test
374 public void shouldLogJvmMessageAndProcessEvent() throws Exception
375 {
376 String nativeStream = "Listening for transport dt_socket at address: bla\n:maven-surefire-event:bye:\n";
377 EH eventHandler = new EH();
378 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
379 ConsoleLogger logger = mock( ConsoleLogger.class );
380 when( logger.isDebugEnabled() )
381 .thenReturn( false );
382 when( logger.isInfoEnabled() )
383 .thenReturn( true );
384 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
385 when( arguments.getConsoleLogger() ).thenReturn( logger );
386 when( logger.isDebugEnabled() ).thenReturn( true );
387 when( logger.isInfoEnabled() ).thenReturn( false );
388 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
389 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
390 {
391 t.start();
392
393 Event event = eventHandler.pullEvent();
394 assertThat( event.isControlCategory() )
395 .isTrue();
396 assertThat( event.getEventType() )
397 .isEqualTo( BOOTERCODE_BYE );
398
399 verify( logger )
400 .debug( "Listening for transport dt_socket at address: bla" );
401
402 countdown.awaitClosed();
403 }
404
405 assertThat( eventHandler.sizeOfEventCache() )
406 .isEqualTo( 0 );
407
408 verify( logger ).isDebugEnabled();
409
410 verifyNoMoreInteractions( logger );
411 }
412
413 @Test
414 public void shouldBePossibleToKill()
415 {
416 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
417
418 ForkClient client = new ForkClient( null, notifiableTestStream, 0 );
419 client.kill();
420
421 verify( notifiableTestStream, times( 1 ) )
422 .shutdown( eq( Shutdown.KILL ) );
423 }
424
425 @Test
426 public void shouldAcquireNextTest()
427 {
428 String cwd = System.getProperty( "user.dir" );
429 File target = new File( cwd, "target" );
430 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
431 when( factory.getReportsDirectory() )
432 .thenReturn( new File( target, "surefire-reports" ) );
433 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
434 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
435 client.handleEvent( new ControlNextTestEvent() );
436 verify( notifiableTestStream, times( 1 ) )
437 .provideNewTest();
438 verifyNoMoreInteractions( notifiableTestStream );
439 verifyZeroInteractions( factory );
440 assertThat( client.isSaidGoodBye() )
441 .isFalse();
442 assertThat( client.getErrorInFork() )
443 .isNull();
444 assertThat( client.isErrorInFork() )
445 .isFalse();
446 assertThat( client.hadTimeout() )
447 .isFalse();
448 assertThat( client.hasTestsInProgress() )
449 .isFalse();
450 assertThat( client.testsInProgress() )
451 .isEmpty();
452 assertThat( client.getTestVmSystemProperties() )
453 .isEmpty();
454 }
455
456 @Test
457 public void shouldNotifyWithBye()
458 {
459 String cwd = System.getProperty( "user.dir" );
460 File target = new File( cwd, "target" );
461 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
462 when( factory.getReportsDirectory() )
463 .thenReturn( new File( target, "surefire-reports" ) );
464 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
465
466 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
467 client.handleEvent( new ControlByeEvent() );
468 client.kill();
469
470 verify( notifiableTestStream, times( 1 ) )
471 .acknowledgeByeEventReceived();
472 verify( notifiableTestStream, never() )
473 .shutdown( any( Shutdown.class ) );
474 verifyNoMoreInteractions( notifiableTestStream );
475 verifyZeroInteractions( factory );
476 assertThat( client.isSaidGoodBye() )
477 .isTrue();
478 assertThat( client.getErrorInFork() )
479 .isNull();
480 assertThat( client.isErrorInFork() )
481 .isFalse();
482 assertThat( client.hadTimeout() )
483 .isFalse();
484 assertThat( client.hasTestsInProgress() )
485 .isFalse();
486 assertThat( client.testsInProgress() )
487 .isEmpty();
488 assertThat( client.getTestVmSystemProperties() )
489 .isEmpty();
490 }
491
492 @Test
493 public void shouldStopOnNextTest()
494 {
495 String cwd = System.getProperty( "user.dir" );
496 File target = new File( cwd, "target" );
497 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
498 when( factory.getReportsDirectory() )
499 .thenReturn( new File( target, "surefire-reports" ) );
500 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
501 final boolean[] verified = {false};
502 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 )
503 {
504 @Override
505 protected void stopOnNextTest()
506 {
507 super.stopOnNextTest();
508 verified[0] = true;
509 }
510 };
511 client.handleEvent( new ControlStopOnNextTestEvent() );
512 verifyZeroInteractions( notifiableTestStream );
513 verifyZeroInteractions( factory );
514 assertThat( verified[0] )
515 .isTrue();
516 assertThat( client.isSaidGoodBye() )
517 .isFalse();
518 assertThat( client.getErrorInFork() )
519 .isNull();
520 assertThat( client.isErrorInFork() )
521 .isFalse();
522 assertThat( client.hadTimeout() )
523 .isFalse();
524 assertThat( client.hasTestsInProgress() )
525 .isFalse();
526 assertThat( client.testsInProgress() )
527 .isEmpty();
528 assertThat( client.getTestVmSystemProperties() )
529 .isEmpty();
530 }
531
532 @Test
533 public void shouldReceiveStdOut()
534 {
535 String cwd = System.getProperty( "user.dir" );
536 File target = new File( cwd, "target" );
537 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
538 when( factory.getReportsDirectory() )
539 .thenReturn( new File( target, "surefire-reports" ) );
540 MockReporter receiver = new MockReporter();
541 when( factory.createReporter() )
542 .thenReturn( receiver );
543 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
544 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
545 client.handleEvent( new StandardStreamOutEvent( NORMAL_RUN, "msg" ) );
546 verifyZeroInteractions( notifiableTestStream );
547 verify( factory, times( 1 ) )
548 .createReporter();
549 verifyNoMoreInteractions( factory );
550 assertThat( client.getReporter() )
551 .isNotNull();
552 assertThat( receiver.getEvents() )
553 .hasSize( 1 )
554 .contains( STDOUT );
555 assertThat( receiver.getData() )
556 .hasSize( 1 )
557 .contains( "msg" );
558 assertThat( client.isSaidGoodBye() )
559 .isFalse();
560 assertThat( client.getErrorInFork() )
561 .isNull();
562 assertThat( client.isErrorInFork() )
563 .isFalse();
564 assertThat( client.hadTimeout() )
565 .isFalse();
566 assertThat( client.hasTestsInProgress() )
567 .isFalse();
568 assertThat( client.testsInProgress() )
569 .isEmpty();
570 assertThat( client.getTestVmSystemProperties() )
571 .isEmpty();
572 }
573
574 @Test
575 public void shouldReceiveStdOutNewLine()
576 {
577 String cwd = System.getProperty( "user.dir" );
578 File target = new File( cwd, "target" );
579 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
580 when( factory.getReportsDirectory() )
581 .thenReturn( new File( target, "surefire-reports" ) );
582 MockReporter receiver = new MockReporter();
583 when( factory.createReporter() )
584 .thenReturn( receiver );
585 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
586 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
587 client.handleEvent( new StandardStreamOutWithNewLineEvent( NORMAL_RUN, "msg" ) );
588 verifyZeroInteractions( notifiableTestStream );
589 verify( factory, times( 1 ) )
590 .createReporter();
591 verifyNoMoreInteractions( factory );
592 assertThat( client.getReporter() )
593 .isNotNull();
594 assertThat( receiver.getEvents() )
595 .hasSize( 1 )
596 .contains( STDOUT );
597 assertThat( receiver.getData() )
598 .hasSize( 1 )
599 .contains( "msg\n" );
600 assertThat( client.isSaidGoodBye() )
601 .isFalse();
602 assertThat( client.getErrorInFork() )
603 .isNull();
604 assertThat( client.isErrorInFork() )
605 .isFalse();
606 assertThat( client.hadTimeout() )
607 .isFalse();
608 assertThat( client.hasTestsInProgress() )
609 .isFalse();
610 assertThat( client.testsInProgress() )
611 .isEmpty();
612 assertThat( client.getTestVmSystemProperties() )
613 .isEmpty();
614 }
615
616 @Test
617 public void shouldReceiveStdErr()
618 {
619 String cwd = System.getProperty( "user.dir" );
620 File target = new File( cwd, "target" );
621 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
622 when( factory.getReportsDirectory() )
623 .thenReturn( new File( target, "surefire-reports" ) );
624 MockReporter receiver = new MockReporter();
625 when( factory.createReporter() )
626 .thenReturn( receiver );
627 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
628 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
629 client.handleEvent( new StandardStreamErrEvent( NORMAL_RUN, "msg" ) );
630 verifyZeroInteractions( notifiableTestStream );
631 verify( factory, times( 1 ) )
632 .createReporter();
633 verifyNoMoreInteractions( factory );
634 assertThat( client.getReporter() )
635 .isNotNull();
636 assertThat( receiver.getEvents() )
637 .hasSize( 1 )
638 .contains( STDERR );
639 assertThat( receiver.getData() )
640 .hasSize( 1 )
641 .contains( "msg" );
642 assertThat( client.isSaidGoodBye() )
643 .isFalse();
644 assertThat( client.getErrorInFork() )
645 .isNull();
646 assertThat( client.isErrorInFork() )
647 .isFalse();
648 assertThat( client.hadTimeout() )
649 .isFalse();
650 assertThat( client.hasTestsInProgress() )
651 .isFalse();
652 assertThat( client.testsInProgress() )
653 .isEmpty();
654 assertThat( client.getTestVmSystemProperties() )
655 .isEmpty();
656 }
657
658 @Test
659 public void shouldReceiveStdErrNewLine()
660 {
661 String cwd = System.getProperty( "user.dir" );
662 File target = new File( cwd, "target" );
663 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
664 when( factory.getReportsDirectory() )
665 .thenReturn( new File( target, "surefire-reports" ) );
666 MockReporter receiver = new MockReporter();
667 when( factory.createReporter() )
668 .thenReturn( receiver );
669 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
670 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
671 client.handleEvent( new StandardStreamErrWithNewLineEvent( NORMAL_RUN, "msg" ) );
672 verifyZeroInteractions( notifiableTestStream );
673 verify( factory, times( 1 ) )
674 .createReporter();
675 verifyNoMoreInteractions( factory );
676 assertThat( client.getReporter() )
677 .isNotNull();
678 assertThat( receiver.getEvents() )
679 .hasSize( 1 )
680 .contains( STDERR );
681 assertThat( receiver.getData() )
682 .hasSize( 1 )
683 .contains( "msg\n" );
684 assertThat( client.isSaidGoodBye() )
685 .isFalse();
686 assertThat( client.getErrorInFork() )
687 .isNull();
688 assertThat( client.isErrorInFork() )
689 .isFalse();
690 assertThat( client.hadTimeout() )
691 .isFalse();
692 assertThat( client.hasTestsInProgress() )
693 .isFalse();
694 assertThat( client.testsInProgress() )
695 .isEmpty();
696 assertThat( client.getTestVmSystemProperties() )
697 .isEmpty();
698 }
699
700 @Test
701 public void shouldLogConsoleError()
702 {
703 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
704 MockReporter receiver = new MockReporter();
705 when( factory.createReporter() )
706 .thenReturn( receiver );
707 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
708 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
709 StackTraceWriter stackTrace =
710 new DeserializedStacktraceWriter( "Listening for transport dt_socket at address: 5005", null, null );
711 Event event = new ConsoleErrorEvent( stackTrace );
712 client.handleEvent( event );
713 verifyZeroInteractions( notifiableTestStream );
714 verify( factory, times( 1 ) )
715 .createReporter();
716 verify( factory, times( 1 ) )
717 .getReportsDirectory();
718 verifyNoMoreInteractions( factory );
719 assertThat( client.getReporter() )
720 .isNotNull();
721 assertThat( receiver.getEvents() )
722 .isNotEmpty();
723 assertThat( receiver.getEvents() )
724 .contains( CONSOLE_ERR );
725 assertThat( receiver.getData() )
726 .isNotEmpty();
727 assertThat( receiver.getData() )
728 .contains( "Listening for transport dt_socket at address: 5005" );
729 assertThat( client.isSaidGoodBye() )
730 .isFalse();
731 assertThat( client.isErrorInFork() )
732 .isFalse();
733 assertThat( client.getErrorInFork() )
734 .isNull();
735 assertThat( client.hadTimeout() )
736 .isFalse();
737 assertThat( client.hasTestsInProgress() )
738 .isFalse();
739 assertThat( client.testsInProgress() )
740 .isEmpty();
741 assertThat( client.getTestVmSystemProperties() )
742 .isEmpty();
743 }
744
745 @Test
746 public void shouldLogConsoleErrorWithStackTrace() throws Exception
747 {
748 String nativeStream = ":maven-surefire-event:console-error-log:UTF-8"
749 + ":" + encodeBase64String( "Listening for transport dt_socket at address: 5005".getBytes( UTF_8 ) )
750 + ":" + encodeBase64String( "s1".getBytes( UTF_8 ) )
751 + ":" + encodeBase64String( "s2".getBytes( UTF_8 ) ) + ":";
752 EH eventHandler = new EH();
753 CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 );
754 ConsoleLogger logger = mock( ConsoleLogger.class );
755 ForkNodeArguments arguments = mock( ForkNodeArguments.class );
756 when( arguments.getConsoleLogger() ).thenReturn( logger );
757 ReadableByteChannel channel = newChannel( new ByteArrayInputStream( nativeStream.getBytes() ) );
758 try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) )
759 {
760 t.start();
761
762 Event event = eventHandler.pullEvent();
763 assertThat( event.isConsoleErrorCategory() )
764 .isTrue();
765 assertThat( event.isConsoleCategory() )
766 .isTrue();
767 assertThat( event.getEventType() )
768 .isEqualTo( BOOTERCODE_CONSOLE_ERROR );
769
770 ConsoleErrorEvent consoleEvent = (ConsoleErrorEvent) event;
771 assertThat( consoleEvent.getStackTraceWriter() )
772 .isNotNull();
773 assertThat( consoleEvent.getStackTraceWriter().getThrowable().getMessage() )
774 .isEqualTo( "Listening for transport dt_socket at address: 5005" );
775 assertThat( consoleEvent.getStackTraceWriter().smartTrimmedStackTrace() )
776 .isEqualTo( "s1" );
777 assertThat( consoleEvent.getStackTraceWriter().writeTraceToString() )
778 .isEqualTo( "s2" );
779
780 countdown.awaitClosed();
781
782 verifyZeroInteractions( logger );
783 }
784
785 assertThat( eventHandler.sizeOfEventCache() )
786 .isEqualTo( 0 );
787
788 verifyNoMoreInteractions( logger );
789 }
790
791 @Test
792 public void shouldLogConsoleWarning()
793 {
794 String cwd = System.getProperty( "user.dir" );
795 File target = new File( cwd, "target" );
796 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
797 when( factory.getReportsDirectory() )
798 .thenReturn( new File( target, "surefire-reports" ) );
799 MockReporter receiver = new MockReporter();
800 when( factory.createReporter() )
801 .thenReturn( receiver );
802 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
803 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
804 client.handleEvent( new ConsoleWarningEvent( "s1" ) );
805 verifyZeroInteractions( notifiableTestStream );
806 verify( factory, times( 1 ) )
807 .createReporter();
808 verifyNoMoreInteractions( factory );
809 assertThat( client.getReporter() )
810 .isNotNull();
811 assertThat( receiver.getEvents() )
812 .hasSize( 1 )
813 .contains( CONSOLE_WARN );
814 assertThat( receiver.getData() )
815 .hasSize( 1 )
816 .contains( "s1" );
817 assertThat( client.isSaidGoodBye() )
818 .isFalse();
819 assertThat( client.isErrorInFork() )
820 .isFalse();
821 assertThat( client.getErrorInFork() )
822 .isNull();
823 assertThat( client.hadTimeout() )
824 .isFalse();
825 assertThat( client.hasTestsInProgress() )
826 .isFalse();
827 assertThat( client.testsInProgress() )
828 .isEmpty();
829 assertThat( client.getTestVmSystemProperties() )
830 .isEmpty();
831 }
832
833 @Test
834 public void shouldLogConsoleDebug()
835 {
836 String cwd = System.getProperty( "user.dir" );
837 File target = new File( cwd, "target" );
838 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
839 when( factory.getReportsDirectory() )
840 .thenReturn( new File( target, "surefire-reports" ) );
841 MockReporter receiver = new MockReporter();
842 when( factory.createReporter() )
843 .thenReturn( receiver );
844 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
845 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
846 client.handleEvent( new ConsoleDebugEvent( "s1" ) );
847 verifyZeroInteractions( notifiableTestStream );
848 verify( factory, times( 1 ) )
849 .createReporter();
850 verifyNoMoreInteractions( factory );
851 assertThat( client.getReporter() )
852 .isNotNull();
853 assertThat( receiver.getEvents() )
854 .hasSize( 1 )
855 .contains( CONSOLE_DEBUG );
856 assertThat( receiver.getData() )
857 .hasSize( 1 )
858 .contains( "s1" );
859 assertThat( client.isSaidGoodBye() )
860 .isFalse();
861 assertThat( client.isErrorInFork() )
862 .isFalse();
863 assertThat( client.getErrorInFork() )
864 .isNull();
865 assertThat( client.hadTimeout() )
866 .isFalse();
867 assertThat( client.hasTestsInProgress() )
868 .isFalse();
869 assertThat( client.testsInProgress() )
870 .isEmpty();
871 assertThat( client.getTestVmSystemProperties() )
872 .isEmpty();
873 }
874
875 @Test
876 public void shouldLogConsoleInfo()
877 {
878 String cwd = System.getProperty( "user.dir" );
879 File target = new File( cwd, "target" );
880 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
881 when( factory.getReportsDirectory() )
882 .thenReturn( new File( target, "surefire-reports" ) );
883 MockReporter receiver = new MockReporter();
884 when( factory.createReporter() )
885 .thenReturn( receiver );
886 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
887 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
888 client.handleEvent( new ConsoleInfoEvent( "s1" ) );
889 verifyZeroInteractions( notifiableTestStream );
890 verify( factory, times( 1 ) )
891 .createReporter();
892 verifyNoMoreInteractions( factory );
893 assertThat( client.getReporter() )
894 .isNotNull();
895 assertThat( receiver.getEvents() )
896 .hasSize( 1 )
897 .contains( CONSOLE_INFO );
898 assertThat( receiver.getData() )
899 .hasSize( 1 )
900 .contains( "s1" );
901 assertThat( client.isSaidGoodBye() )
902 .isFalse();
903 assertThat( client.isErrorInFork() )
904 .isFalse();
905 assertThat( client.getErrorInFork() )
906 .isNull();
907 assertThat( client.hadTimeout() )
908 .isFalse();
909 assertThat( client.hasTestsInProgress() )
910 .isFalse();
911 assertThat( client.testsInProgress() )
912 .isEmpty();
913 assertThat( client.getTestVmSystemProperties() )
914 .isEmpty();
915 }
916
917 @Test
918 public void shouldSendSystemProperty()
919 {
920 String cwd = System.getProperty( "user.dir" );
921 File target = new File( cwd, "target" );
922 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
923 when( factory.getReportsDirectory() )
924 .thenReturn( new File( target, "surefire-reports" ) );
925 MockReporter receiver = new MockReporter();
926 when( factory.createReporter() )
927 .thenReturn( receiver );
928 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
929 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
930 client.handleEvent( new SystemPropertyEvent( NORMAL_RUN, "k1", "v1" ) );
931 verifyZeroInteractions( notifiableTestStream );
932 verifyZeroInteractions( factory );
933 assertThat( client.getReporter() )
934 .isNotNull();
935 assertThat( receiver.getEvents() )
936 .isEmpty();
937 assertThat( receiver.getData() )
938 .isEmpty();
939 assertThat( client.isSaidGoodBye() )
940 .isFalse();
941 assertThat( client.isErrorInFork() )
942 .isFalse();
943 assertThat( client.getErrorInFork() )
944 .isNull();
945 assertThat( client.hadTimeout() )
946 .isFalse();
947 assertThat( client.hasTestsInProgress() )
948 .isFalse();
949 assertThat( client.testsInProgress() )
950 .isEmpty();
951 assertThat( client.getTestVmSystemProperties() )
952 .hasSize( 1 );
953 assertThat( client.getTestVmSystemProperties() )
954 .includes( entry( "k1", "v1" ) );
955 }
956
957 @Test
958 public void shouldSendTestsetStartingKilled()
959 {
960 String cwd = System.getProperty( "user.dir" );
961 File target = new File( cwd, "target" );
962 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
963 when( factory.getReportsDirectory() )
964 .thenReturn( new File( target, "surefire-reports" ) );
965 MockReporter receiver = new MockReporter();
966 when( factory.createReporter() )
967 .thenReturn( receiver );
968 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
969
970 final String exceptionMessage = "msg";
971 final String smartStackTrace = "MyTest:86 >> Error";
972 final String stackTrace = "trace line 1\ntrace line 2";
973 final String trimmedStackTrace = "trace line 1";
974
975 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
976 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
977 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
978 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
979 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
980 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
981
982 TestSetReportEntry reportEntry = mock( TestSetReportEntry.class );
983 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
984 when( reportEntry.getGroup() ).thenReturn( "this group" );
985 when( reportEntry.getMessage() ).thenReturn( "some test" );
986 when( reportEntry.getName() ).thenReturn( "my test" );
987 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
988 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
989 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
990
991 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
992 client.handleEvent( new TestsetStartingEvent( NORMAL_RUN, reportEntry ) );
993
994 client.tryToTimeout( System.currentTimeMillis() + 1000L, 1 );
995
996 verify( notifiableTestStream )
997 .shutdown( Shutdown.KILL );
998 verifyNoMoreInteractions( notifiableTestStream );
999 verify( factory ).createReporter();
1000 verifyNoMoreInteractions( factory );
1001 assertThat( client.getReporter() )
1002 .isNotNull();
1003 assertThat( receiver.getEvents() )
1004 .hasSize( 1 );
1005 assertThat( receiver.getEvents() )
1006 .contains( SET_STARTING );
1007 assertThat( receiver.getData() )
1008 .hasSize( 1 );
1009 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1010 .isEqualTo( "pkg.MyTest" );
1011 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1012 .isNull();
1013 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1014 .isEqualTo( "my test" );
1015 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getNameText() )
1016 .isNull();
1017 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getElapsed() )
1018 .isEqualTo( ELAPSED_TIME );
1019 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getMessage() )
1020 .isEqualTo( "some test" );
1021 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getGroup() )
1022 .isEqualTo( "this group" );
1023 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter() )
1024 .isNotNull();
1025 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) )
1026 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1027 .isEqualTo( exceptionMessage );
1028 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1029 .isEqualTo( smartStackTrace );
1030 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTraceToString() )
1031 .isEqualTo( stackTrace );
1032 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1033 .isEqualTo( trimmedStackTrace );
1034 assertThat( client.isSaidGoodBye() )
1035 .isFalse();
1036 assertThat( client.isErrorInFork() )
1037 .isFalse();
1038 assertThat( client.getErrorInFork() )
1039 .isNull();
1040 assertThat( client.hadTimeout() )
1041 .isTrue();
1042 assertThat( client.hasTestsInProgress() )
1043 .isFalse();
1044 assertThat( client.testsInProgress() )
1045 .isEmpty();
1046 assertThat( client.getTestVmSystemProperties() )
1047 .isEmpty();
1048 assertThat( client.getTestVmSystemProperties() )
1049 .isEmpty();
1050 }
1051
1052 @Test
1053 public void shouldSendTestsetStarting()
1054 {
1055 String cwd = System.getProperty( "user.dir" );
1056 File target = new File( cwd, "target" );
1057 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1058 when( factory.getReportsDirectory() )
1059 .thenReturn( new File( target, "surefire-reports" ) );
1060 MockReporter receiver = new MockReporter();
1061 when( factory.createReporter() )
1062 .thenReturn( receiver );
1063 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1064
1065 final String exceptionMessage = "msg";
1066 final String smartStackTrace = "MyTest:86 >> Error";
1067 final String stackTrace = "trace line 1\ntrace line 2";
1068 final String trimmedStackTrace = "trace line 1";
1069
1070 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1071 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1072 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1073 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1074 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1075 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1076
1077 TestSetReportEntry reportEntry = mock( TestSetReportEntry.class );
1078 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1079 when( reportEntry.getGroup() ).thenReturn( "this group" );
1080 when( reportEntry.getMessage() ).thenReturn( "some test" );
1081 when( reportEntry.getName() ).thenReturn( "my test" );
1082 when( reportEntry.getNameText() ).thenReturn( "dn2" );
1083 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1084 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1085 when( reportEntry.getSourceText() ).thenReturn( "dn1" );
1086 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1087
1088 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1089 client.handleEvent( new TestsetStartingEvent( NORMAL_RUN, reportEntry ) );
1090 client.tryToTimeout( System.currentTimeMillis(), 1 );
1091
1092 verifyZeroInteractions( notifiableTestStream );
1093 verify( factory ).createReporter();
1094 verifyNoMoreInteractions( factory );
1095 assertThat( client.getReporter() )
1096 .isNotNull();
1097 assertThat( receiver.getEvents() )
1098 .hasSize( 1 );
1099 assertThat( receiver.getEvents() )
1100 .contains( SET_STARTING );
1101 assertThat( receiver.getData() )
1102 .hasSize( 1 );
1103 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1104 .isEqualTo( "pkg.MyTest" );
1105 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1106 .isEqualTo( "dn1" );
1107 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1108 .isEqualTo( "my test" );
1109 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getNameText() )
1110 .isEqualTo( "dn2" );
1111 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getElapsed() )
1112 .isEqualTo( ELAPSED_TIME );
1113 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getMessage() )
1114 .isEqualTo( "some test" );
1115 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getGroup() )
1116 .isEqualTo( "this group" );
1117 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter() )
1118 .isNotNull();
1119 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) )
1120 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1121 .isEqualTo( "msg" );
1122 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1123 .isEqualTo( smartStackTrace );
1124 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTraceToString() )
1125 .isEqualTo( stackTrace );
1126 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1127 .isEqualTo( trimmedStackTrace );
1128 assertThat( client.isSaidGoodBye() )
1129 .isFalse();
1130 assertThat( client.isErrorInFork() )
1131 .isFalse();
1132 assertThat( client.getErrorInFork() )
1133 .isNull();
1134 assertThat( client.hadTimeout() )
1135 .isFalse();
1136 assertThat( client.hasTestsInProgress() )
1137 .isFalse();
1138 assertThat( client.testsInProgress() )
1139 .isEmpty();
1140 assertThat( client.getTestVmSystemProperties() )
1141 .isEmpty();
1142 assertThat( client.getTestVmSystemProperties() )
1143 .isEmpty();
1144 assertThat( client.getDefaultReporterFactory() )
1145 .isSameAs( factory );
1146 }
1147
1148 @Test
1149 public void shouldSendTestsetCompleted()
1150 {
1151 String cwd = System.getProperty( "user.dir" );
1152 File target = new File( cwd, "target" );
1153 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1154 when( factory.getReportsDirectory() )
1155 .thenReturn( new File( target, "surefire-reports" ) );
1156 MockReporter receiver = new MockReporter();
1157 when( factory.createReporter() )
1158 .thenReturn( receiver );
1159 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1160
1161 final String exceptionMessage = "msg";
1162 final String smartStackTrace = "MyTest:86 >> Error";
1163 final String stackTrace = "trace line 1\ntrace line 2";
1164 final String trimmedStackTrace = "trace line 1";
1165
1166 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1167 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1168 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1169 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1170 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1171 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1172
1173 TestSetReportEntry reportEntry = mock( TestSetReportEntry.class );
1174 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1175 when( reportEntry.getGroup() ).thenReturn( "this group" );
1176 when( reportEntry.getMessage() ).thenReturn( "some test" );
1177 when( reportEntry.getName() ).thenReturn( "my test" );
1178 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1179 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1180 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1181
1182 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1183 client.handleEvent( new TestsetCompletedEvent( NORMAL_RUN, reportEntry ) );
1184
1185 verifyZeroInteractions( notifiableTestStream );
1186 verify( factory ).createReporter();
1187 verifyNoMoreInteractions( factory );
1188 assertThat( client.getReporter() )
1189 .isNotNull();
1190 assertThat( receiver.getEvents() )
1191 .hasSize( 1 );
1192 assertThat( receiver.getEvents() )
1193 .contains( SET_COMPLETED );
1194 assertThat( receiver.getData() )
1195 .hasSize( 1 );
1196 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1197 .isEqualTo( "pkg.MyTest" );
1198 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1199 .isNull();
1200 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1201 .isEqualTo( "my test" );
1202 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getNameText() )
1203 .isNull();
1204 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getElapsed() )
1205 .isEqualTo( ELAPSED_TIME );
1206 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getMessage() )
1207 .isEqualTo( "some test" );
1208 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getGroup() )
1209 .isEqualTo( "this group" );
1210 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter() )
1211 .isNotNull();
1212 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) )
1213 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1214 .isEqualTo( "msg" );
1215 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1216 .isEqualTo( "MyTest:86 >> Error" );
1217 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTraceToString() )
1218 .isEqualTo( stackTrace );
1219 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1220 .isEqualTo( trimmedStackTrace );
1221 assertThat( client.isSaidGoodBye() )
1222 .isFalse();
1223 assertThat( client.isErrorInFork() )
1224 .isFalse();
1225 assertThat( client.getErrorInFork() )
1226 .isNull();
1227 assertThat( client.hadTimeout() )
1228 .isFalse();
1229 assertThat( client.hasTestsInProgress() )
1230 .isFalse();
1231 assertThat( client.testsInProgress() )
1232 .isEmpty();
1233 assertThat( client.getTestVmSystemProperties() )
1234 .isEmpty();
1235 assertThat( client.getTestVmSystemProperties() )
1236 .isEmpty();
1237 assertThat( client.getDefaultReporterFactory() )
1238 .isSameAs( factory );
1239 }
1240
1241 @Test
1242 public void shouldSendTestStarting()
1243 {
1244 String cwd = System.getProperty( "user.dir" );
1245 File target = new File( cwd, "target" );
1246 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1247 when( factory.getReportsDirectory() )
1248 .thenReturn( new File( target, "surefire-reports" ) );
1249 MockReporter receiver = new MockReporter();
1250 when( factory.createReporter() )
1251 .thenReturn( receiver );
1252 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1253
1254 final String exceptionMessage = "msg";
1255 final String smartStackTrace = "MyTest:86 >> Error";
1256 final String stackTrace = "trace line 1\ntrace line 2";
1257 final String trimmedStackTrace = "trace line 1";
1258
1259 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1260 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1261 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1262 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1263 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1264 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1265
1266 ReportEntry reportEntry = mock( ReportEntry.class );
1267 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1268 when( reportEntry.getGroup() ).thenReturn( "this group" );
1269 when( reportEntry.getMessage() ).thenReturn( "some test" );
1270 when( reportEntry.getName() ).thenReturn( "my test" );
1271 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1272 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1273 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1274
1275 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1276 client.handleEvent( new TestStartingEvent( NORMAL_RUN, reportEntry ) );
1277
1278 verifyZeroInteractions( notifiableTestStream );
1279 verify( factory ).createReporter();
1280 verifyNoMoreInteractions( factory );
1281 assertThat( client.hasTestsInProgress() )
1282 .isTrue();
1283 assertThat( client.testsInProgress() )
1284 .hasSize( 1 )
1285 .contains( "pkg.MyTest" );
1286 assertThat( client.getReporter() )
1287 .isNotNull();
1288 assertThat( receiver.getEvents() )
1289 .hasSize( 1 );
1290 assertThat( receiver.getEvents() )
1291 .contains( TEST_STARTING );
1292 assertThat( receiver.getData() )
1293 .hasSize( 1 );
1294 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1295 .isEqualTo( "pkg.MyTest" );
1296 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1297 .isNull();
1298 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1299 .isEqualTo( "my test" );
1300 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getNameText() )
1301 .isNull();
1302 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getElapsed() )
1303 .isEqualTo( ELAPSED_TIME );
1304 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getMessage() )
1305 .isEqualTo( "some test" );
1306 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getGroup() )
1307 .isEqualTo( "this group" );
1308 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter() )
1309 .isNotNull();
1310 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) )
1311 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1312 .isEqualTo( "msg" );
1313 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1314 .isEqualTo( smartStackTrace );
1315 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTraceToString() )
1316 .isEqualTo( stackTrace );
1317 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1318 .isEqualTo( trimmedStackTrace );
1319 assertThat( client.isSaidGoodBye() )
1320 .isFalse();
1321 assertThat( client.isErrorInFork() )
1322 .isFalse();
1323 assertThat( client.getErrorInFork() )
1324 .isNull();
1325 assertThat( client.hadTimeout() )
1326 .isFalse();
1327 assertThat( client.getTestVmSystemProperties() )
1328 .isEmpty();
1329 assertThat( client.getTestVmSystemProperties() )
1330 .isEmpty();
1331 assertThat( client.getDefaultReporterFactory() )
1332 .isSameAs( factory );
1333 }
1334
1335 @Test
1336 public void shouldSendTestSucceeded()
1337 {
1338 String cwd = System.getProperty( "user.dir" );
1339 File target = new File( cwd, "target" );
1340 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1341 when( factory.getReportsDirectory() )
1342 .thenReturn( new File( target, "surefire-reports" ) );
1343 MockReporter receiver = new MockReporter();
1344 when( factory.createReporter() )
1345 .thenReturn( receiver );
1346 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1347
1348 final String exceptionMessage = "msg";
1349 final String smartStackTrace = "MyTest:86 >> Error";
1350 final String stackTrace = "trace line 1\ntrace line 2";
1351 final String trimmedStackTrace = "trace line 1";
1352
1353 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1354 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1355 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1356 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1357 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1358 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1359
1360 ReportEntry reportEntry = mock( ReportEntry.class );
1361 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1362 when( reportEntry.getGroup() ).thenReturn( "this group" );
1363 when( reportEntry.getMessage() ).thenReturn( "some test" );
1364 when( reportEntry.getName() ).thenReturn( "my test" );
1365 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1366 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1367 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1368
1369 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1370 SimpleReportEntry testStarted = new SimpleReportEntry( reportEntry.getSourceName(), null, null, null );
1371 client.handleEvent( new TestStartingEvent( NORMAL_RUN, testStarted ) );
1372
1373 assertThat( client.testsInProgress() )
1374 .hasSize( 1 )
1375 .contains( "pkg.MyTest" );
1376
1377 client.handleEvent( new TestSucceededEvent( NORMAL_RUN, reportEntry ) );
1378
1379 verifyZeroInteractions( notifiableTestStream );
1380 verify( factory ).createReporter();
1381 verifyNoMoreInteractions( factory );
1382 assertThat( client.getReporter() )
1383 .isNotNull();
1384 assertThat( receiver.getEvents() )
1385 .hasSize( 2 );
1386 assertThat( receiver.getEvents() )
1387 .contains( TEST_STARTING, TEST_SUCCEEDED );
1388 assertThat( receiver.getData() )
1389 .hasSize( 2 );
1390 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1391 .isEqualTo( "pkg.MyTest" );
1392 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1393 .isNull();
1394 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1395 .isNull();
1396 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getNameText() )
1397 .isNull();
1398 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceName() )
1399 .isEqualTo( "pkg.MyTest" );
1400 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getName() )
1401 .isEqualTo( "my test" );
1402 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getElapsed() )
1403 .isEqualTo( ELAPSED_TIME );
1404 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getMessage() )
1405 .isEqualTo( "some test" );
1406 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getGroup() )
1407 .isEqualTo( "this group" );
1408 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter() )
1409 .isNotNull();
1410 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) )
1411 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1412 .isEqualTo( "msg" );
1413 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1414 .isEqualTo( smartStackTrace );
1415 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTraceToString() )
1416 .isEqualTo( stackTrace );
1417 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1418 .isEqualTo( trimmedStackTrace );
1419 assertThat( client.isSaidGoodBye() )
1420 .isFalse();
1421 assertThat( client.isErrorInFork() )
1422 .isFalse();
1423 assertThat( client.getErrorInFork() )
1424 .isNull();
1425 assertThat( client.hadTimeout() )
1426 .isFalse();
1427 assertThat( client.hasTestsInProgress() )
1428 .isFalse();
1429 assertThat( client.testsInProgress() )
1430 .isEmpty();
1431 assertThat( client.getTestVmSystemProperties() )
1432 .isEmpty();
1433 assertThat( client.getTestVmSystemProperties() )
1434 .isEmpty();
1435 assertThat( client.getDefaultReporterFactory() )
1436 .isSameAs( factory );
1437 }
1438
1439 @Test
1440 public void shouldSendTestFailed()
1441 {
1442 String cwd = System.getProperty( "user.dir" );
1443 File target = new File( cwd, "target" );
1444 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1445 when( factory.getReportsDirectory() )
1446 .thenReturn( new File( target, "surefire-reports" ) );
1447 MockReporter receiver = new MockReporter();
1448 when( factory.createReporter() )
1449 .thenReturn( receiver );
1450 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1451
1452 final String exceptionMessage = "msg";
1453 final String smartStackTrace = "MyTest:86 >> Error";
1454 final String stackTrace = "trace line 1\ntrace line 2";
1455 final String trimmedStackTrace = "trace line 1";
1456
1457 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1458 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1459 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1460 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1461 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1462 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1463
1464 ReportEntry reportEntry = mock( ReportEntry.class );
1465 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1466 when( reportEntry.getGroup() ).thenReturn( "this group" );
1467 when( reportEntry.getMessage() ).thenReturn( "some test" );
1468 when( reportEntry.getName() ).thenReturn( "my test" );
1469 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1470 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1471 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1472
1473 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1474 SimpleReportEntry testClass = new SimpleReportEntry( reportEntry.getSourceName(), null, null, null );
1475 client.handleEvent( new TestStartingEvent( NORMAL_RUN, testClass ) );
1476
1477 assertThat( client.testsInProgress() )
1478 .hasSize( 1 )
1479 .contains( "pkg.MyTest" );
1480
1481 client.handleEvent( new TestFailedEvent( NORMAL_RUN, reportEntry ) );
1482
1483 verifyZeroInteractions( notifiableTestStream );
1484 verify( factory ).createReporter();
1485 verifyNoMoreInteractions( factory );
1486 assertThat( client.getReporter() )
1487 .isNotNull();
1488 assertThat( receiver.getEvents() )
1489 .hasSize( 2 );
1490 assertThat( receiver.getEvents() )
1491 .contains( TEST_STARTING, TEST_FAILED );
1492 assertThat( receiver.getData() )
1493 .hasSize( 2 );
1494 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1495 .isEqualTo( "pkg.MyTest" );
1496 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1497 .isNull();
1498 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1499 .isNull();
1500 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getNameText() )
1501 .isNull();
1502 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getStackTraceWriter() )
1503 .isNull();
1504 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceName() )
1505 .isEqualTo( "pkg.MyTest" );
1506 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceText() )
1507 .isNull();
1508 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getName() )
1509 .isEqualTo( "my test" );
1510 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getNameText() )
1511 .isNull();
1512 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getElapsed() )
1513 .isEqualTo( ELAPSED_TIME );
1514 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getMessage() )
1515 .isEqualTo( "some test" );
1516 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getGroup() )
1517 .isEqualTo( "this group" );
1518 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter() )
1519 .isNotNull();
1520 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) )
1521 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1522 .isEqualTo( "msg" );
1523 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1524 .isEqualTo( "MyTest:86 >> Error" );
1525 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTraceToString() )
1526 .isEqualTo( stackTrace );
1527 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1528 .isEqualTo( trimmedStackTrace );
1529 assertThat( client.isSaidGoodBye() )
1530 .isFalse();
1531 assertThat( client.isErrorInFork() )
1532 .isFalse();
1533 assertThat( client.getErrorInFork() )
1534 .isNull();
1535 assertThat( client.hadTimeout() )
1536 .isFalse();
1537 assertThat( client.hasTestsInProgress() )
1538 .isFalse();
1539 assertThat( client.testsInProgress() )
1540 .isEmpty();
1541 assertThat( client.getTestVmSystemProperties() )
1542 .isEmpty();
1543 assertThat( client.getTestVmSystemProperties() )
1544 .isEmpty();
1545 assertThat( client.getDefaultReporterFactory() )
1546 .isSameAs( factory );
1547 }
1548
1549 @Test
1550 public void shouldSendTestSkipped()
1551 {
1552 String cwd = System.getProperty( "user.dir" );
1553 File target = new File( cwd, "target" );
1554 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1555 when( factory.getReportsDirectory() )
1556 .thenReturn( new File( target, "surefire-reports" ) );
1557 MockReporter receiver = new MockReporter();
1558 when( factory.createReporter() )
1559 .thenReturn( receiver );
1560 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1561
1562 final String exceptionMessage = "msg";
1563 final String smartStackTrace = "MyTest:86 >> Error";
1564 final String stackTrace = "trace line 1\ntrace line 2";
1565 final String trimmedStackTrace = "trace line 1";
1566
1567 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1568 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1569 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1570 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1571 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1572 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1573
1574 ReportEntry reportEntry = mock( ReportEntry.class );
1575 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1576 when( reportEntry.getGroup() ).thenReturn( "this group" );
1577 when( reportEntry.getMessage() ).thenReturn( "some test" );
1578 when( reportEntry.getName() ).thenReturn( "my test" );
1579 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1580 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1581 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1582
1583 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1584 SimpleReportEntry testStarted = new SimpleReportEntry( reportEntry.getSourceName(), null, null, null );
1585 client.handleEvent( new TestStartingEvent( NORMAL_RUN, testStarted ) );
1586
1587 assertThat( client.testsInProgress() )
1588 .hasSize( 1 )
1589 .contains( "pkg.MyTest" );
1590
1591 client.handleEvent( new TestSkippedEvent( NORMAL_RUN, reportEntry ) );
1592
1593 verifyZeroInteractions( notifiableTestStream );
1594 verify( factory ).createReporter();
1595 verifyNoMoreInteractions( factory );
1596 assertThat( client.getReporter() )
1597 .isNotNull();
1598 assertThat( receiver.getEvents() )
1599 .hasSize( 2 );
1600 assertThat( receiver.getEvents() )
1601 .contains( TEST_STARTING, TEST_SKIPPED );
1602 assertThat( receiver.getData() )
1603 .hasSize( 2 );
1604 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1605 .isEqualTo( "pkg.MyTest" );
1606 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1607 .isNull();
1608 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1609 .isNull();
1610 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getNameText() )
1611 .isNull();
1612 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceName() )
1613 .isEqualTo( "pkg.MyTest" );
1614 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceText() )
1615 .isNull();
1616 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getName() )
1617 .isEqualTo( "my test" );
1618 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getNameText() )
1619 .isNull();
1620 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getElapsed() )
1621 .isEqualTo( ELAPSED_TIME );
1622 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getMessage() )
1623 .isEqualTo( "some test" );
1624 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getGroup() )
1625 .isEqualTo( "this group" );
1626 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter() )
1627 .isNotNull();
1628 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) )
1629 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1630 .isEqualTo( "msg" );
1631 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1632 .isEqualTo( smartStackTrace );
1633 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTraceToString() )
1634 .isEqualTo( stackTrace );
1635 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1636 .isEqualTo( trimmedStackTrace );
1637 assertThat( client.isSaidGoodBye() )
1638 .isFalse();
1639 assertThat( client.isErrorInFork() )
1640 .isFalse();
1641 assertThat( client.getErrorInFork() )
1642 .isNull();
1643 assertThat( client.hadTimeout() )
1644 .isFalse();
1645 assertThat( client.hasTestsInProgress() )
1646 .isFalse();
1647 assertThat( client.testsInProgress() )
1648 .isEmpty();
1649 assertThat( client.getTestVmSystemProperties() )
1650 .isEmpty();
1651 assertThat( client.getTestVmSystemProperties() )
1652 .isEmpty();
1653 assertThat( client.getDefaultReporterFactory() )
1654 .isSameAs( factory );
1655 }
1656
1657 @Test
1658 public void shouldSendTestError()
1659 {
1660 String cwd = System.getProperty( "user.dir" );
1661 File target = new File( cwd, "target" );
1662 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1663 when( factory.getReportsDirectory() )
1664 .thenReturn( new File( target, "surefire-reports" ) );
1665 MockReporter receiver = new MockReporter();
1666 when( factory.createReporter() )
1667 .thenReturn( receiver );
1668 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1669
1670 final String exceptionMessage = "msg";
1671 final String smartStackTrace = "MyTest:86 >> Error";
1672 final String stackTrace = "trace line 1\ntrace line 2";
1673 final String trimmedStackTrace = "trace line 1";
1674
1675 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1676 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1677 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1678 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1679 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1680 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1681
1682 ReportEntry reportEntry = mock( ReportEntry.class );
1683 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1684 when( reportEntry.getGroup() ).thenReturn( "this group" );
1685 when( reportEntry.getMessage() ).thenReturn( "some test" );
1686 when( reportEntry.getName() ).thenReturn( "my test" );
1687 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1688 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1689 when( reportEntry.getSourceText() ).thenReturn( "display name" );
1690 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1691
1692 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1693 SimpleReportEntry testStarted =
1694 new SimpleReportEntry( reportEntry.getSourceName(), reportEntry.getSourceText(), null, null );
1695 client.handleEvent( new TestStartingEvent( NORMAL_RUN, testStarted ) );
1696
1697 assertThat( client.testsInProgress() )
1698 .hasSize( 1 )
1699 .contains( "pkg.MyTest" );
1700
1701 client.handleEvent( new TestErrorEvent( NORMAL_RUN, reportEntry ) );
1702
1703 verifyZeroInteractions( notifiableTestStream );
1704 verify( factory ).createReporter();
1705 verifyNoMoreInteractions( factory );
1706 assertThat( client.getReporter() )
1707 .isNotNull();
1708 assertThat( receiver.getEvents() )
1709 .hasSize( 2 );
1710 assertThat( receiver.getEvents() )
1711 .contains( TEST_STARTING, TEST_ERROR );
1712 assertThat( receiver.getData() )
1713 .hasSize( 2 );
1714 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1715 .isEqualTo( "pkg.MyTest" );
1716 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1717 .isEqualTo( "display name" );
1718 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1719 .isNull();
1720 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceName() )
1721 .isEqualTo( "pkg.MyTest" );
1722 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceText() )
1723 .isEqualTo( "display name" );
1724 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getName() )
1725 .isEqualTo( "my test" );
1726 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getElapsed() )
1727 .isEqualTo( ELAPSED_TIME );
1728 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getMessage() )
1729 .isEqualTo( "some test" );
1730 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getGroup() )
1731 .isEqualTo( "this group" );
1732 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter() )
1733 .isNotNull();
1734 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) )
1735 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1736 .isEqualTo( "msg" );
1737 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1738 .isEqualTo( smartStackTrace );
1739 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTraceToString() )
1740 .isEqualTo( stackTrace );
1741 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1742 .isEqualTo( trimmedStackTrace );
1743 assertThat( client.isSaidGoodBye() )
1744 .isFalse();
1745 assertThat( client.isErrorInFork() )
1746 .isFalse();
1747 assertThat( client.getErrorInFork() )
1748 .isNull();
1749 assertThat( client.hadTimeout() )
1750 .isFalse();
1751 assertThat( client.hasTestsInProgress() )
1752 .isFalse();
1753 assertThat( client.testsInProgress() )
1754 .isEmpty();
1755 assertThat( client.getTestVmSystemProperties() )
1756 .isEmpty();
1757 assertThat( client.getTestVmSystemProperties() )
1758 .isEmpty();
1759 assertThat( client.getDefaultReporterFactory() )
1760 .isSameAs( factory );
1761 }
1762
1763 @Test
1764 public void shouldSendTestAssumptionFailure()
1765 {
1766 String cwd = System.getProperty( "user.dir" );
1767 File target = new File( cwd, "target" );
1768 DefaultReporterFactory factory = mock( DefaultReporterFactory.class );
1769 when( factory.getReportsDirectory() )
1770 .thenReturn( new File( target, "surefire-reports" ) );
1771 MockReporter receiver = new MockReporter();
1772 when( factory.createReporter() )
1773 .thenReturn( receiver );
1774 NotifiableTestStream notifiableTestStream = mock( NotifiableTestStream.class );
1775
1776 final String exceptionMessage = "msg";
1777 final String smartStackTrace = "MyTest:86 >> Error";
1778 final String stackTrace = "trace line 1\ntrace line 2";
1779 final String trimmedStackTrace = "trace line 1";
1780
1781 SafeThrowable safeThrowable = new SafeThrowable( new Exception( exceptionMessage ) );
1782 StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class );
1783 when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable );
1784 when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace );
1785 when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace );
1786 when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace );
1787
1788 ReportEntry reportEntry = mock( ReportEntry.class );
1789 when( reportEntry.getElapsed() ).thenReturn( ELAPSED_TIME );
1790 when( reportEntry.getGroup() ).thenReturn( "this group" );
1791 when( reportEntry.getMessage() ).thenReturn( "some test" );
1792 when( reportEntry.getName() ).thenReturn( "my test" );
1793 when( reportEntry.getNameText() ).thenReturn( "display name" );
1794 when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" );
1795 when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" );
1796 when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter );
1797
1798 ForkClient client = new ForkClient( factory, notifiableTestStream, 0 );
1799 SimpleReportEntry testStarted = new SimpleReportEntry( reportEntry.getSourceName(), null, null, null );
1800 client.handleEvent( new TestStartingEvent( NORMAL_RUN, testStarted ) );
1801
1802 assertThat( client.testsInProgress() )
1803 .hasSize( 1 )
1804 .contains( "pkg.MyTest" );
1805
1806 client.handleEvent( new TestAssumptionFailureEvent( NORMAL_RUN, reportEntry ) );
1807
1808 verifyZeroInteractions( notifiableTestStream );
1809 verify( factory ).createReporter();
1810 verifyNoMoreInteractions( factory );
1811 assertThat( client.getReporter() )
1812 .isNotNull();
1813 assertThat( receiver.getEvents() )
1814 .hasSize( 2 );
1815 assertThat( receiver.getEvents() )
1816 .contains( TEST_STARTING, TEST_ASSUMPTION_FAIL );
1817 assertThat( receiver.getData() )
1818 .hasSize( 2 );
1819 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceName() )
1820 .isEqualTo( "pkg.MyTest" );
1821 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getSourceText() )
1822 .isNull();
1823 assertThat( ( (ReportEntry) receiver.getData().get( 0 ) ).getName() )
1824 .isNull();
1825 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getSourceName() )
1826 .isEqualTo( "pkg.MyTest" );
1827 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getName() )
1828 .isEqualTo( "my test" );
1829 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getNameText() )
1830 .isEqualTo( "display name" );
1831 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getElapsed() )
1832 .isEqualTo( ELAPSED_TIME );
1833 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getMessage() )
1834 .isEqualTo( "some test" );
1835 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getGroup() )
1836 .isEqualTo( "this group" );
1837 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter() )
1838 .isNotNull();
1839 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) )
1840 .getStackTraceWriter().getThrowable().getLocalizedMessage() )
1841 .isEqualTo( "msg" );
1842 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().smartTrimmedStackTrace() )
1843 .isEqualTo( smartStackTrace );
1844 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTraceToString() )
1845 .isEqualTo( stackTrace );
1846 assertThat( ( (ReportEntry) receiver.getData().get( 1 ) ).getStackTraceWriter().writeTrimmedTraceToString() )
1847 .isEqualTo( trimmedStackTrace );
1848 assertThat( client.isSaidGoodBye() )
1849 .isFalse();
1850 assertThat( client.isErrorInFork() )
1851 .isFalse();
1852 assertThat( client.getErrorInFork() )
1853 .isNull();
1854 assertThat( client.hadTimeout() )
1855 .isFalse();
1856 assertThat( client.hasTestsInProgress() )
1857 .isFalse();
1858 assertThat( client.testsInProgress() )
1859 .isEmpty();
1860 assertThat( client.getTestVmSystemProperties() )
1861 .isEmpty();
1862 assertThat( client.getTestVmSystemProperties() )
1863 .isEmpty();
1864 assertThat( client.getDefaultReporterFactory() )
1865 .isSameAs( factory );
1866 }
1867
1868 private static class EH implements EventHandler<Event>
1869 {
1870 private final BlockingQueue<Event> cache = new LinkedBlockingQueue<>( 1 );
1871
1872 Event pullEvent() throws InterruptedException
1873 {
1874 return cache.poll( 1, TimeUnit.MINUTES );
1875 }
1876
1877 int sizeOfEventCache()
1878 {
1879 return cache.size();
1880 }
1881
1882 @Override
1883 public void handleEvent( @Nonnull Event event )
1884 {
1885 cache.add( event );
1886 }
1887 }
1888 }