private void OnExecutionMessageReceived(object sender, MessageReceivedEventArgs messageReceived, ITestRunEventsHandler testRunEventsHandler)
{
try
{
var rawMessage = messageReceived.Data;
// Send raw message first to unblock handlers waiting to send message to IDEs
testRunEventsHandler.HandleRawMessage(rawMessage);
var message = this.dataSerializer.DeserializeMessage(rawMessage);
switch (message.MessageType)
{
case MessageType.TestRunStatsChange:
var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(message);
testRunEventsHandler.HandleTestRunStatsChange(testRunChangedArgs);
break;
case MessageType.ExecutionComplete:
var testRunCompletePayload = this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message);
testRunEventsHandler.HandleTestRunComplete(
testRunCompletePayload.TestRunCompleteArgs,
testRunCompletePayload.LastRunTests,
testRunCompletePayload.RunAttachments,
testRunCompletePayload.ExecutorUris);
this.SetOperationComplete();
break;
case MessageType.TestMessage:
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
testRunEventsHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
break;
case MessageType.LaunchAdapterProcessWithDebuggerAttached:
var testProcessStartInfo = this.dataSerializer.DeserializePayload <TestProcessStartInfo>(message);
int processId = testRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo);
var data =
this.dataSerializer.SerializePayload(
MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback,
processId,
this.protocolVersion);
this.channel.Send(data);
break;
}
}
catch (Exception exception)
{
this.OnTestRunAbort(testRunEventsHandler, exception, false);
}
}
private async Task SendMessageAndListenAndReportTestResultsAsync(string messageType, object payload, ITestRunEventsHandler eventHandler, ITestHostLauncher customHostLauncher)
{
try
{
this.communicationManager.SendMessage(messageType, payload, this.protocolVersion);
var isTestRunComplete = false;
// Cycle through the messages that the testhost sends.
// Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification.
while (!isTestRunComplete)
{
var message = await this.TryReceiveMessageAsync();
if (string.Equals(MessageType.TestRunStatsChange, message.MessageType))
{
var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(
message);
eventHandler.HandleTestRunStatsChange(testRunChangedArgs);
}
else if (string.Equals(MessageType.ExecutionComplete, message.MessageType))
{
var testRunCompletePayload =
this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message);
eventHandler.HandleTestRunComplete(
testRunCompletePayload.TestRunCompleteArgs,
testRunCompletePayload.LastRunTests,
testRunCompletePayload.RunAttachments,
testRunCompletePayload.ExecutorUris);
isTestRunComplete = true;
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
}
else if (string.Equals(MessageType.CustomTestHostLaunch, message.MessageType))
{
HandleCustomHostLaunch(customHostLauncher, message);
}
}
}
catch (Exception exception)
{
EqtTrace.Error("Aborting Test Run Operation: {0}", exception);
eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsRun);
var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero);
eventHandler.HandleTestRunComplete(completeArgs, null, null, null);
this.CleanupCommunicationIfProcessExit();
}
this.testPlatformEventSource.TranslationLayerExecutionStop();
}
// mock a VsTest run. Provides test result one by one at 10 ms intervals
// note: a lot of information is still missing (vs real VsTest). You will have to add them if your test requires them
private void MoqTestRun(ITestRunEventsHandler testRunEvents, IReadOnlyList <TestResult> testResults)
{
Task.Run(() =>
{
var timer = new Stopwatch();
testRunEvents.HandleTestRunStatsChange(
new TestRunChangedEventArgs(new TestRunStatistics(0, null), null, new[] { testResults[0].TestCase }));
for (var i = 0; i < testResults.Count; i++)
{
Thread.Sleep(10);
testResults[i].EndTime = DateTimeOffset.Now;
testRunEvents.HandleTestRunStatsChange(new TestRunChangedEventArgs(
new TestRunStatistics(i + 1, null), new[] { testResults[i] }, null));
}
Thread.Sleep(10);
testRunEvents.HandleTestRunComplete(
new TestRunCompleteEventArgs(new TestRunStatistics(testResults.Count, null), false, false, null,
null, timer.Elapsed),
null,
null,
null);
});
}
private void ListenAndReportTestResults(ITestRunEventsHandler testRunEventsHandler)
{
var isTestRunComplete = false;
// Cycle through the messages that the testhost sends.
// Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification.
while (!isTestRunComplete)
{
try
{
var rawMessage = this.TryReceiveRawMessage();
// Send raw message first to unblock handlers waiting to send message to IDEs
testRunEventsHandler.HandleRawMessage(rawMessage);
var message = this.dataSerializer.DeserializeMessage(rawMessage);
if (string.Equals(MessageType.TestRunStatsChange, message.MessageType))
{
var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(
message);
testRunEventsHandler.HandleTestRunStatsChange(testRunChangedArgs);
}
else if (string.Equals(MessageType.ExecutionComplete, message.MessageType))
{
var testRunCompletePayload =
this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message);
testRunEventsHandler.HandleTestRunComplete(
testRunCompletePayload.TestRunCompleteArgs,
testRunCompletePayload.LastRunTests,
testRunCompletePayload.RunAttachments,
testRunCompletePayload.ExecutorUris);
isTestRunComplete = true;
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
testRunEventsHandler.HandleLogMessage(
testMessagePayload.MessageLevel,
testMessagePayload.Message);
}
else if (string.Equals(MessageType.LaunchAdapterProcessWithDebuggerAttached, message.MessageType))
{
var testProcessStartInfo = this.dataSerializer.DeserializePayload <TestProcessStartInfo>(message);
int processId = testRunEventsHandler.LaunchProcessWithDebuggerAttached(testProcessStartInfo);
this.communicationManager.SendMessage(
MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback,
processId,
version: this.protocolVersion);
}
}
catch (IOException exception)
{
// To avoid further communication with remote host
this.sendMessagesToRemoteHost = false;
this.OnTestRunAbort(testRunEventsHandler, exception);
isTestRunComplete = true;
}
catch (Exception exception)
{
this.OnTestRunAbort(testRunEventsHandler, exception);
isTestRunComplete = true;
}
}
}
private async Task SendMessageAndListenAndReportTestResultsAsync(string messageType, object payload, ITestRunEventsHandler eventHandler, ITestHostLauncher customHostLauncher)
{
try
{
this.communicationManager.SendMessage(messageType, payload, this.protocolVersion);
var isTestRunComplete = false;
// Cycle through the messages that the testhost sends.
// Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification.
while (!isTestRunComplete)
{
var message = await this.TryReceiveMessageAsync();
if (string.Equals(MessageType.TestRunStatsChange, message.MessageType))
{
var testRunChangedArgs = this.dataSerializer.DeserializePayload <TestRunChangedEventArgs>(
message);
eventHandler.HandleTestRunStatsChange(testRunChangedArgs);
}
else if (string.Equals(MessageType.ExecutionComplete, message.MessageType))
{
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("VsTestConsoleRequestSender.SendMessageAndListenAndReportTestResultsAsync: Execution complete.");
}
var testRunCompletePayload =
this.dataSerializer.DeserializePayload <TestRunCompletePayload>(message);
eventHandler.HandleTestRunComplete(
testRunCompletePayload.TestRunCompleteArgs,
testRunCompletePayload.LastRunTests,
testRunCompletePayload.RunAttachments,
testRunCompletePayload.ExecutorUris);
isTestRunComplete = true;
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
}
else if (string.Equals(MessageType.CustomTestHostLaunch, message.MessageType))
{
HandleCustomHostLaunch(customHostLauncher, message);
}
else if (string.Equals(MessageType.EditorAttachDebugger, message.MessageType))
{
AttachDebuggerToProcess(customHostLauncher, message);
}
}
}
catch (Exception exception)
{
EqtTrace.Error("Aborting Test Run Operation: {0}", exception);
eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsRun);
var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero);
eventHandler.HandleTestRunComplete(completeArgs, null, null, 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.
}
this.testPlatformEventSource.TranslationLayerExecutionStop();
}