/// <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)); }