/// <inheritdoc />
public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler)
{
this.messageEventHandler = eventHandler;
this.onDisconnected = (disconnectedEventArgs) =>
{
this.OnTestRunAbort(eventHandler, disconnectedEventArgs.Error, true);
};
this.onMessageReceived = (sender, args) => this.OnExecutionMessageReceived(sender, args, eventHandler);
this.channel.MessageReceived += this.onMessageReceived;
var message = this.dataSerializer.SerializePayload(
MessageType.StartTestExecutionWithTests,
runCriteria,
this.protocolVersion);
this.channel.Send(message);
}
public void StartTestRunWithTestsShouldCallHandleTestRunStatsChange()
{
var mockHandler = new Mock <ITestRunEventsHandler>();
var runCriteria = new TestRunCriteriaWithTests(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
};
var waitHandle = new AutoResetEvent(false);
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);
waitHandle.Set();
});
this.testRequestSender.StartTestRun(runCriteria, mockHandler.Object);
waitHandle.WaitOne();
this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartTestExecutionWithTests, runCriteria), Times.Once);
mockHandler.Verify(mh => mh.HandleTestRunStatsChange(testRunChangedArgs), Times.Once);
mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.AtLeastOnce);
}
/// <inheritdoc />
public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler)
{
this.messageEventHandler = eventHandler;
this.onDisconnected = (disconnectedEventArgs) =>
{
this.OnTestRunAbort(eventHandler, disconnectedEventArgs.Error, true);
};
this.onMessageReceived = (sender, args) => this.OnExecutionMessageReceived(sender, args, eventHandler);
this.channel.MessageReceived += this.onMessageReceived;
var message = this.dataSerializer.SerializePayload(
MessageType.StartTestExecutionWithTests,
runCriteria,
this.protocolVersion);
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("TestRequestSender.StartTestRun: Sending test run with message: {0}", message);
}
this.channel.Send(message);
}
public void SendExecutionCompleteShouldSendTestRunCompletePayloadOnChannel()
{
var t1 = new TestCase("N.C.M1", new Uri("executor://mstest/v2"), "test1.dll");
var t2 = new TestCase("N.C.M2", new Uri("executor://mstest/v2"), "test1.dll");
var testCases = new[] { t1, t2 };
var testRunCriteriaWithTests = new TestRunCriteriaWithTests(testCases, "runsettings", null, null);
var message = this.dataSerializer.SerializePayload(MessageType.StartTestExecutionWithTests, testRunCriteriaWithTests);
this.mockExecutionManager.Setup(em => em.StartTestRun(It.IsAny <IEnumerable <TestCase> >(), It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <TestExecutionContext>(), It.IsAny <ITestCaseEventsHandler>(),
It.IsAny <ITestRunEventsHandler>())).Callback(() =>
{
this.requestHandler.SendExecutionComplete(It.IsAny <TestRunCompleteEventArgs>(), It.IsAny <TestRunChangedEventArgs>(), It.IsAny <ICollection <AttachmentSet> >(), It.IsAny <ICollection <string> >());
});
this.SetupChannel();
this.ProcessRequestsAsync(this.mockTestHostManagerFactory.Object);
this.mockChannel.Setup(mc => mc.Send(It.Is <string>(d => d.Contains(MessageType.ExecutionComplete))))
.Callback <string>(
(d) =>
{
var msg = this.dataSerializer.DeserializeMessage(d);
var payload = this.dataSerializer.DeserializePayload <TestRunCompletePayload>(msg);
Assert.IsNotNull(payload);
});
this.SendMessageOnChannel(message);
this.jobQueue.Flush();
mockExecutionManager.Verify(e =>
e.StartTestRun(
It.Is <IEnumerable <TestCase> >(tcs =>
tcs.Any(t => t.FullyQualifiedName.Equals("N.C.M1")) &&
tcs.Any(t => t.FullyQualifiedName.Equals("N.C.M2"))), It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <TestExecutionContext>(), It.IsAny <ITestCaseEventsHandler>(),
It.IsAny <ITestRunEventsHandler>()));
this.SendSessionEnd();
}
public void ProcessRequestsExecutionStartShouldStartExecutionWithGivenTests()
{
var t1 = new TestCase("N.C.M1", new Uri("executor://mstest/v2"), "test1.dll");
var t2 = new TestCase("N.C.M2", new Uri("executor://mstest/v2"), "test1.dll");
var testCases = new [] { t1, t2 };
var testRunCriteriaWithTests = new TestRunCriteriaWithTests(testCases, "runsettings", null, null);
var message = this.dataSerializer.SerializePayload(MessageType.StartTestExecutionWithTests, testRunCriteriaWithTests);
this.ProcessRequestsAsync(this.mockTestHostManagerFactory.Object);
this.SendMessageOnChannel(message);
this.jobQueue.Flush();
mockExecutionManager.Verify(e =>
e.StartTestRun(
It.Is <IEnumerable <TestCase> >(tcs =>
tcs.Any(t => t.FullyQualifiedName.Equals("N.C.M1")) &&
tcs.Any(t => t.FullyQualifiedName.Equals("N.C.M2"))), It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <TestExecutionContext>(), It.IsAny <ITestCaseEventsHandler>(),
It.IsAny <ITestRunEventsHandler>()));
this.SendSessionEnd();
}
/// <summary>
/// Executes the specified tests with the criteria mentioned.
/// </summary>
/// <param name="runCriteria">The test run criteria.</param>
/// <param name="eventHandler">The handler for execution events from the test host.</param>
public void StartTestRun(TestRunCriteriaWithTests runCriteria, ITestRunEventsHandler eventHandler)
{
this.StartTestRunAndListenAndReportTestResults(MessageType.StartTestExecutionWithTests, runCriteria, eventHandler);
}
/// <summary>
/// Starts the test run
/// </summary>
/// <param name="testRunCriteria"> The settings/options for the test run. </param>
/// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param>
/// <returns> The process id of the runner executing tests. </returns>
public virtual int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler)
{
try
{
if (!this.testHostManager.Shared)
{
// Non shared test host requires test source information to launch. Provide the sources
// information and create the channel.
EqtTrace.Verbose("ProxyExecutionManager: Test host is non shared. Lazy initialize.");
var testSources = testRunCriteria.Sources;
// If the test execution is with a test filter, group them by sources
if (testRunCriteria.HasSpecificTests)
{
testSources = testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key);
}
this.InitializeExtensions(testSources);
}
this.SetupChannel(testRunCriteria.Sources);
var executionContext = new TestExecutionContext(
testRunCriteria.FrequencyOfRunStatsChangeEvent,
testRunCriteria.RunStatsChangeEventTimeout,
inIsolation: false,
keepAlive: testRunCriteria.KeepAlive,
isDataCollectionEnabled: false,
areTestCaseLevelEventsRequired: false,
hasTestRun: true,
isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug),
testCaseFilter: testRunCriteria.TestCaseFilter);
if (testRunCriteria.HasSpecificSources)
{
var runRequest = new TestRunCriteriaWithSources(
testRunCriteria.AdapterSourceMap,
testRunCriteria.TestRunSettings,
executionContext);
this.RequestSender.StartTestRun(runRequest, eventHandler);
}
else
{
var runRequest = new TestRunCriteriaWithTests(
testRunCriteria.Tests,
testRunCriteria.TestRunSettings,
executionContext);
this.RequestSender.StartTestRun(runRequest, eventHandler);
}
}
catch (Exception exception)
{
EqtTrace.Error("ProxyExecutionManager.StartTestRun: Failed to start test run: {0}", exception);
var completeArgs = new TestRunCompleteEventArgs(null, false, false, exception, new Collection <AttachmentSet>(), TimeSpan.Zero);
eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message);
eventHandler.HandleTestRunComplete(completeArgs, null, null, null);
}
return(0);
}
/// <summary>
/// Starts the test run
/// </summary>
/// <param name="testRunCriteria"> The settings/options for the test run. </param>
/// <param name="eventHandler"> EventHandler for handling execution events from Engine. </param>
/// <returns> The process id of the runner executing tests. </returns>
public virtual int StartTestRun(TestRunCriteria testRunCriteria, ITestRunEventsHandler eventHandler)
{
try
{
EqtTrace.Verbose("ProxyExecutionManager: Test host is always Lazy initialize.");
var testSources = testRunCriteria.Sources;
// If the test execution is with a test filter, group them by sources
if (testRunCriteria.HasSpecificTests)
{
testSources = testRunCriteria.Tests.GroupBy(tc => tc.Source).Select(g => g.Key);
}
this.isCommunicationEstablished = this.SetupChannel(testSources, this.cancellationTokenSource.Token);
if (this.isCommunicationEstablished)
{
if (this.cancellationTokenSource.IsCancellationRequested)
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("ProxyExecutionManager.StartTestRun: Canceling the current run after getting cancelation request.");
}
throw new TestPlatformException(Resources.Resources.CancelationRequested);
}
this.InitializeExtensions(testSources);
var executionContext = new TestExecutionContext(
testRunCriteria.FrequencyOfRunStatsChangeEvent,
testRunCriteria.RunStatsChangeEventTimeout,
inIsolation: false,
keepAlive: testRunCriteria.KeepAlive,
isDataCollectionEnabled: false,
areTestCaseLevelEventsRequired: false,
hasTestRun: true,
isDebug: (testRunCriteria.TestHostLauncher != null && testRunCriteria.TestHostLauncher.IsDebug),
testCaseFilter: testRunCriteria.TestCaseFilter);
// This is workaround for the bug https://github.com/Microsoft/vstest/issues/970
var runsettings = this.RemoveNodesFromRunsettingsIfRequired(testRunCriteria.TestRunSettings, (testMessageLevel, message) => { this.LogMessage(testMessageLevel, message, eventHandler); });
if (testRunCriteria.HasSpecificSources)
{
var runRequest = new TestRunCriteriaWithSources(
testRunCriteria.AdapterSourceMap,
runsettings,
executionContext);
this.RequestSender.StartTestRun(runRequest, eventHandler);
}
else
{
var runRequest = new TestRunCriteriaWithTests(
testRunCriteria.Tests,
runsettings,
executionContext);
this.RequestSender.StartTestRun(runRequest, eventHandler);
}
}
}
catch (Exception exception)
{
EqtTrace.Error("ProxyExecutionManager.StartTestRun: Failed to start test run: {0}", exception);
this.LogMessage(TestMessageLevel.Error, exception.Message, eventHandler);
// 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, exception, new Collection <AttachmentSet>(), TimeSpan.Zero);
eventHandler.HandleTestRunComplete(completeArgs, null, null, null);
}
return(0);
}
