public void EventsHandlerHandleLogMessageShouldSendTestMessage()
{
string message = "error message";
handler.HandleLogMessage(TestMessageLevel.Error, message);
mockCommunicationManager.Verify(cm => cm.SendMessage(MessageType.TestMessage, It.Is <TestMessagePayload>(p => p.MessageLevel == TestMessageLevel.Error && p.Message == message)));
}
private async Task <Collection <AttachmentSet> > InternalProcessTestRunAttachmentsAsync(IRequestData requestData, Collection <AttachmentSet> attachments, ITestRunAttachmentsProcessingEventsHandler eventHandler, CancellationToken cancellationToken)
{
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
testPlatformEventSource.TestRunAttachmentsProcessingStart(attachments?.Count ?? 0);
requestData.MetricsCollection.Add(TelemetryDataConstants.NumberOfAttachmentsSentForProcessing, attachments?.Count ?? 0);
cancellationToken.ThrowIfCancellationRequested();
var taskCompletionSource = new TaskCompletionSource <Collection <AttachmentSet> >();
using (cancellationToken.Register(() => taskCompletionSource.TrySetCanceled()))
{
Task <Collection <AttachmentSet> > task = Task.Run(async() => await ProcessAttachmentsAsync(new Collection <AttachmentSet>(attachments.ToList()), eventHandler, cancellationToken));
var completedTask = await Task.WhenAny(task, taskCompletionSource.Task).ConfigureAwait(false);
if (completedTask == task)
{
return(FinalizeOperation(requestData, new TestRunAttachmentsProcessingCompleteEventArgs(false, null), await task, stopwatch, eventHandler));
}
else
{
eventHandler?.HandleLogMessage(TestMessageLevel.Informational, "Attachments processing was cancelled.");
return(FinalizeOperation(requestData, new TestRunAttachmentsProcessingCompleteEventArgs(true, null), attachments, stopwatch, eventHandler));
}
}
}
catch (OperationCanceledException)
{
if (EqtTrace.IsWarningEnabled)
{
EqtTrace.Warning("TestRunAttachmentsProcessingManager: operation was cancelled.");
}
return(FinalizeOperation(requestData, new TestRunAttachmentsProcessingCompleteEventArgs(true, null), attachments, stopwatch, eventHandler));
}
catch (Exception e)
{
EqtTrace.Error("TestRunAttachmentsProcessingManager: Exception in ProcessTestRunAttachmentsAsync: " + e);
eventHandler?.HandleLogMessage(TestMessageLevel.Error, e.Message);
return(FinalizeOperation(requestData, new TestRunAttachmentsProcessingCompleteEventArgs(false, e), attachments, stopwatch, eventHandler));
}
}
private async Task SendMessageAndListenAndReportAttachmentsProcessingResultAsync(IEnumerable <AttachmentSet> attachments, bool collectMetrics, ITestRunAttachmentsProcessingEventsHandler eventHandler, CancellationToken cancellationToken)
{
try
{
var payload = new TestRunAttachmentsProcessingPayload
{
Attachments = attachments,
CollectMetrics = collectMetrics
};
this.communicationManager.SendMessage(MessageType.TestRunAttachmentsProcessingStart, payload);
var isTestRunAttachmentsProcessingComplete = false;
using (cancellationToken.Register(() => this.communicationManager.SendMessage(MessageType.TestRunAttachmentsProcessingCancel)))
{
// Cycle through the messages that the vstest.console sends.
// Currently each of the operations are not separate tasks since they should not each take much time.
// This is just a notification.
while (!isTestRunAttachmentsProcessingComplete)
{
var message = await this.TryReceiveMessageAsync().ConfigureAwait(false);
if (string.Equals(MessageType.TestRunAttachmentsProcessingComplete, message.MessageType))
{
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("VsTestConsoleRequestSender.SendMessageAndListenAndReportAttachments: Process complete.");
}
var testRunAttachmentsProcessingCompletePayload = this.dataSerializer.DeserializePayload <TestRunAttachmentsProcessingCompletePayload>(message);
eventHandler.HandleTestRunAttachmentsProcessingComplete(testRunAttachmentsProcessingCompletePayload.AttachmentsProcessingCompleteEventArgs, testRunAttachmentsProcessingCompletePayload.Attachments);
isTestRunAttachmentsProcessingComplete = true;
}
else if (string.Equals(MessageType.TestRunAttachmentsProcessingProgress, message.MessageType))
{
var testRunAttachmentsProcessingProgressPayload = this.dataSerializer.DeserializePayload <TestRunAttachmentsProcessingProgressPayload>(message);
eventHandler.HandleTestRunAttachmentsProcessingProgress(testRunAttachmentsProcessingProgressPayload.AttachmentsProcessingProgressEventArgs);
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
}
else
{
EqtTrace.Warning($"VsTestConsoleRequestSender.SendMessageAndListenAndReportAttachments: Unexpected message received {message.MessageType}.");
}
}
}
}
catch (Exception exception)
{
EqtTrace.Error("Aborting Test Session End Operation: {0}", exception);
eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestRunAttachmentsProcessing);
eventHandler.HandleTestRunAttachmentsProcessingComplete(new TestRunAttachmentsProcessingCompleteEventArgs(false, exception), null);
// Earlier we were closing the connection with vstest.console in case of exceptions
// Removing that code because vstest.console might be in a healthy state and letting the client
// know of the error, so that the TL can wait for the next instruction from the client itself.
// Also, connection termination might not kill the process which could result in files being locked by testhost.
}
finally
{
this.testPlatformEventSource.TranslationLayerTestRunAttachmentsProcessingStop();
}
}
public void SendMessage(TestMessageLevel testMessageLevel, string message)
{
eventsHandler.HandleLogMessage(testMessageLevel, message);
}