/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
if (showDiagnostics && message is _DiagnosticMessage diagnosticMessage)
{
lock (consoleLock)
{
if (!noColor)
{
ConsoleHelper.SetForegroundColor(displayColor);
}
if (assemblyDisplayName == null)
{
Console.WriteLine(diagnosticMessage.Message);
}
else
{
Console.WriteLine($" {assemblyDisplayName}: {diagnosticMessage.Message}");
}
if (!noColor)
{
ConsoleHelper.ResetColor();
}
}
}
return(true);
}
public DelegatingExecutionSummarySinkTests()
{
innerSink = Substitute.For <_IMessageSink>();
innerSink.OnMessage(null !).ReturnsForAnyArgs(true);
testMessage = new _MessageSinkMessage();
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(message);
return
(DiscoverySink.OnMessage(message) &&
!cancelThunk());
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
return
(message.DispatchWhen(DiagnosticMessageEvent) &&
message.DispatchWhen(ErrorMessageEvent));
}
public void BaseSerializationIncludesTypeName()
{
var msg = new _MessageSinkMessage();
var result = Encoding.UTF8.GetString(msg.ToJson());
Assert.Equal(@"{""$type"":""_MessageSinkMessage""}", result);
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
if (message is _TestSkipped testSkipped)
{
var testFailed = new _TestFailed
{
AssemblyUniqueID = testSkipped.AssemblyUniqueID,
ExceptionParentIndices = new[] { -1 },
ExceptionTypes = new[] { "FAIL_SKIP" },
ExecutionTime = 0m,
Messages = new[] { testSkipped.Reason },
Output = "",
StackTraces = new[] { "" },
TestCaseUniqueID = testSkipped.TestCaseUniqueID,
TestClassUniqueID = testSkipped.TestClassUniqueID,
TestCollectionUniqueID = testSkipped.TestCollectionUniqueID,
TestMethodUniqueID = testSkipped.TestMethodUniqueID,
TestUniqueID = testSkipped.TestUniqueID
};
return(innerSink.OnMessage(testFailed));
}
// TODO: Shouldn't there be conversions of all the finished messages up the stack, to rectify the counts?
if (message is _TestCollectionFinished testCollectionFinished)
{
testCollectionFinished = new _TestCollectionFinished
{
AssemblyUniqueID = testCollectionFinished.AssemblyUniqueID,
ExecutionTime = testCollectionFinished.ExecutionTime,
TestCollectionUniqueID = testCollectionFinished.TestCollectionUniqueID,
TestsFailed = testCollectionFinished.TestsFailed + testCollectionFinished.TestsSkipped,
TestsRun = testCollectionFinished.TestsRun,
TestsSkipped = 0
};
return(innerSink.OnMessage(testCollectionFinished));
}
if (message is _TestAssemblyFinished assemblyFinished)
{
assemblyFinished = new _TestAssemblyFinished
{
AssemblyUniqueID = assemblyFinished.AssemblyUniqueID,
ExecutionTime = assemblyFinished.ExecutionTime,
TestsFailed = assemblyFinished.TestsFailed + assemblyFinished.TestsSkipped,
TestsRun = assemblyFinished.TestsRun,
TestsSkipped = 0
};
return(innerSink.OnMessage(assemblyFinished));
}
return(innerSink.OnMessage(message));
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(message);
return
(message.DispatchWhen(TestCaseDiscoveredEvent) &&
message.DispatchWhen(DiscoveryCompleteEvent) &&
message.DispatchWhen(DiscoveryStartingEvent));
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
if (message is _MessageSinkMessage v3Message)
{
logger.LogImportantMessage(Encoding.UTF8.GetString(v3Message.ToJson()));
}
return(true);
}
public void MessagesAreDispatchedImmediatelyFromBus()
{
var msg1 = new _MessageSinkMessage();
var dispatchedMessages = new List <_MessageSinkMessage>();
using (var bus = new SynchronousMessageBus(SpyMessageSink.Create(messages: dispatchedMessages)))
Assert.True(bus.QueueMessage(msg1));
Assert.Collection(dispatchedMessages, message => Assert.Same(msg1, message));
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
return
(message.DispatchWhen(TestAssemblyDiscoveryFinishedEvent) &&
message.DispatchWhen(TestAssemblyDiscoveryStartingEvent) &&
message.DispatchWhen(TestAssemblyExecutionFinishedEvent) &&
message.DispatchWhen(TestAssemblyExecutionStartingEvent) &&
message.DispatchWhen(TestExecutionSummariesEvent));
}
public bool OnMessage(_MessageSinkMessage message)
{
if (message is _TestCaseDiscovered discovered)
{
if (!filter(discovered))
{
return(true);
}
}
return(innerMessageSink.OnMessage(message));
}
/// <inheritdoc/>
public virtual bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
var result = true;
lock (AggregatedSinks)
foreach (var dispatcher in AggregatedSinks)
{
result = dispatcher.OnMessage(message) && result;
}
return(result);
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
if (message is _TestCaseDiscovered discoveryMessage)
{
TestCases.Add(discoveryMessage);
}
if (message is _DiscoveryComplete)
{
Finished.Set();
}
return(true);
}
/// <summary>
/// Handles a message of a specific type by testing it for the type, as well as verifying that there
/// is a registered callback.
/// </summary>
/// <param name="message">The message to dispatch.</param>
/// <param name="callback">The callback to dispatch the message to.</param>
/// <returns>Returns <c>true</c> if processing should continue; <c>false</c> otherwise.</returns>
public static bool DispatchWhen <TMessage>(
this _MessageSinkMessage message,
MessageHandler <TMessage>?callback)
where TMessage : _MessageSinkMessage
{
Guard.ArgumentNotNull(nameof(message), message);
if (callback != null && message is TMessage castMessage)
{
var args = new MessageHandlerArgs <TMessage>(castMessage);
callback(args);
return(!args.IsStopped);
}
return(true);
}
/// <summary/>
public bool QueueMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
if (shutdownRequested)
{
throw new ObjectDisposedException("MessageBus");
}
if (stopOnFail && message is _TestFailed)
{
continueRunning = false;
}
reporterQueue.Enqueue(message);
reporterWorkEvent.Set();
return(continueRunning);
}
public static void WhenSinkThrowsMessagesContinueToBeDelivered()
{
var sink = Substitute.For <_IMessageSink>();
var msg1 = new _MessageSinkMessage();
var msg2 = new _MessageSinkMessage();
var msg3 = new _MessageSinkMessage();
var messages = new List <_MessageSinkMessage>();
sink
.OnMessage(Arg.Any <_MessageSinkMessage>())
.Returns(callInfo =>
{
var msg = (_MessageSinkMessage)callInfo[0];
if (msg == msg2)
{
throw new DivideByZeroException("whee!");
}
else
{
messages.Add(msg);
}
return(false);
});
using (var bus = new MessageBus(sink))
{
bus.QueueMessage(msg1);
bus.QueueMessage(msg2);
bus.QueueMessage(msg3);
}
Assert.Collection(
messages,
message => Assert.Same(message, msg1),
message =>
{
var errorMessage = Assert.IsAssignableFrom <_ErrorMessage>(message);
Assert.Equal("System.DivideByZeroException", errorMessage.ExceptionTypes.Single());
Assert.Equal("whee!", errorMessage.Messages.Single());
},
message => Assert.Same(message, msg3)
);
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
var result = innerSink.OnMessage(message);
return
(message.DispatchWhen <_ErrorMessage>(args => Interlocked.Increment(ref errors)) &&
message.DispatchWhen <_TestAssemblyCleanupFailure>(args => Interlocked.Increment(ref errors)) &&
message.DispatchWhen <_TestAssemblyFinished>(HandleTestAssemblyFinished) &&
message.DispatchWhen <_TestAssemblyStarting>(HandleTestAssemblyStarting) &&
message.DispatchWhen <_TestCaseCleanupFailure>(args => Interlocked.Increment(ref errors)) &&
message.DispatchWhen <_TestClassCleanupFailure>(args => Interlocked.Increment(ref errors)) &&
message.DispatchWhen <_TestCleanupFailure>(args => Interlocked.Increment(ref errors)) &&
message.DispatchWhen <_TestCollectionCleanupFailure>(args => Interlocked.Increment(ref errors)) &&
message.DispatchWhen <_TestMethodCleanupFailure>(args => Interlocked.Increment(ref errors)) &&
result &&
!cancelThunk());
}
public static void QueueReturnsTrueForFailIfStopOnFailFalse()
{
var messages = new List <_MessageSinkMessage>();
var sink = SpyMessageSink.Create(messages: messages);
var msg1 = new _MessageSinkMessage();
var msg2 = TestData.TestFailed();
var msg3 = new _MessageSinkMessage();
using (var bus = new MessageBus(sink))
{
Assert.True(bus.QueueMessage(msg1));
Assert.True(bus.QueueMessage(msg2));
Assert.True(bus.QueueMessage(msg3));
}
Assert.Collection(
messages,
message => Assert.Same(msg1, message),
message => Assert.Same(msg2, message),
message => Assert.Same(msg3, message)
);
}
public static void QueuedMessageShowUpInMessageSink()
{
var messages = new List <_MessageSinkMessage>();
var sink = SpyMessageSink.Create(messages: messages);
var msg1 = new _MessageSinkMessage();
var msg2 = new _MessageSinkMessage();
var msg3 = new _MessageSinkMessage();
using (var bus = new MessageBus(sink))
{
bus.QueueMessage(msg1);
bus.QueueMessage(msg2);
bus.QueueMessage(msg3);
}
Assert.Collection(
messages,
message => Assert.Same(msg1, message),
message => Assert.Same(msg2, message),
message => Assert.Same(msg3, message)
);
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(nameof(message), message);
// Call the inner sink first, because we want to be able to depend on ExecutionSummary
// being correctly filled out.
var result = innerSink.OnMessage(message);
return(message.DispatchWhen <_ErrorMessage>(HandleErrorMessage)
&& message.DispatchWhen <_TestAssemblyCleanupFailure>(HandleTestAssemblyCleanupFailure) &&
message.DispatchWhen <_TestAssemblyFinished>(HandleTestAssemblyFinished) &&
message.DispatchWhen <_TestAssemblyStarting>(HandleTestAssemblyStarting)
&& message.DispatchWhen <_TestCaseCleanupFailure>(HandleTestCaseCleanupFailure) &&
message.DispatchWhen <_TestCaseFinished>(HandleTestCaseFinished) &&
message.DispatchWhen <_TestCaseStarting>(HandleTestCaseStarting)
&& message.DispatchWhen <_TestClassCleanupFailure>(HandleTestClassCleanupFailure) &&
message.DispatchWhen <_TestClassFinished>(HandleTestClassFinished) &&
message.DispatchWhen <_TestClassStarting>(HandleTestClassStarting)
&& message.DispatchWhen <_TestCollectionCleanupFailure>(HandleTestCollectionCleanupFailure) &&
message.DispatchWhen <_TestCollectionFinished>(HandleTestCollectionFinished) &&
message.DispatchWhen <_TestCollectionStarting>(HandleTestCollectionStarting)
&& message.DispatchWhen <_TestMethodCleanupFailure>(HandleTestMethodCleanupFailure) &&
message.DispatchWhen <_TestMethodFinished>(HandleTestMethodFinished) &&
message.DispatchWhen <_TestMethodStarting>(HandleTestMethodStarting)
&& message.DispatchWhen <_TestCleanupFailure>(HandleTestCleanupFailure) &&
message.DispatchWhen <_TestFailed>(HandleTestFailed) &&
message.DispatchWhen <_TestFinished>(HandleTestFinished) &&
message.DispatchWhen <_TestPassed>(HandleTestPassed) &&
message.DispatchWhen <_TestSkipped>(HandleTestSkipped) &&
message.DispatchWhen <_TestStarting>(HandleTestStarting)
&& result);
}
/// <inheritdoc/>
public bool OnMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(message);
return
(message.DispatchWhen(AfterTestFinishedEvent) &&
message.DispatchWhen(AfterTestStartingEvent) &&
message.DispatchWhen(BeforeTestFinishedEvent) &&
message.DispatchWhen(BeforeTestStartingEvent) &&
message.DispatchWhen(TestAssemblyCleanupFailureEvent) &&
message.DispatchWhen(TestAssemblyFinishedEvent) &&
message.DispatchWhen(TestAssemblyStartingEvent) &&
message.DispatchWhen(TestCaseCleanupFailureEvent) &&
message.DispatchWhen(TestCaseFinishedEvent) &&
message.DispatchWhen(TestCaseStartingEvent) &&
message.DispatchWhen(TestClassCleanupFailureEvent) &&
message.DispatchWhen(TestClassConstructionFinishedEvent) &&
message.DispatchWhen(TestClassConstructionStartingEvent) &&
message.DispatchWhen(TestClassDisposeFinishedEvent) &&
message.DispatchWhen(TestClassDisposeStartingEvent) &&
message.DispatchWhen(TestClassFinishedEvent) &&
message.DispatchWhen(TestClassStartingEvent) &&
message.DispatchWhen(TestCleanupFailureEvent) &&
message.DispatchWhen(TestCollectionCleanupFailureEvent) &&
message.DispatchWhen(TestCollectionFinishedEvent) &&
message.DispatchWhen(TestCollectionStartingEvent) &&
message.DispatchWhen(TestFailedEvent) &&
message.DispatchWhen(TestFinishedEvent) &&
message.DispatchWhen(TestMethodCleanupFailureEvent) &&
message.DispatchWhen(TestMethodFinishedEvent) &&
message.DispatchWhen(TestMethodStartingEvent) &&
message.DispatchWhen(TestOutputEvent) &&
message.DispatchWhen(TestPassedEvent) &&
message.DispatchWhen(TestSkippedEvent) &&
message.DispatchWhen(TestStartingEvent));
}
public bool QueueMessage(_MessageSinkMessage message)
{
Messages.Add(message);
return(cancellationThunk(message));
}
/// <inheritdoc/>
public virtual bool OnMessage(_MessageSinkMessage message)
{
callback?.Invoke(message);
return(innerSink.OnMessage(message));
}
/// <inheritdoc/> public bool OnMessage(_MessageSinkMessage message) => true;
/// <inheritdoc/>
public virtual bool QueueMessage(_MessageSinkMessage message)
{
callback?.Invoke(message);
return(innerMessageBus.QueueMessage(message));
}
/// <summary/>
public bool QueueMessage(_MessageSinkMessage message)
{
Guard.ArgumentNotNull(message);
return(messageSink.OnMessage(message));
}
