| package org.apache.maven.plugin.surefire.extensions; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import org.apache.maven.plugin.surefire.booterclient.output.DeserializedStacktraceWriter; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessEventListener; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessEventNotifier; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessExitErrorListener; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessPropertyEventListener; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessReportEventListener; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessStackTraceEventListener; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessStandardOutErrEventListener; |
| import org.apache.maven.plugin.surefire.booterclient.output.ForkedProcessStringEventListener; |
| import org.apache.maven.plugin.surefire.log.api.ConsoleLogger; |
| import org.apache.maven.plugin.surefire.log.api.ConsoleLoggerUtils; |
| import org.apache.maven.surefire.booter.spi.LegacyMasterProcessChannelEncoder; |
| import org.apache.maven.surefire.api.event.Event; |
| import org.apache.maven.surefire.extensions.EventHandler; |
| import org.apache.maven.surefire.extensions.ForkNodeArguments; |
| import org.apache.maven.surefire.extensions.util.CountdownCloseable; |
| import org.apache.maven.surefire.api.report.ReportEntry; |
| import org.apache.maven.surefire.api.report.RunMode; |
| import org.apache.maven.surefire.api.report.SafeThrowable; |
| import org.apache.maven.surefire.api.report.StackTraceWriter; |
| import org.apache.maven.surefire.api.util.internal.ObjectUtils; |
| import org.apache.maven.surefire.api.util.internal.WritableBufferedByteChannel; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.experimental.runners.Enclosed; |
| import org.junit.experimental.theories.DataPoints; |
| import org.junit.experimental.theories.FromDataPoints; |
| import org.junit.experimental.theories.Theories; |
| import org.junit.experimental.theories.Theory; |
| import org.junit.rules.ExpectedException; |
| import org.junit.runner.RunWith; |
| import org.mockito.ArgumentCaptor; |
| import org.powermock.core.classloader.annotations.PowerMockIgnore; |
| import org.powermock.modules.junit4.PowerMockRunner; |
| |
| import javax.annotation.Nonnull; |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.Closeable; |
| import java.io.File; |
| import java.io.LineNumberReader; |
| import java.io.PrintStream; |
| import java.io.StringReader; |
| import java.nio.ByteBuffer; |
| import java.nio.channels.ReadableByteChannel; |
| import java.nio.charset.Charset; |
| import java.util.Map; |
| import java.util.concurrent.BlockingQueue; |
| import java.util.concurrent.LinkedTransferQueue; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| import static java.lang.String.format; |
| import static java.nio.charset.StandardCharsets.UTF_8; |
| import static java.util.Arrays.copyOfRange; |
| import static org.apache.maven.surefire.api.report.RunMode.NORMAL_RUN; |
| import static org.apache.maven.surefire.shared.codec.binary.Base64.encodeBase64String; |
| import static org.apache.maven.surefire.api.util.internal.Channels.newBufferedChannel; |
| import static org.apache.maven.surefire.api.util.internal.Channels.newChannel; |
| import static org.fest.assertions.Assertions.assertThat; |
| import static org.fest.assertions.Index.atIndex; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.rules.ExpectedException.none; |
| import static org.mockito.ArgumentMatchers.anyString; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| import static org.mockito.Mockito.when; |
| |
| /** |
| * Test for {@link ForkedProcessEventNotifier}. |
| * |
| * @author <a href="mailto:tibordigana@apache.org">Tibor Digana (tibor17)</a> |
| * @since 3.0.0-M4 |
| */ |
| @RunWith( Enclosed.class ) |
| public class ForkedProcessEventNotifierTest |
| { |
| /** |
| * |
| */ |
| @RunWith( PowerMockRunner.class ) |
| @PowerMockIgnore( { "org.jacoco.agent.rt.*", "com.vladium.emma.rt.*" } ) |
| public static class DecoderOperationsTest |
| { |
| @Rule |
| public final ExpectedException rule = none(); |
| |
| @Test |
| public void shouldBeFailSafe() |
| { |
| assertThat( EventConsumerThread.decode( null, UTF_8 ) ).isNull(); |
| assertThat( EventConsumerThread.decode( "-", UTF_8 ) ).isNull(); |
| assertThat( EventConsumerThread.decodeToInteger( null ) ).isNull(); |
| assertThat( EventConsumerThread.decodeToInteger( "-" ) ).isNull(); |
| } |
| |
| @Test |
| public void shouldHaveSystemProperty() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| Map<String, String> props = ObjectUtils.systemProps(); |
| encoder.sendSystemProperties( props ); |
| wChannel.close(); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| PropertyEventAssertionListener listener = new PropertyEventAssertionListener(); |
| notifier.setSystemPropertiesListener( listener ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| for ( int i = 0; i < props.size(); i++ ) |
| { |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| } |
| |
| assertThat( listener.counter.get() ) |
| .isEqualTo( props.size() ); |
| } |
| |
| @Test |
| public void shouldRecognizeEmptyStream4ReportEntry() |
| { |
| ReportEntry reportEntry = EventConsumerThread.decodeReportEntry( null, null, null, "", "", null, null, "", |
| "", "", null ); |
| assertThat( reportEntry ).isNull(); |
| |
| reportEntry = EventConsumerThread.decodeReportEntry( UTF_8, "", "", "", "", "", "", "-", "", "", "" ); |
| assertThat( reportEntry ).isNotNull(); |
| assertThat( reportEntry.getStackTraceWriter() ).isNotNull(); |
| assertThat( reportEntry.getStackTraceWriter().smartTrimmedStackTrace() ).isEmpty(); |
| assertThat( reportEntry.getStackTraceWriter().writeTraceToString() ).isEmpty(); |
| assertThat( reportEntry.getStackTraceWriter().writeTrimmedTraceToString() ).isEmpty(); |
| assertThat( reportEntry.getSourceName() ).isEmpty(); |
| assertThat( reportEntry.getSourceText() ).isEmpty(); |
| assertThat( reportEntry.getName() ).isEmpty(); |
| assertThat( reportEntry.getNameText() ).isEmpty(); |
| assertThat( reportEntry.getGroup() ).isEmpty(); |
| assertThat( reportEntry.getNameWithGroup() ).isEmpty(); |
| assertThat( reportEntry.getMessage() ).isEmpty(); |
| assertThat( reportEntry.getElapsed() ).isNull(); |
| |
| rule.expect( NumberFormatException.class ); |
| EventConsumerThread.decodeReportEntry( UTF_8, "", "", "", "", "", "", "", "", "", "" ); |
| } |
| |
| @Test |
| @SuppressWarnings( "checkstyle:magicnumber" ) |
| public void testCreatingReportEntry() |
| { |
| final String exceptionMessage = "msg"; |
| final String encodedExceptionMsg = encodeBase64String( toArray( UTF_8.encode( exceptionMessage ) ) ); |
| |
| final String smartStackTrace = "MyTest:86 >> Error"; |
| final String encodedSmartStackTrace = encodeBase64String( toArray( UTF_8.encode( smartStackTrace ) ) ); |
| |
| final String stackTrace = "Exception: msg\ntrace line 1\ntrace line 2"; |
| final String encodedStackTrace = encodeBase64String( toArray( UTF_8.encode( stackTrace ) ) ); |
| |
| final String trimmedStackTrace = "trace line 1\ntrace line 2"; |
| final String encodedTrimmedStackTrace = encodeBase64String( toArray( UTF_8.encode( trimmedStackTrace ) ) ); |
| |
| SafeThrowable safeThrowable = new SafeThrowable( exceptionMessage ); |
| StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class ); |
| when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable ); |
| when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace ); |
| when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( trimmedStackTrace ); |
| when( stackTraceWriter.writeTraceToString() ).thenReturn( stackTrace ); |
| |
| ReportEntry reportEntry = mock( ReportEntry.class ); |
| when( reportEntry.getElapsed() ).thenReturn( 102 ); |
| when( reportEntry.getGroup() ).thenReturn( "this group" ); |
| when( reportEntry.getMessage() ).thenReturn( "skipped test" ); |
| when( reportEntry.getName() ).thenReturn( "my test" ); |
| when( reportEntry.getNameText() ).thenReturn( "my display name" ); |
| when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" ); |
| when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" ); |
| when( reportEntry.getSourceText() ).thenReturn( "test class display name" ); |
| when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter ); |
| |
| String encodedSourceName = encodeBase64String( toArray( UTF_8.encode( reportEntry.getSourceName() ) ) ); |
| String encodedSourceText = encodeBase64String( toArray( UTF_8.encode( reportEntry.getSourceText() ) ) ); |
| String encodedName = encodeBase64String( toArray( UTF_8.encode( reportEntry.getName() ) ) ); |
| String encodedText = encodeBase64String( toArray( UTF_8.encode( reportEntry.getNameText() ) ) ); |
| String encodedGroup = encodeBase64String( toArray( UTF_8.encode( reportEntry.getGroup() ) ) ); |
| String encodedMessage = encodeBase64String( toArray( UTF_8.encode( reportEntry.getMessage() ) ) ); |
| |
| ReportEntry decodedReportEntry = EventConsumerThread.decodeReportEntry( UTF_8, encodedSourceName, |
| encodedSourceText, encodedName, encodedText, encodedGroup, encodedMessage, "-", null, null, null ); |
| |
| assertThat( decodedReportEntry ).isNotNull(); |
| assertThat( decodedReportEntry.getSourceName() ).isEqualTo( reportEntry.getSourceName() ); |
| assertThat( decodedReportEntry.getSourceText() ).isEqualTo( reportEntry.getSourceText() ); |
| assertThat( decodedReportEntry.getName() ).isEqualTo( reportEntry.getName() ); |
| assertThat( decodedReportEntry.getNameText() ).isEqualTo( reportEntry.getNameText() ); |
| assertThat( decodedReportEntry.getGroup() ).isEqualTo( reportEntry.getGroup() ); |
| assertThat( decodedReportEntry.getMessage() ).isEqualTo( reportEntry.getMessage() ); |
| assertThat( decodedReportEntry.getStackTraceWriter() ).isNull(); |
| |
| decodedReportEntry = EventConsumerThread.decodeReportEntry( UTF_8, encodedSourceName, encodedSourceText, |
| encodedName, encodedText, encodedGroup, encodedMessage, "-", encodedExceptionMsg, |
| encodedSmartStackTrace, null ); |
| |
| assertThat( decodedReportEntry ).isNotNull(); |
| assertThat( decodedReportEntry.getSourceName() ).isEqualTo( reportEntry.getSourceName() ); |
| assertThat( decodedReportEntry.getSourceText() ).isEqualTo( reportEntry.getSourceText() ); |
| assertThat( decodedReportEntry.getName() ).isEqualTo( reportEntry.getName() ); |
| assertThat( decodedReportEntry.getNameText() ).isEqualTo( reportEntry.getNameText() ); |
| assertThat( decodedReportEntry.getGroup() ).isEqualTo( reportEntry.getGroup() ); |
| assertThat( decodedReportEntry.getMessage() ).isEqualTo( reportEntry.getMessage() ); |
| assertThat( decodedReportEntry.getElapsed() ).isNull(); |
| assertThat( decodedReportEntry.getStackTraceWriter() ).isNotNull(); |
| assertThat( decodedReportEntry.getStackTraceWriter().getThrowable().getMessage() ) |
| .isEqualTo( exceptionMessage ); |
| assertThat( decodedReportEntry.getStackTraceWriter().smartTrimmedStackTrace() ) |
| .isEqualTo( smartStackTrace ); |
| assertThat( decodedReportEntry.getStackTraceWriter().writeTraceToString() ) |
| .isNull(); |
| |
| decodedReportEntry = EventConsumerThread.decodeReportEntry( UTF_8, encodedSourceName, encodedSourceText, |
| encodedName, encodedText, encodedGroup, encodedMessage, "1003", encodedExceptionMsg, |
| encodedSmartStackTrace, null ); |
| |
| assertThat( decodedReportEntry ).isNotNull(); |
| assertThat( decodedReportEntry.getSourceName() ).isEqualTo( reportEntry.getSourceName() ); |
| assertThat( decodedReportEntry.getSourceText() ).isEqualTo( reportEntry.getSourceText() ); |
| assertThat( decodedReportEntry.getName() ).isEqualTo( reportEntry.getName() ); |
| assertThat( decodedReportEntry.getNameText() ).isEqualTo( reportEntry.getNameText() ); |
| assertThat( decodedReportEntry.getGroup() ).isEqualTo( reportEntry.getGroup() ); |
| assertThat( decodedReportEntry.getMessage() ).isEqualTo( reportEntry.getMessage() ); |
| assertThat( decodedReportEntry.getElapsed() ).isEqualTo( 1003 ); |
| assertThat( decodedReportEntry.getStackTraceWriter() ).isNotNull(); |
| assertThat( decodedReportEntry.getStackTraceWriter().getThrowable().getMessage() ) |
| .isEqualTo( exceptionMessage ); |
| assertThat( decodedReportEntry.getStackTraceWriter().smartTrimmedStackTrace() ) |
| .isEqualTo( smartStackTrace ); |
| assertThat( decodedReportEntry.getStackTraceWriter().writeTraceToString() ) |
| .isNull(); |
| |
| decodedReportEntry = EventConsumerThread.decodeReportEntry( UTF_8, encodedSourceName, encodedSourceText, |
| encodedName, encodedText, encodedGroup, encodedMessage, "1003", encodedExceptionMsg, |
| encodedSmartStackTrace, encodedStackTrace ); |
| |
| assertThat( decodedReportEntry ).isNotNull(); |
| assertThat( decodedReportEntry.getSourceName() ).isEqualTo( reportEntry.getSourceName() ); |
| assertThat( decodedReportEntry.getSourceText() ).isEqualTo( reportEntry.getSourceText() ); |
| assertThat( decodedReportEntry.getName() ).isEqualTo( reportEntry.getName() ); |
| assertThat( decodedReportEntry.getNameText() ).isEqualTo( reportEntry.getNameText() ); |
| assertThat( decodedReportEntry.getGroup() ).isEqualTo( reportEntry.getGroup() ); |
| assertThat( decodedReportEntry.getMessage() ).isEqualTo( reportEntry.getMessage() ); |
| assertThat( decodedReportEntry.getElapsed() ).isEqualTo( 1003 ); |
| assertThat( decodedReportEntry.getStackTraceWriter() ).isNotNull(); |
| assertThat( decodedReportEntry.getStackTraceWriter().getThrowable().getMessage() ).isNotNull(); |
| assertThat( decodedReportEntry.getStackTraceWriter().getThrowable().getMessage() ) |
| .isEqualTo( exceptionMessage ); |
| assertThat( decodedReportEntry.getStackTraceWriter().smartTrimmedStackTrace() ) |
| .isEqualTo( smartStackTrace ); |
| assertThat( decodedReportEntry.getStackTraceWriter().writeTraceToString() ).isEqualTo( stackTrace ); |
| assertThat( decodedReportEntry.getStackTraceWriter().writeTrimmedTraceToString() ).isEqualTo( stackTrace ); |
| |
| decodedReportEntry = EventConsumerThread.decodeReportEntry( UTF_8, encodedSourceName, encodedSourceText, |
| encodedName, encodedText, encodedGroup, encodedMessage, "1003", encodedExceptionMsg, |
| encodedSmartStackTrace, encodedTrimmedStackTrace ); |
| |
| assertThat( decodedReportEntry ).isNotNull(); |
| assertThat( decodedReportEntry.getSourceName() ).isEqualTo( reportEntry.getSourceName() ); |
| assertThat( decodedReportEntry.getSourceText() ).isEqualTo( reportEntry.getSourceText() ); |
| assertThat( decodedReportEntry.getName() ).isEqualTo( reportEntry.getName() ); |
| assertThat( decodedReportEntry.getNameText() ).isEqualTo( reportEntry.getNameText() ); |
| assertThat( decodedReportEntry.getGroup() ).isEqualTo( reportEntry.getGroup() ); |
| assertThat( decodedReportEntry.getMessage() ).isEqualTo( reportEntry.getMessage() ); |
| assertThat( decodedReportEntry.getElapsed() ).isEqualTo( 1003 ); |
| assertThat( decodedReportEntry.getStackTraceWriter() ).isNotNull(); |
| assertThat( decodedReportEntry.getStackTraceWriter().getThrowable().getMessage() ).isNotNull(); |
| assertThat( decodedReportEntry.getStackTraceWriter().getThrowable().getMessage() ) |
| .isEqualTo( exceptionMessage ); |
| assertThat( decodedReportEntry.getStackTraceWriter().smartTrimmedStackTrace() ) |
| .isEqualTo( smartStackTrace ); |
| assertThat( decodedReportEntry.getStackTraceWriter().writeTraceToString() ).isEqualTo( trimmedStackTrace ); |
| assertThat( decodedReportEntry.getStackTraceWriter().writeTrimmedTraceToString() ) |
| .isEqualTo( trimmedStackTrace ); |
| } |
| |
| @Test |
| public void shouldSendByeEvent() throws Exception |
| { |
| Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.bye(); |
| String read = new String( out.toByteArray(), UTF_8 ); |
| |
| assertThat( read ) |
| .isEqualTo( ":maven-surefire-event:bye:\n" ); |
| |
| LineNumberReader lines = out.newReader( UTF_8 ); |
| |
| final String cmd = lines.readLine(); |
| assertThat( cmd ) |
| .isNotNull(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| EventAssertionListener listener = new EventAssertionListener(); |
| notifier.setByeListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void shouldSendStopOnNextTestEvent() throws Exception |
| { |
| Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.stopOnNextTest(); |
| String read = new String( out.toByteArray(), UTF_8 ); |
| |
| assertThat( read ) |
| .isEqualTo( ":maven-surefire-event:stop-on-next-test:\n" ); |
| |
| LineNumberReader lines = out.newReader( UTF_8 ); |
| |
| final String cmd = lines.readLine(); |
| assertThat( cmd ) |
| .isNotNull(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| EventAssertionListener listener = new EventAssertionListener(); |
| notifier.setStopOnNextTestListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void shouldCorrectlyDecodeStackTracesWithEmptyStringTraceMessages() throws Exception |
| { |
| String exceptionMessage = ""; |
| String smartStackTrace = "JUnit5Test.failWithEmptyString:16"; |
| String exceptionStackTrace = "org.opentest4j.AssertionFailedError: \n" |
| + "\tat JUnit5Test.failWithEmptyString(JUnit5Test.java:16)\n"; |
| |
| StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class ); |
| SafeThrowable safeThrowable = new SafeThrowable( exceptionMessage ); |
| when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable ); |
| when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace ); |
| when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( exceptionStackTrace ); |
| when( stackTraceWriter.writeTraceToString() ).thenReturn( exceptionStackTrace ); |
| |
| ReportEntry reportEntry = mock( ReportEntry.class ); |
| when( reportEntry.getElapsed() ).thenReturn( 7 ); |
| when( reportEntry.getGroup() ).thenReturn( null ); |
| when( reportEntry.getMessage() ).thenReturn( null ); |
| when( reportEntry.getName() ).thenReturn( "failWithEmptyString" ); |
| when( reportEntry.getNameWithGroup() ).thenReturn( "JUnit5Test" ); |
| when( reportEntry.getSourceName() ).thenReturn( "JUnit5Test" ); |
| when( reportEntry.getSourceText() ).thenReturn( null ); |
| when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter ); |
| |
| final Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.testFailed( reportEntry, true ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| final ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| ReportEventAssertionListener listener = new ReportEventAssertionListener( reportEntry, true ); |
| notifier.setTestFailedListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void shouldSendNextTestEvent() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.acquireNextTest(); |
| String read = new String( out.toByteArray(), UTF_8 ); |
| |
| assertThat( read ) |
| .isEqualTo( ":maven-surefire-event:next-test:\n" ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| EventAssertionListener listener = new EventAssertionListener(); |
| notifier.setAcquireNextTestListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testConsole() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.consoleInfoLog( "msg" ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StringEventAssertionListener listener = new StringEventAssertionListener( "msg" ); |
| notifier.setConsoleInfoListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testError() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.consoleErrorLog( "msg" ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StackTraceEventListener listener = new StackTraceEventListener( "msg", null, null ); |
| notifier.setConsoleErrorListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testErrorWithException() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| Throwable throwable = new Throwable( "msg" ); |
| encoder.consoleErrorLog( throwable ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| String stackTrace = ConsoleLoggerUtils.toString( throwable ); |
| StackTraceEventListener listener = new StackTraceEventListener( "msg", null, stackTrace ); |
| notifier.setConsoleErrorListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testErrorWithStackTraceWriter() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| StackTraceWriter stackTraceWriter = new DeserializedStacktraceWriter( "1", "2", "3" ); |
| encoder.consoleErrorLog( stackTraceWriter, false ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StackTraceEventListener listener = new StackTraceEventListener( "1", "2", "3" ); |
| notifier.setConsoleErrorListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testDebug() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.consoleDebugLog( "msg" ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StringEventAssertionListener listener = new StringEventAssertionListener( "msg" ); |
| notifier.setConsoleDebugListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| |
| assertThat( listener.msg ) |
| .isEqualTo( "msg" ); |
| } |
| |
| @Test |
| public void testWarning() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| encoder.consoleWarningLog( "msg" ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StringEventAssertionListener listener = new StringEventAssertionListener( "msg" ); |
| notifier.setConsoleWarningListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testStdOutStream() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| encoder.stdOut( "msg", false ); |
| wChannel.close(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StandardOutErrEventAssertionListener listener = |
| new StandardOutErrEventAssertionListener( NORMAL_RUN, "msg", false ); |
| notifier.setStdOutListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testStdOutStreamPrint() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| encoder.stdOut( "", false ); |
| wChannel.close(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StandardOutErrEventAssertionListener listener = |
| new StandardOutErrEventAssertionListener( NORMAL_RUN, "", false ); |
| notifier.setStdOutListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testStdOutStreamPrintWithNull() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| encoder.stdOut( null, false ); |
| wChannel.close(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StandardOutErrEventAssertionListener listener = |
| new StandardOutErrEventAssertionListener( NORMAL_RUN, null, false ); |
| notifier.setStdOutListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testStdOutStreamPrintln() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| encoder.stdOut( "", true ); |
| wChannel.close(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StandardOutErrEventAssertionListener listener = |
| new StandardOutErrEventAssertionListener( NORMAL_RUN, "", true ); |
| notifier.setStdOutListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testStdOutStreamPrintlnWithNull() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| encoder.stdOut( null, true ); |
| wChannel.close(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StandardOutErrEventAssertionListener listener = |
| new StandardOutErrEventAssertionListener( NORMAL_RUN, null, true ); |
| notifier.setStdOutListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void testStdErrStream() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| encoder.stdErr( "msg", false ); |
| wChannel.close(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| StandardOutErrEventAssertionListener listener = |
| new StandardOutErrEventAssertionListener( NORMAL_RUN, "msg", false ); |
| notifier.setStdErrListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void shouldCountSameNumberOfSystemProperties() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| WritableBufferedByteChannel wChannel = newBufferedChannel( out ); |
| LegacyMasterProcessChannelEncoder encoder = new LegacyMasterProcessChannelEncoder( wChannel ); |
| encoder.sendSystemProperties( ObjectUtils.systemProps() ); |
| wChannel.close(); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| PropertyEventAssertionListener listener = new PropertyEventAssertionListener(); |
| notifier.setSystemPropertiesListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| |
| @Test |
| public void shouldHandleErrorAfterNullLine() |
| { |
| ForkedProcessEventNotifier decoder = new ForkedProcessEventNotifier(); |
| decoder.setSystemPropertiesListener( new PropertyEventAssertionListener() ); |
| rule.expect( NullPointerException.class ); |
| decoder.notifyEvent( null ); |
| } |
| |
| @Test |
| public void shouldHandleErrorAfterUnknownOperation() throws Exception |
| { |
| String cmd = ":maven-surefire-event:abnormal-run:-:\n"; |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( cmd.getBytes() ) ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 1 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| when( logger.isDebugEnabled() ).thenReturn( true ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.dumpStreamText( anyString() ) ).thenReturn( new File( "" ) ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| countdown.awaitClosed(); |
| } |
| |
| ArgumentCaptor<String> dumpLine = ArgumentCaptor.forClass( String.class ); |
| verify( logger, times( 2 ) ).debug( dumpLine.capture() ); |
| assertThat( dumpLine.getAllValues() ) |
| .hasSize( 2 ) |
| .contains( ":maven-surefire-event:abnormal-run:", atIndex( 0 ) ) |
| .contains( "-:", atIndex( 1 ) ); |
| |
| ArgumentCaptor<String> dumpText = ArgumentCaptor.forClass( String.class ); |
| verify( arguments, times( 2 ) ).dumpStreamText( dumpText.capture() ); |
| String dump = "Corrupted STDOUT by directly writing to native stream in forked JVM 0."; |
| assertThat( dumpText.getAllValues() ) |
| .hasSize( 2 ) |
| .contains( format( dump + " Stream '%s'.", ":maven-surefire-event:abnormal-run:" ), atIndex( 0 ) ) |
| .contains( format( dump + " Stream '%s'.", "-:" ), atIndex( 1 ) ); |
| |
| ArgumentCaptor<String> warning = ArgumentCaptor.forClass( String.class ); |
| verify( arguments, times( 2 ) ).logWarningAtEnd( warning.capture() ); |
| dump += " See FAQ web page and the dump file "; |
| assertThat( warning.getAllValues() ) |
| .hasSize( 2 ); |
| assertThat( warning.getAllValues().get( 0 ) ) |
| .startsWith( dump ); |
| assertThat( warning.getAllValues().get( 1 ) ) |
| .startsWith( dump ); |
| } |
| |
| @Test |
| public void shouldHandleExit() throws Exception |
| { |
| final Stream out = Stream.newStream(); |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| |
| StackTraceWriter stackTraceWriter = mock( StackTraceWriter.class ); |
| when( stackTraceWriter.getThrowable() ).thenReturn( new SafeThrowable( "1" ) ); |
| when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( "2" ); |
| when( stackTraceWriter.writeTraceToString() ).thenReturn( "3" ); |
| when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( "4" ); |
| encoder.sendExitError( stackTraceWriter, false ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| ProcessExitErrorListener listener = new ProcessExitErrorListener(); |
| notifier.setExitErrorEventListener( listener ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| |
| assertThat( listener.called.get() ) |
| .isTrue(); |
| } |
| } |
| |
| /** |
| * |
| */ |
| @RunWith( Theories.class ) |
| public static class ReportEntryTest |
| { |
| @DataPoints( value = "operation" ) |
| @SuppressWarnings( "checkstyle:visibilitymodifier" ) |
| public static String[][] operations = { { "testSetStarting", "setTestSetStartingListener" }, |
| { "testSetCompleted", "setTestSetCompletedListener" }, |
| { "testStarting", "setTestStartingListener" }, |
| { "testSucceeded", "setTestSucceededListener" }, |
| { "testFailed", "setTestFailedListener" }, |
| { "testSkipped", "setTestSkippedListener" }, |
| { "testError", "setTestErrorListener" }, |
| { "testAssumptionFailure", "setTestAssumptionFailureListener" } |
| }; |
| |
| @DataPoints( value = "reportedMessage" ) |
| @SuppressWarnings( "checkstyle:visibilitymodifier" ) |
| public static String[] reportedMessage = { null, "skipped test" }; |
| |
| @DataPoints( value = "elapsed" ) |
| @SuppressWarnings( { "checkstyle:visibilitymodifier", "checkstyle:magicnumber" } ) |
| public static Integer[] elapsed = { null, 102 }; |
| |
| @DataPoints( value = "trim" ) |
| @SuppressWarnings( "checkstyle:visibilitymodifier" ) |
| public static boolean[] trim = { false, true }; |
| |
| @DataPoints( value = "msg" ) |
| @SuppressWarnings( "checkstyle:visibilitymodifier" ) |
| public static boolean[] msg = { false, true }; |
| |
| @DataPoints( value = "smart" ) |
| @SuppressWarnings( "checkstyle:visibilitymodifier" ) |
| public static boolean[] smart = { false, true }; |
| |
| @DataPoints( value = "trace" ) |
| @SuppressWarnings( "checkstyle:visibilitymodifier" ) |
| public static boolean[] trace = { false, true }; |
| |
| @Theory |
| public void testReportEntryOperations( @FromDataPoints( "operation" ) String[] operation, |
| @FromDataPoints( "reportedMessage" ) String reportedMessage, |
| @FromDataPoints( "elapsed" ) Integer elapsed, |
| @FromDataPoints( "trim" ) boolean trim, |
| @FromDataPoints( "msg" ) boolean msg, |
| @FromDataPoints( "smart" ) boolean smart, |
| @FromDataPoints( "trace" ) boolean trace ) |
| throws Exception |
| { |
| String exceptionMessage = msg ? "msg" : null; |
| String smartStackTrace = smart ? "MyTest:86 >> Error" : null; |
| String exceptionStackTrace = |
| trace ? ( trim ? "trace line 1\ntrace line 2" : "Exception: msg\ntrace line 1\ntrace line 2" ) |
| : null; |
| |
| StackTraceWriter stackTraceWriter = null; |
| if ( exceptionStackTrace != null ) |
| { |
| SafeThrowable safeThrowable = new SafeThrowable( exceptionMessage ); |
| stackTraceWriter = mock( StackTraceWriter.class ); |
| when( stackTraceWriter.getThrowable() ).thenReturn( safeThrowable ); |
| when( stackTraceWriter.smartTrimmedStackTrace() ).thenReturn( smartStackTrace ); |
| when( stackTraceWriter.writeTrimmedTraceToString() ).thenReturn( exceptionStackTrace ); |
| when( stackTraceWriter.writeTraceToString() ).thenReturn( exceptionStackTrace ); |
| } |
| |
| ReportEntry reportEntry = mock( ReportEntry.class ); |
| when( reportEntry.getElapsed() ).thenReturn( elapsed ); |
| when( reportEntry.getGroup() ).thenReturn( "this group" ); |
| when( reportEntry.getMessage() ).thenReturn( reportedMessage ); |
| when( reportEntry.getName() ).thenReturn( "my test" ); |
| when( reportEntry.getName() ).thenReturn( "display name of test" ); |
| when( reportEntry.getNameWithGroup() ).thenReturn( "name with group" ); |
| when( reportEntry.getSourceName() ).thenReturn( "pkg.MyTest" ); |
| when( reportEntry.getSourceText() ).thenReturn( "test class display name" ); |
| when( reportEntry.getStackTraceWriter() ).thenReturn( stackTraceWriter ); |
| |
| final Stream out = Stream.newStream(); |
| |
| LegacyMasterProcessChannelEncoder encoder = |
| new LegacyMasterProcessChannelEncoder( newBufferedChannel( out ) ); |
| |
| LegacyMasterProcessChannelEncoder.class.getMethod( operation[0], ReportEntry.class, boolean.class ) |
| .invoke( encoder, reportEntry, trim ); |
| |
| ForkedProcessEventNotifier notifier = new ForkedProcessEventNotifier(); |
| |
| ForkedProcessEventNotifier.class.getMethod( operation[1], ForkedProcessReportEventListener.class ) |
| .invoke( notifier, new ReportEventAssertionListener( reportEntry, stackTraceWriter != null ) ); |
| |
| ReadableByteChannel channel = newChannel( new ByteArrayInputStream( out.toByteArray() ) ); |
| |
| EH eventHandler = new EH(); |
| CountdownCloseable countdown = new CountdownCloseable( mock( Closeable.class ), 0 ); |
| ConsoleLogger logger = mock( ConsoleLogger.class ); |
| ForkNodeArguments arguments = mock( ForkNodeArguments.class ); |
| when( arguments.getConsoleLogger() ).thenReturn( logger ); |
| try ( EventConsumerThread t = new EventConsumerThread( "t", channel, eventHandler, countdown, arguments ) ) |
| { |
| t.start(); |
| notifier.notifyEvent( eventHandler.pullEvent() ); |
| } |
| } |
| } |
| |
| private static class ProcessExitErrorListener implements ForkedProcessExitErrorListener |
| { |
| final AtomicBoolean called = new AtomicBoolean(); |
| |
| @Override |
| public void handle( StackTraceWriter stackTrace ) |
| { |
| called.set( true ); |
| assertThat( stackTrace.getThrowable().getMessage() ).isEqualTo( "1" ); |
| assertThat( stackTrace.smartTrimmedStackTrace() ).isEqualTo( "2" ); |
| assertThat( stackTrace.writeTraceToString() ).isEqualTo( "3" ); |
| } |
| } |
| |
| private static class PropertyEventAssertionListener implements ForkedProcessPropertyEventListener |
| { |
| final AtomicBoolean called = new AtomicBoolean(); |
| private final Map<?, ?> sysProps = System.getProperties(); |
| private final AtomicInteger counter = new AtomicInteger(); |
| |
| public void handle( RunMode runMode, String key, String value ) |
| { |
| called.set( true ); |
| counter.incrementAndGet(); |
| assertThat( runMode ).isEqualTo( NORMAL_RUN ); |
| assertTrue( sysProps.containsKey( key ) ); |
| assertThat( sysProps.get( key ) ).isEqualTo( value ); |
| } |
| } |
| |
| private static class EventAssertionListener implements ForkedProcessEventListener |
| { |
| final AtomicBoolean called = new AtomicBoolean(); |
| |
| public void handle() |
| { |
| called.set( true ); |
| } |
| } |
| |
| private static class StringEventAssertionListener implements ForkedProcessStringEventListener |
| { |
| final AtomicBoolean called = new AtomicBoolean(); |
| private final String msg; |
| |
| StringEventAssertionListener( String msg ) |
| { |
| this.msg = msg; |
| } |
| |
| public void handle( String msg ) |
| { |
| called.set( true ); |
| assertThat( msg ) |
| .isEqualTo( this.msg ); |
| } |
| } |
| |
| private static class StackTraceEventListener implements ForkedProcessStackTraceEventListener |
| { |
| final AtomicBoolean called = new AtomicBoolean(); |
| private final String msg; |
| private final String smartStackTrace; |
| private final String stackTrace; |
| |
| StackTraceEventListener( String msg, String smartStackTrace, String stackTrace ) |
| { |
| this.msg = msg; |
| this.smartStackTrace = smartStackTrace; |
| this.stackTrace = stackTrace; |
| } |
| |
| @Override |
| public void handle( @Nonnull StackTraceWriter stackTrace ) |
| { |
| called.set( true ); |
| |
| assertThat( stackTrace.getThrowable().getMessage() ) |
| .isEqualTo( msg ); |
| |
| assertThat( stackTrace.smartTrimmedStackTrace() ) |
| .isEqualTo( smartStackTrace ); |
| |
| assertThat( stackTrace.writeTraceToString() ) |
| .isEqualTo( this.stackTrace ); |
| } |
| } |
| |
| private static class StandardOutErrEventAssertionListener implements ForkedProcessStandardOutErrEventListener |
| { |
| final AtomicBoolean called = new AtomicBoolean(); |
| private final RunMode runMode; |
| private final String output; |
| private final boolean newLine; |
| |
| StandardOutErrEventAssertionListener( RunMode runMode, String output, boolean newLine ) |
| { |
| this.runMode = runMode; |
| this.output = output; |
| this.newLine = newLine; |
| } |
| |
| public void handle( RunMode runMode, String output, boolean newLine ) |
| { |
| called.set( true ); |
| |
| assertThat( runMode ) |
| .isEqualTo( this.runMode ); |
| |
| assertThat( output ) |
| .isEqualTo( this.output ); |
| |
| assertThat( newLine ) |
| .isEqualTo( this.newLine ); |
| } |
| } |
| |
| private static class ReportEventAssertionListener implements ForkedProcessReportEventListener<ReportEntry> |
| { |
| final AtomicBoolean called = new AtomicBoolean(); |
| private final ReportEntry reportEntry; |
| private final boolean hasStackTrace; |
| |
| ReportEventAssertionListener( ReportEntry reportEntry, boolean hasStackTrace ) |
| { |
| this.reportEntry = reportEntry; |
| this.hasStackTrace = hasStackTrace; |
| } |
| |
| public void handle( RunMode runMode, ReportEntry reportEntry ) |
| { |
| called.set( true ); |
| assertThat( reportEntry.getSourceName() ).isEqualTo( this.reportEntry.getSourceName() ); |
| assertThat( reportEntry.getSourceText() ).isEqualTo( this.reportEntry.getSourceText() ); |
| assertThat( reportEntry.getName() ).isEqualTo( this.reportEntry.getName() ); |
| assertThat( reportEntry.getNameText() ).isEqualTo( this.reportEntry.getNameText() ); |
| assertThat( reportEntry.getGroup() ).isEqualTo( this.reportEntry.getGroup() ); |
| assertThat( reportEntry.getMessage() ).isEqualTo( this.reportEntry.getMessage() ); |
| assertThat( reportEntry.getElapsed() ).isEqualTo( this.reportEntry.getElapsed() ); |
| if ( reportEntry.getStackTraceWriter() == null ) |
| { |
| assertThat( hasStackTrace ).isFalse(); |
| assertThat( this.reportEntry.getStackTraceWriter() ).isNull(); |
| } |
| else |
| { |
| assertThat( hasStackTrace ).isTrue(); |
| assertThat( this.reportEntry.getStackTraceWriter() ).isNotNull(); |
| |
| assertThat( reportEntry.getStackTraceWriter().getThrowable().getMessage() ) |
| .isEqualTo( this.reportEntry.getStackTraceWriter().getThrowable().getMessage() ); |
| |
| assertThat( reportEntry.getStackTraceWriter().getThrowable().getLocalizedMessage() ) |
| .isEqualTo( this.reportEntry.getStackTraceWriter().getThrowable().getLocalizedMessage() ); |
| |
| assertThat( reportEntry.getStackTraceWriter().smartTrimmedStackTrace() ) |
| .isEqualTo( this.reportEntry.getStackTraceWriter().smartTrimmedStackTrace() ); |
| } |
| } |
| } |
| |
| private static class Stream extends PrintStream |
| { |
| private final ByteArrayOutputStream out; |
| |
| Stream( ByteArrayOutputStream out ) |
| { |
| super( out, true ); |
| this.out = out; |
| } |
| |
| byte[] toByteArray() |
| { |
| return out.toByteArray(); |
| } |
| |
| LineNumberReader newReader( Charset streamCharset ) |
| { |
| return new LineNumberReader( new StringReader( new String( toByteArray(), streamCharset ) ) ); |
| } |
| |
| static Stream newStream() |
| { |
| return new Stream( new ByteArrayOutputStream() ); |
| } |
| } |
| |
| private static byte[] toArray( ByteBuffer buffer ) |
| { |
| return copyOfRange( buffer.array(), buffer.arrayOffset(), buffer.arrayOffset() + buffer.remaining() ); |
| } |
| |
| private static class EH implements EventHandler<Event> |
| { |
| private final BlockingQueue<Event> cache = new LinkedTransferQueue<>(); |
| |
| Event pullEvent() throws InterruptedException |
| { |
| return cache.poll( 1, TimeUnit.MINUTES ); |
| } |
| |
| @Override |
| public void handleEvent( @Nonnull Event event ) |
| { |
| cache.add( event ); |
| } |
| } |
| } |
