public void StartTestRunShouldCallHandleTestRunCompleteOnRunCompletion()
{
var mockHandler = new Mock <ITestRunEventsHandler>();
var runCriteria = new TestRunCriteriaWithTests(null, null, null);
var rawMessage = "ExecComplete";
var message = new Message()
{
MessageType = MessageType.ExecutionComplete, Payload = null
};
var payload = new TestRunCompletePayload()
{
ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null
};
this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(message)).Returns(payload);
var waitHandle = new AutoResetEvent(false);
mockHandler.Setup(mh => mh.HandleTestRunComplete(
It.IsAny <TestRunCompleteEventArgs>(),
It.IsAny <TestRunChangedEventArgs>(),
It.IsAny <ICollection <AttachmentSet> >(),
It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set());
this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object);
waitHandle.WaitOne();
this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithTests, runCriteria, this.protocolConfig.Version), Times.Once);
this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Once);
mockHandler.Verify(mh => mh.HandleTestRunComplete(null, null, null, null), Times.Once);
mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Once);
}
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool skipTestHostLaunch)
{
Task.Run(
delegate
{
try
{
testRequestManager.ResetOptions();
var customLauncher = skipTestHostLaunch ?
DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(this, testRunPayload) : null;
testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
}
catch (Exception ex)
{
EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex);
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
};
this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);
var runCompletePayload = new TestRunCompletePayload()
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue),
LastRunTests = null
};
// Send run complete to translation layer
this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload);
}
});
}
private void OnTestRunAbort(ITestRunEventsHandler testRunEventsHandler, Exception exception)
{
EqtTrace.Error("Server: TestExecution: Aborting test run because {0}", exception);
// log console message to vstest console
testRunEventsHandler.HandleLogMessage(TestMessageLevel.Error, CommonResources.AbortedTestRun);
// log console message to vstest console wrapper
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = CommonResources.AbortedTestRun
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
testRunEventsHandler.HandleRawMessage(rawMessage);
// notify test run abort to vstest console wrapper
var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero);
var payload = new TestRunCompletePayload {
TestRunCompleteArgs = completeArgs
};
rawMessage = this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, payload);
testRunEventsHandler.HandleRawMessage(rawMessage);
// notify of a test run complete and bail out.
testRunEventsHandler.HandleTestRunComplete(completeArgs, null, null, null);
this.CleanupCommunicationIfProcessExit();
}
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool skipTestHostLaunch)
{
Task.Run(
delegate
{
try
{
testRequestManager.ResetOptions();
var customLauncher = skipTestHostLaunch ?
DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(this, testRunPayload) : null;
testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
}
catch (Exception ex)
{
EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex);
// If there is an exception during test run request creation or some time during the process
// In such cases, TestPlatform will never send a TestRunComplete event and IDE need to be sent a run complete message
// We need recoverability in translationlayer-designmode scenarios
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
};
this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);
var runCompletePayload = new TestRunCompletePayload()
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue),
LastRunTests = null
};
// Send run complete to translation layer
this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload);
}
});
}
private void OnTestRunAbort(ITestRunEventsHandler testRunEventsHandler, Exception exception, bool getClientError)
{
if (this.IsOperationComplete())
{
EqtTrace.Verbose("TestRequestSender: OnTestRunAbort: Operation is already complete. Skip error message.");
return;
}
EqtTrace.Verbose("TestRequestSender: OnTestRunAbort: Set operation complete.");
this.SetOperationComplete();
var reason = this.GetAbortErrorMessage(exception, getClientError);
EqtTrace.Error("TestRequestSender: Aborting test run because {0}", reason);
this.LogErrorMessage(string.Format(CommonResources.AbortedTestRun, reason));
// notify test run abort to vstest console wrapper.
var completeArgs = new TestRunCompleteEventArgs(null, false, true, exception, null, TimeSpan.Zero);
var payload = new TestRunCompletePayload {
TestRunCompleteArgs = completeArgs
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, payload);
testRunEventsHandler.HandleRawMessage(rawMessage);
// notify of a test run complete and bail out.
testRunEventsHandler.HandleTestRunComplete(completeArgs, null, null, null);
}
public void OnTestRunComplete(TestRunCompletePayload testRunComplete)
{
if (testRunComplete.TestRunCompleteArgs.IsAborted || testRunComplete.TestRunCompleteArgs.IsCanceled)
{
return;
}
if (testRunComplete.LastRunTests != null)
{
OnTestRunChanged(testRunComplete.LastRunTests);
}
}
public void ExecutionManagerShouldPassOnLaunchProcessWithDebuggerAttached()
{
Mock <ITestRunEventsHandler> mockTestRunEventsHandler = new Mock <ITestRunEventsHandler>();
var runCriteria = new Mock <TestRunCriteria>(
new List <TestCase> {
new TestCase("A.C.M", new System.Uri("executor://dummy"), "source.dll")
},
10);
var rawMessage = "LaunchProcessWithDebugger";
var message = new Message()
{
MessageType = MessageType.LaunchAdapterProcessWithDebuggerAttached, Payload = null
};
var payload = new TestProcessStartInfo();
this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestProcessStartInfo>(message)).Returns(payload);
var completePayload = new TestRunCompletePayload()
{
ExecutorUris = null,
LastRunTests = null,
RunAttachments = null,
TestRunCompleteArgs = null
};
var completeMessage = new Message()
{
MessageType = MessageType.ExecutionComplete, Payload = null
};
mockTestRunEventsHandler.Setup(mh => mh.LaunchProcessWithDebuggerAttached(payload)).Callback(
() =>
{
this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload);
});
var waitHandle = new AutoResetEvent(false);
mockTestRunEventsHandler.Setup(mh => mh.HandleTestRunComplete(
It.IsAny <TestRunCompleteEventArgs>(),
It.IsAny <TestRunChangedEventArgs>(),
It.IsAny <ICollection <AttachmentSet> >(),
It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set());
this.testExecutionManager.StartTestRun(runCriteria.Object, mockTestRunEventsHandler.Object);
waitHandle.WaitOne();
// Verify
mockTestRunEventsHandler.Verify(mtdeh => mtdeh.LaunchProcessWithDebuggerAttached(It.IsAny <TestProcessStartInfo>()), Times.Once);
}
public void StartTestRunShouldCallLaunchProcessWithDebuggerAndWaitForCallback()
{
var mockHandler = new Mock <ITestRunEventsHandler>();
var runCriteria = new TestRunCriteriaWithSources(null, null, null);
var rawMessage = "LaunchProcessWithDebugger";
var message = new Message()
{
MessageType = MessageType.LaunchAdapterProcessWithDebuggerAttached, Payload = null
};
var payload = new TestProcessStartInfo();
this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestProcessStartInfo>(message)).Returns(payload);
var completePayload = new TestRunCompletePayload()
{
ExecutorUris = null,
LastRunTests = null,
RunAttachments = null,
TestRunCompleteArgs = null
};
var completeMessage = new Message()
{
MessageType = MessageType.ExecutionComplete, Payload = null
};
mockHandler.Setup(mh => mh.LaunchProcessWithDebuggerAttached(payload)).Callback(
() =>
{
this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload);
});
var waitHandle = new AutoResetEvent(false);
mockHandler.Setup(mh => mh.HandleTestRunComplete(
It.IsAny <TestRunCompleteEventArgs>(),
It.IsAny <TestRunChangedEventArgs>(),
It.IsAny <ICollection <AttachmentSet> >(),
It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set());
this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object);
waitHandle.WaitOne();
this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithSources, runCriteria, this.protocolConfig.Version), Times.Once);
this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(It.IsAny <string>()), Times.Exactly(2));
mockHandler.Verify(mh => mh.LaunchProcessWithDebuggerAttached(payload), Times.Once);
mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Exactly(2));
this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.LaunchAdapterProcessWithDebuggerAttachedCallback, It.IsAny <object>(), this.protocolConfig.Version), Times.Once);
}
public void ExecutionManagerShouldPassOnTestRunStatsChange()
{
this.mockFileHelper.Setup(fh => fh.Exists(It.IsAny <string>())).Returns(true);
Mock <ITestRunEventsHandler> mockTestRunEventsHandler = new Mock <ITestRunEventsHandler>();
var runCriteria = new Mock <TestRunCriteria>(
new List <TestCase> {
new TestCase("A.C.M", new System.Uri("executor://dummy"), "source.dll")
},
10);
var testRunChangedArgs = new TestRunChangedEventArgs(null, null, null);
this.testExecutionManager = this.GetProxyExecutionManager();
var completePayload = new TestRunCompletePayload()
{
ExecutorUris = null,
LastRunTests = null,
RunAttachments = null,
TestRunCompleteArgs = null
};
var completeMessage = new Message()
{
MessageType = MessageType.ExecutionComplete, Payload = null
};
this.SetupChannelMessage(MessageType.StartTestExecutionWithTests, MessageType.TestRunStatsChange, testRunChangedArgs);
mockTestRunEventsHandler.Setup(mh => mh.HandleTestRunStatsChange(It.IsAny <TestRunChangedEventArgs>())).Callback(
() =>
{
this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload);
this.mockDataSerializer.Setup(ds => ds.SerializeMessage(It.IsAny <string>()))
.Returns(MessageType.SessionEnd);
this.RaiseMessageReceived(MessageType.ExecutionComplete);
});
var waitHandle = new AutoResetEvent(false);
mockTestRunEventsHandler.Setup(mh => mh.HandleTestRunComplete(
It.IsAny <TestRunCompleteEventArgs>(),
It.IsAny <TestRunChangedEventArgs>(),
It.IsAny <ICollection <AttachmentSet> >(),
It.IsAny <ICollection <string> >())).Callback(() => waitHandle.Set());
// Act.
this.testExecutionManager.StartTestRun(runCriteria.Object, mockTestRunEventsHandler.Object);
waitHandle.WaitOne();
// Verify
mockTestRunEventsHandler.Verify(mtdeh => mtdeh.HandleTestRunStatsChange(It.IsAny <TestRunChangedEventArgs>()), Times.Once);
}
public void StartTestRunWithSourcesShouldCallHandleTestRunStatsChange()
{
var mockHandler = new Mock <ITestRunEventsHandler>();
var runCriteria = new TestRunCriteriaWithSources(null, null, null);
var testRunChangedArgs = new TestRunChangedEventArgs(null, null, null);
var rawMessage = "OnTestRunStatsChange";
var message = new Message()
{
MessageType = MessageType.TestRunStatsChange, Payload = null
};
this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunChangedEventArgs>(message)).Returns(testRunChangedArgs);
var completePayload = new TestRunCompletePayload()
{
ExecutorUris = null,
LastRunTests = null,
RunAttachments = null,
TestRunCompleteArgs = null
};
var completeMessage = new Message()
{
MessageType = MessageType.ExecutionComplete, Payload = null
};
mockHandler.Setup(mh => mh.HandleTestRunStatsChange(testRunChangedArgs)).Callback(
() =>
{
this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Returns(completePayload);
});
var waitHandle = new AutoResetEvent(false);
mockHandler.Setup(mh => mh.HandleTestRunComplete(It.IsAny <TestRunCompleteEventArgs>(),
It.IsAny <TestRunChangedEventArgs>(), It.IsAny <ICollection <AttachmentSet> >(), It.IsAny <ICollection <string> >())).Callback
(() => waitHandle.Set());
this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object);
waitHandle.WaitOne();
this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithSources, runCriteria), Times.Once);
// One for run stats and another for runcomplete
this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Exactly(2));
mockHandler.Verify(mh => mh.HandleTestRunStatsChange(testRunChangedArgs), Times.Once);
mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Exactly(2));
}
/// <inheritdoc/>
public void SendExecutionComplete(
TestRunCompleteEventArgs testRunCompleteArgs,
TestRunChangedEventArgs lastChunkArgs,
ICollection <AttachmentSet> runContextAttachments,
ICollection <string> executorUris)
{
var payload = new TestRunCompletePayload
{
TestRunCompleteArgs = testRunCompleteArgs,
LastRunTests = lastChunkArgs,
RunAttachments = runContextAttachments,
ExecutorUris = executorUris
};
this.communicationManager.SendMessage(MessageType.ExecutionComplete, payload, this.protocolVersion);
}
public void StartTestRunShouldCallHandleLogMessageOnTestMessage()
{
var mockHandler = new Mock <ITestRunEventsHandler>();
var runCriteria = new TestRunCriteriaWithSources(null, null, null, null);
var rawMessage = "OnLogMessage";
var message = new Message()
{
MessageType = MessageType.TestMessage, Payload = null
};
var payload = new TestMessagePayload()
{
MessageLevel = TestMessageLevel.Error, Message = rawMessage
};
this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestMessagePayload>(message)).Returns(payload);
var completePayload = new TestRunCompletePayload()
{
ExecutorUris = null, LastRunTests = null, RunAttachments = null, TestRunCompleteArgs = null
};
var completeMessage = new Message()
{
MessageType = MessageType.ExecutionComplete, Payload = null
};
var waitHandle = new AutoResetEvent(false);
mockHandler.Setup(mh => mh.HandleLogMessage(TestMessageLevel.Error, rawMessage)).Callback(
() =>
{
this.mockDataSerializer.Setup(ds => ds.DeserializeMessage(It.IsAny <string>())).Returns(completeMessage);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage)).Callback(() => { waitHandle.Set(); })
.Returns(completePayload);
});
this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object);
waitHandle.WaitOne();
this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithSources, runCriteria, this.protocolConfig.Version), Times.Once);
this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(It.IsAny <string>()), Times.AtLeast(2));
// Asserting that 'StartTestRun" should have been completed, & invoked only once
this.mockDataSerializer.Verify(ds => ds.DeserializePayload <TestRunCompletePayload>(completeMessage), Times.Exactly(1));
mockHandler.Verify(mh => mh.HandleLogMessage(payload.MessageLevel, payload.Message), Times.Once);
mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.AtLeastOnce);
}
public void StartTestRunShouldStopServerOnRunCompleteMessageReceived()
{
var testRunCompletePayload = new TestRunCompletePayload
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, false, null, null, TimeSpan.MaxValue),
LastRunTests = new TestRunChangedEventArgs(null, null, null),
RunAttachments = new List <AttachmentSet>()
};
this.SetupDeserializeMessage(MessageType.ExecutionComplete, testRunCompletePayload);
this.SetupFakeCommunicationChannel();
this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object);
this.RaiseMessageReceivedEvent();
this.mockServer.Verify(ms => ms.Stop());
}
/// <summary>
/// Update raw message with telemetry info.
/// </summary>
/// <param name="testRunCompletePayload">Test run complete payload.</param>
/// <param name="message">Updated rawMessage.</param>
/// <returns></returns>
private string UpdateRawMessageWithTelemetryInfo(TestRunCompletePayload testRunCompletePayload, Message message)
{
var rawMessage = default(string);
if (this.requestData.IsTelemetryOptedIn)
{
if (testRunCompletePayload?.TestRunCompleteArgs != null)
{
if (testRunCompletePayload.TestRunCompleteArgs.Metrics == null)
{
testRunCompletePayload.TestRunCompleteArgs.Metrics = this.requestData.MetricsCollection.Metrics;
}
else
{
foreach (var kvp in this.requestData.MetricsCollection.Metrics)
{
testRunCompletePayload.TestRunCompleteArgs.Metrics[kvp.Key] = kvp.Value;
}
}
// Fill in the time taken to complete the run
var executionTotalTimeTakenForDesignMode = DateTime.UtcNow - this.executionStartTime;
testRunCompletePayload.TestRunCompleteArgs.Metrics[TelemetryDataConstants.TimeTakenInSecForRun] = executionTotalTimeTakenForDesignMode.TotalSeconds;
}
if (message is VersionedMessage message1)
{
var version = message1.Version;
rawMessage = this.dataSerializer.SerializePayload(
MessageType.ExecutionComplete,
testRunCompletePayload,
version);
}
else
{
rawMessage = this.dataSerializer.SerializePayload(
MessageType.ExecutionComplete,
testRunCompletePayload);
}
}
return(rawMessage);
}
public void StartTestRunShouldNotNotifyExecutionCompleteIfClientDisconnectedAndOperationComplete()
{
var testRunCompletePayload = new TestRunCompletePayload
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, false, null, null, TimeSpan.MaxValue),
LastRunTests = new TestRunChangedEventArgs(null, null, null),
RunAttachments = new List <AttachmentSet>()
};
this.SetupDeserializeMessage(MessageType.ExecutionComplete, testRunCompletePayload);
this.SetupFakeCommunicationChannel();
this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object);
this.RaiseMessageReceivedEvent(); // Raise test run complete
this.RaiseClientDisconnectedEvent();
this.mockExecutionEventsHandler.Verify(eh => eh.HandleTestRunComplete(It.Is <TestRunCompleteEventArgs>(t => t.IsAborted), null, null, null), Times.Never);
this.mockExecutionEventsHandler.Verify(eh => eh.HandleRawMessage("SerializedAbortedPayload"), Times.Never);
}
protected void HandleParallelTestRunComplete(TestRunCompleteEventArgs completedArgs)
{
// In case of sequential execution - RawMessage would have contained a 'TestRunCompletePayload' object
// To send a rawmessge - we need to create rawmessage from an aggregated payload object
var testRunCompletePayload = new TestRunCompletePayload()
{
ExecutorUris = this.runDataAggregator.ExecutorUris,
LastRunTests = null,
RunAttachments = this.runDataAggregator.RunContextAttachments,
TestRunCompleteArgs = completedArgs
};
// we have to send rawmessages as we block the runcomplete actual raw messages
ConvertToRawMessageAndSend(MessageType.ExecutionComplete, testRunCompletePayload);
// send actual test runcomplete to clients
this.actualRunEventsHandler.HandleTestRunComplete(
completedArgs, null, this.runDataAggregator.RunContextAttachments, this.runDataAggregator.ExecutorUris);
}
private void StartTestRun(TestRunRequestPayload testRunPayload, ITestRequestManager testRequestManager, bool shouldLaunchTesthost)
{
Task.Run(
() =>
{
try
{
testRequestManager.ResetOptions();
// We must avoid re-launching the test host if the test run payload already
// contains test session info. Test session info being present is an indicative
// of an already running test host spawned by a start test session call.
var customLauncher =
shouldLaunchTesthost && testRunPayload.TestSessionInfo == null
? DesignModeTestHostLauncherFactory.GetCustomHostLauncherForTestRun(
this,
testRunPayload.DebuggingEnabled)
: null;
testRequestManager.RunTests(testRunPayload, customLauncher, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
}
catch (Exception ex)
{
EqtTrace.Error("DesignModeClient: Exception in StartTestRun: " + ex);
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
};
this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);
var runCompletePayload = new TestRunCompletePayload()
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, ex, null, TimeSpan.MinValue),
LastRunTests = null
};
// Send run complete to translation layer
this.communicationManager.SendMessage(MessageType.ExecutionComplete, runCompletePayload);
}
});
}
public void StartTestRunShouldNotifyExecutionCompleteOnRunCompleteMessageReceived()
{
var testRunCompletePayload = new TestRunCompletePayload
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, false, null, null, TimeSpan.MaxValue),
LastRunTests = new TestRunChangedEventArgs(null, null, null),
RunAttachments = new List <AttachmentSet>()
};
this.SetupDeserializeMessage(MessageType.ExecutionComplete, testRunCompletePayload);
this.SetupFakeCommunicationChannel();
this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object);
this.RaiseMessageReceivedEvent();
this.mockExecutionEventsHandler.Verify(
eh => eh.HandleTestRunComplete(
testRunCompletePayload.TestRunCompleteArgs,
testRunCompletePayload.LastRunTests,
testRunCompletePayload.RunAttachments,
It.IsAny <ICollection <string> >()),
Times.Once);
}
/// <summary>
/// Handles LoggerManager's TestRunComplete.
/// </summary>
/// <param name="testRunCompletePayload">TestRun complete payload.</param>
private void HandleLoggerManagerTestRunComplete(TestRunCompletePayload testRunCompletePayload)
{
if (this.LoggerManager.LoggersInitialized && testRunCompletePayload != null)
{
// Send last chunk to logger manager.
if (testRunCompletePayload.LastRunTests != null)
{
this.LoggerManager.HandleTestRunStatsChange(testRunCompletePayload.LastRunTests);
}
// Note: In HandleRawMessage attachments are considered from TestRunCompleteArgs, while in HandleTestRunComplete attachments are considered directly from testRunCompletePayload.
// Ideally we should have attachmentSets at one place only.
// Send test run complete to logger manager.
TestRunCompleteEventArgs testRunCompleteArgs =
new TestRunCompleteEventArgs(
testRunCompletePayload.TestRunCompleteArgs.TestRunStatistics,
testRunCompletePayload.TestRunCompleteArgs.IsCanceled,
testRunCompletePayload.TestRunCompleteArgs.IsAborted,
testRunCompletePayload.TestRunCompleteArgs.Error,
testRunCompletePayload.TestRunCompleteArgs.AttachmentSets,
this.runRequestTimeTracker.Elapsed);
this.LoggerManager.HandleTestRunComplete(testRunCompleteArgs);
}
}
private async void StartMessageLoop(TaskCompletionSource <object> tcs)
{
while (isConnected)
{
var message = await ReceiveMessageAsync();
if (message != null)
{
if (message.MessageType == MessageType.SessionConnected)
{
// Version Check
comm.SendMessage(MessageType.VersionCheck, 1);
tcs.TrySetResult(null);
SendTestHostLaunched();
isConnected = true;
}
else if (!isConnected)
{
continue;
}
else if (message.MessageType == MessageType.StartDiscovery)
{
var req = comm.DeserializePayload <DiscoveryRequestPayload>(message);
comm.SendMessage(MessageType.DiscoveryInitialize);
var tests = ViewModels.TestRunnerVM.Instance.Tests;
comm.SendMessage(MessageType.DiscoveryComplete, new
DiscoveryCompletePayload()
{
LastDiscoveredTests = tests.Select(t => t.Test), TotalTests = tests.Count()
});
}
else if (message.MessageType == MessageType.TestRunSelectedTestCasesDefaultHost ||
message.MessageType == MessageType.TestRunAllSourcesWithDefaultHost)
{
var trr = comm.DeserializePayload <TestRunRequestPayload>(message);
if (trr.TestCases != null)
{
var testsToRun = ViewModels.TestRunnerVM.Instance.Tests.Select(t => t.Test).Where(t => trr.TestCases.Any(t2 => t2.Id == t.Id)).ToList();
DateTime start = DateTime.Now;
var _ = ViewModels.TestRunnerVM.Instance.Run(testsToRun, new SettingsXmlImpl(ViewModels.TestRunnerVM.Instance.Settings.AppendParameters(trr.RunSettings))).ContinueWith(task =>
{
TimeSpan elapsedTime = DateTime.Now - start;
if (task.IsCanceled)
{
SendMessage(MessageType.CancelTestRun);
}
else if (task.Exception != null)
{
SendMessage(MessageType.TestMessage, new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = task.Exception.ToString()
});
var runCompletePayload = new TestRunCompletePayload()
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, task.Exception, null, TimeSpan.MinValue),
LastRunTests = null
};
SendMessage(MessageType.ExecutionComplete, runCompletePayload);
}
else
{
var results = task.Result;
var stats = new Dictionary <TestOutcome, long>()
{
{ TestOutcome.Passed, results.Where(t => t.Outcome == TestOutcome.Passed).Count() },
{ TestOutcome.Failed, results.Where(t => t.Outcome == TestOutcome.Failed).Count() },
{ TestOutcome.Skipped, results.Where(t => t.Outcome == TestOutcome.Skipped).Count() },
{ TestOutcome.NotFound, results.Where(t => t.Outcome == TestOutcome.NotFound).Count() },
{ TestOutcome.None, results.Where(t => t.Outcome == TestOutcome.None).Count() }
};
var testRunStats = new TestRunStatistics(results.Count(), stats);
var payload = new TestRunCompletePayload()
{
LastRunTests = new TestRunChangedEventArgs(testRunStats, results, testsToRun),
RunAttachments = new List <AttachmentSet>(),
TestRunCompleteArgs = new TestRunCompleteEventArgs(testRunStats, false, false, null, new System.Collections.ObjectModel.Collection <AttachmentSet>(), elapsedTime)
};
SendMessage(MessageType.ExecutionComplete, payload);
}
});
}
}
else
{
System.Diagnostics.Debug.WriteLine($"Got message: {message.MessageType}, Payload={message.Payload}");
}
}
}
comm.StopServer();
_ = StartAsync();
}
/// <summary>
/// Handles the Run Complete event from a parallel proxy manager
/// </summary>
public void HandleTestRunComplete(
TestRunCompleteEventArgs testRunCompleteArgs,
TestRunChangedEventArgs lastChunkArgs,
ICollection <AttachmentSet> runContextAttachments,
ICollection <string> executorUris)
{
// we get run complete events from each executor process
// so we cannot "complete" the actual executor operation until all sources/testcases are consumed
// We should not block last chunk results while we aggregate overall run data
if (lastChunkArgs != null)
{
ConvertToRawMessageAndSend(MessageType.TestRunStatsChange, lastChunkArgs);
HandleTestRunStatsChange(lastChunkArgs);
}
// Update runstats, executorUris, etc.
// we need this data when we send the final runcomplete
runDataAggregator.Aggregate(
testRunCompleteArgs.TestRunStatistics,
executorUris,
testRunCompleteArgs.Error,
testRunCompleteArgs.ElapsedTimeInRunningTests,
testRunCompleteArgs.IsAborted,
testRunCompleteArgs.IsCanceled,
runContextAttachments,
testRunCompleteArgs.AttachmentSets);
// Do not send TestRunComplete to actual test run handler
// We need to see if there are still sources to execute - let the parallel manager decide
var parallelRunComplete = this.parallelProxyExecutionManager.HandlePartialRunComplete(
this.proxyExecutionManager,
testRunCompleteArgs,
null, // lastChunk should be null as we already sent this data above
runContextAttachments,
executorUris);
if (parallelRunComplete)
{
// todo : Merge Code Coverage files here
var completedArgs = new TestRunCompleteEventArgs(runDataAggregator.GetAggregatedRunStats(),
runDataAggregator.IsCanceled,
runDataAggregator.IsAborted,
runDataAggregator.GetAggregatedException(),
new Collection <AttachmentSet>(runDataAggregator.RunCompleteArgsAttachments),
runDataAggregator.ElapsedTime);
// In case of sequential execution - RawMessage would have contained a 'TestRunCompletePayload' object
// To send a rawmessge - we need to create rawmessage from an aggregated payload object
var testRunCompletePayload = new TestRunCompletePayload()
{
ExecutorUris = runDataAggregator.ExecutorUris,
LastRunTests = null,
RunAttachments = runDataAggregator.RunContextAttachments,
TestRunCompleteArgs = completedArgs
};
// we have to send rawmessages as we block the runcomplete actual raw messages
ConvertToRawMessageAndSend(MessageType.ExecutionComplete, testRunCompletePayload);
// send actual test runcomplete to clients
this.actualRunEventsHandler.HandleTestRunComplete(
completedArgs, null, runDataAggregator.RunContextAttachments, runDataAggregator.ExecutorUris);
}
}
/// <inheritdoc/>
public virtual int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler)
{
this.baseTestRunEventsHandler = eventHandler;
try
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("ProxyExecutionManager: Test host is always Lazy initialize.");
}
var testSources = new List <string>(
testRunCriteria.HasSpecificSources
? testRunCriteria.Sources
// If the test execution is with a test filter, group them by sources.
: testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key));
this.isCommunicationEstablished = this.ProxyOperationManager.SetupChannel(
testSources,
testRunCriteria.TestRunSettings);
if (this.isCommunicationEstablished)
{
this.ProxyOperationManager.CancellationTokenSource.Token.ThrowTestPlatformExceptionIfCancellationRequested();
this.InitializeExtensions(testSources);
// This code should be in sync with InProcessProxyExecutionManager.StartTestRun
// execution context.
var executionContext = new TestExecutionContext(
testRunCriteria.FrequencyOfRunStatsChangeEvent,
testRunCriteria.RunStatsChangeEventTimeout,
inIsolation: false,
keepAlive: testRunCriteria.KeepAlive,
isDataCollectionEnabled: false,
areTestCaseLevelEventsRequired: false,
hasTestRun: true,
// Debugging should happen if there's a custom test host launcher present
// and is in debugging mode, or if the debugging is enabled in case the
// test session info is present.
isDebug:
(testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug) ||
this.debugEnabledForTestSession,
testCaseFilter: testRunCriteria.TestCaseFilter,
filterOptions: testRunCriteria.FilterOptions);
// This is workaround for the bug https://github.com/Microsoft/vstest/issues/970
var runsettings = this.ProxyOperationManager.RemoveNodesFromRunsettingsIfRequired(
testRunCriteria.TestRunSettings,
(testMessageLevel, message) => { this.LogMessage(testMessageLevel, message); });
if (testRunCriteria.HasSpecificSources)
{
var runRequest = testRunCriteria.CreateTestRunCriteriaForSources(
testHostManager,
runsettings,
executionContext,
testSources);
this.ProxyOperationManager.RequestSender.StartTestRun(runRequest, this);
}
else
{
var runRequest = testRunCriteria.CreateTestRunCriteriaForTests(
testHostManager,
runsettings,
executionContext,
testSources);
this.ProxyOperationManager.RequestSender.StartTestRun(runRequest, this);
}
}
}
catch (Exception exception)
{
EqtTrace.Error("ProxyExecutionManager.StartTestRun: Failed to start test run: {0}", exception);
// Log error message to design mode and CLI.
// TestPlatformException is expected exception, log only the message.
// For other exceptions, log the stacktrace as well.
var errorMessage = exception is TestPlatformException ? exception.Message : exception.ToString();
var testMessagePayload = new TestMessagePayload()
{
MessageLevel = TestMessageLevel.Error,
Message = errorMessage
};
this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload));
this.LogMessage(TestMessageLevel.Error, errorMessage);
// Send a run complete to caller. Similar logic is also used in
// ParallelProxyExecutionManager.StartTestRunOnConcurrentManager.
//
// Aborted is `true`: in case of parallel run (or non shared host), an aborted
// message ensures another execution manager created to replace the current one.
// This will help if the current execution manager is aborted due to irreparable
// error and the test host is lost as well.
var completeArgs = new TestRunCompleteEventArgs(null, false, true, null, new Collection <AttachmentSet>(), TimeSpan.Zero);
var testRunCompletePayload = new TestRunCompletePayload {
TestRunCompleteArgs = completeArgs
};
this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.ExecutionComplete, testRunCompletePayload));
this.HandleTestRunComplete(completeArgs, null, null, null);
}
return(0);
}
