public void DesignModeClientConnectShouldCallRequestManagerForAttachmentsProcessingStart()
{
var payload = new TestRunAttachmentsProcessingPayload();
var startAttachmentsProcessing = new Message {
MessageType = MessageType.TestRunAttachmentsProcessingStart, Payload = JToken.FromObject(payload)
};
this.mockCommunicationManager.Setup(cm => cm.WaitForServerConnection(It.IsAny <int>())).Returns(true);
this.mockCommunicationManager.SetupSequence(cm => cm.ReceiveMessage()).Returns(startAttachmentsProcessing);
this.mockTestRequestManager
.Setup(
rm => rm.ProcessTestRunAttachments(
It.IsAny <TestRunAttachmentsProcessingPayload>(),
It.IsAny <ITestRunAttachmentsProcessingEventsHandler>(),
It.IsAny <ProtocolConfig>()))
.Callback(() => complateEvent.Set());
this.designModeClient.ConnectToClientAndProcessRequests(PortNumber, this.mockTestRequestManager.Object);
Assert.IsTrue(this.complateEvent.WaitOne(Timeout), "AttachmentsProcessing not completed.");
this.mockCommunicationManager.Verify(cm => cm.SendMessage(MessageType.TestMessage, It.IsAny <TestMessagePayload>()), Times.Never);
this.mockCommunicationManager.Verify(cm => cm.SendMessage(MessageType.TestRunAttachmentsProcessingComplete, It.IsAny <TestRunAttachmentsProcessingCompletePayload>()), Times.Never);
this.mockTestRequestManager.Verify(rm => rm.ProcessTestRunAttachments(It.IsAny <TestRunAttachmentsProcessingPayload>(), It.IsAny <TestRunAttachmentsProcessingEventsHandler>(), It.IsAny <ProtocolConfig>()));
}
private void StartTestRunAttachmentsProcessing(TestRunAttachmentsProcessingPayload attachmentsProcessingPayload, ITestRequestManager testRequestManager)
{
Task.Run(
() =>
{
try
{
testRequestManager.ProcessTestRunAttachments(attachmentsProcessingPayload, new TestRunAttachmentsProcessingEventsHandler(this.communicationManager), this.protocolConfig);
}
catch (Exception ex)
{
EqtTrace.Error("DesignModeClient: Exception in StartTestRunAttachmentsProcessing: " + ex);
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
};
this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);
var payload = new TestRunAttachmentsProcessingCompletePayload()
{
Attachments = null
};
// Send run complete to translation layer
this.communicationManager.SendMessage(MessageType.TestRunAttachmentsProcessingComplete, payload);
}
});
}
/// <inheritdoc/>
public void ProcessTestRunAttachments(
TestRunAttachmentsProcessingPayload attachmentsProcessingPayload,
ITestRunAttachmentsProcessingEventsHandler attachmentsProcessingEventsHandler,
ProtocolConfig protocolConfig)
{
EqtTrace.Info("TestRequestManager.ProcessTestRunAttachments: Test run attachments processing started.");
this.telemetryOptedIn = attachmentsProcessingPayload.CollectMetrics;
var requestData = this.GetRequestData(protocolConfig);
// Make sure to run the run request inside a lock as the below section is not thread-safe.
// There can be only one discovery, execution or attachments processing request at a given
// point in time.
lock (this.syncObject)
{
try
{
EqtTrace.Info("TestRequestManager.ProcessTestRunAttachments: Synchronization context taken.");
this.TestPlatformEventSourceInstance.TestRunAttachmentsProcessingRequestStart();
this.currentAttachmentsProcessingCancellationTokenSource = new CancellationTokenSource();
Task task = this.attachmentsProcessingManager.ProcessTestRunAttachmentsAsync(
requestData,
attachmentsProcessingPayload.Attachments,
attachmentsProcessingEventsHandler,
this.currentAttachmentsProcessingCancellationTokenSource.Token);
task.Wait();
}
finally
{
if (this.currentAttachmentsProcessingCancellationTokenSource != null)
{
this.currentAttachmentsProcessingCancellationTokenSource.Dispose();
this.currentAttachmentsProcessingCancellationTokenSource = null;
}
EqtTrace.Info("TestRequestManager.ProcessTestRunAttachments: Test run attachments processing completed.");
this.TestPlatformEventSourceInstance.TestRunAttachmentsProcessingRequestStop();
// Post the attachments processing complete event.
this.metricsPublisher.Result.PublishMetrics(
TelemetryDataConstants.TestAttachmentsProcessingCompleteEvent,
requestData.MetricsCollection.Metrics);
}
}
}
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();
}
}