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