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);
}
});
}
private void StartDiscovery(DiscoveryRequestPayload discoveryRequestPayload, ITestRequestManager testRequestManager)
{
Task.Run(
delegate
{
try
{
testRequestManager.ResetOptions();
testRequestManager.DiscoverTests(discoveryRequestPayload, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
}
catch (Exception ex)
{
EqtTrace.Error("DesignModeClient: Exception in StartDiscovery: " + ex);
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = ex.ToString()
};
this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload);
var payload = new DiscoveryCompletePayload()
{
IsAborted = true,
LastDiscoveredTests = null,
TotalTests = -1
};
// Send run complete to translation layer
this.communicationManager.SendMessage(MessageType.DiscoveryComplete, payload);
}
});
}
private void onTestMessageReceived(object sender, TestMessagePayload e)
{
if (e.MessageLevel != TestMessageLevel.Informational)
{
this.messageLogger.SendMessage(e.MessageLevel, e.Message);
}
}
internal void InvokeMessageReceived(object sender, TestMessagePayload args)
{
if (!this.DisableInvoke && this.onTestMessageReceived != null)
{
this.onTestMessageReceived.Invoke(sender, args);
}
}
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);
}
});
}
/// <summary>
/// Discovers tests
/// </summary>
/// <param name="discoveryCriteria">Settings, parameters for the discovery request</param>
/// <param name="eventHandler">EventHandler for handling discovery events from Engine</param>
public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler eventHandler)
{
try
{
if (!this.testHostManager.Shared)
{
// If the test host doesn't support sharing across sources, we must initialize it
// with sources.
this.InitializeExtensions(discoveryCriteria.Sources);
}
this.SetupChannel(discoveryCriteria.Sources);
this.RequestSender.DiscoverTests(discoveryCriteria, eventHandler);
}
catch (Exception exception)
{
EqtTrace.Error("ProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception);
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = exception.Message
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
eventHandler.HandleRawMessage(rawMessage);
// Log to vstest.console
eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message);
eventHandler.HandleDiscoveryComplete(0, new List <ObjectModel.TestCase>(), false);
}
}
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 OnDiscoveryAbort(ITestDiscoveryEventsHandler eventHandler)
{
// Log to vstest console
eventHandler.HandleLogMessage(TestMessageLevel.Error, CommonResources.AbortedTestDiscovery);
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = CommonResources.AbortedTestDiscovery
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
eventHandler.HandleRawMessage(rawMessage);
// Notify discovery abort to IDE test output
var payload = new DiscoveryCompletePayload()
{
IsAborted = true,
LastDiscoveredTests = null,
TotalTests = -1
};
rawMessage = this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, payload);
eventHandler.HandleRawMessage(rawMessage);
// Complete discovery
eventHandler.HandleDiscoveryComplete(-1, null, true);
this.CleanupCommunicationIfProcessExit();
}
private void OnTestMessageReceived(object sender, TestMessagePayload e)
{
if (e.MessageLevel != TestMessageLevel.Informational)
{
this.frameworkHandle.SendMessage(e.MessageLevel, e.Message);
}
}
/// <summary>
/// Discovers tests
/// </summary>
/// <param name="discoveryCriteria">Settings, parameters for the discovery request</param>
/// <param name="eventHandler">EventHandler for handling discovery events from Engine</param>
public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler eventHandler)
{
try
{
this.isCommunicationEstablished = this.SetupChannel(discoveryCriteria.Sources, this.cancellationTokenSource.Token);
if (this.isCommunicationEstablished)
{
this.InitializeExtensions(discoveryCriteria.Sources);
this.RequestSender.DiscoverTests(discoveryCriteria, eventHandler);
}
}
catch (Exception exception)
{
EqtTrace.Error("ProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception);
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = exception.Message
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
eventHandler.HandleRawMessage(rawMessage);
// Log to vstest.console
// Send a discovery complete to caller. Similar logic is also used in ParallelProxyDiscoveryManager.DiscoverTestsOnConcurrentManager
// Aborted is `true`: in case of parallel discovery (or non shared host), an aborted message ensures another discovery manager
// created to replace the current one. This will help if the current discovery manager is aborted due to irreparable error
// and the test host is lost as well.
eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message);
eventHandler.HandleDiscoveryComplete(-1, new List <ObjectModel.TestCase>(), true);
}
}
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 OnDiscoveryAbort(ITestDiscoveryEventsHandler eventHandler, Exception exception)
{
EqtTrace.Error("Server: TestExecution: Aborting test discovery because {0}", exception);
var reason = string.Format(CommonResources.AbortedTestDiscovery, exception?.Message);
// Log to vstest console
eventHandler.HandleLogMessage(TestMessageLevel.Error, reason);
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = reason
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
eventHandler.HandleRawMessage(rawMessage);
// Notify discovery abort to IDE test output
var payload = new DiscoveryCompletePayload()
{
IsAborted = true,
LastDiscoveredTests = null,
TotalTests = -1
};
rawMessage = this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, payload);
eventHandler.HandleRawMessage(rawMessage);
// Complete discovery
eventHandler.HandleDiscoveryComplete(-1, null, true);
this.CleanupCommunicationIfProcessExit();
}
private void StartDiscovery(DiscoveryRequestPayload discoveryRequestPayload, ITestRequestManager testRequestManager)
{
Task.Run(
delegate
{
try
{
testRequestManager.ResetOptions();
testRequestManager.DiscoverTests(discoveryRequestPayload, new DesignModeTestEventsRegistrar(this), this.protocolConfig);
}
catch (Exception ex)
{
EqtTrace.Error("DesignModeClient: Exception in StartDiscovery: " + ex);
// If there is an exception during test discovery request creation or some time during the process
// In such cases, TestPlatform will never send a DiscoveryComplete event and IDE need to be sent a discovery 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 payload = new DiscoveryCompletePayload()
{
IsAborted = true,
LastDiscoveredTests = null,
TotalTests = -1
};
// Send run complete to translation layer
this.communicationManager.SendMessage(MessageType.DiscoveryComplete, payload);
}
});
}
/// <inheritdoc/>
public void SendLog(TestMessageLevel messageLevel, string message)
{
var testMessagePayload = new TestMessagePayload {
MessageLevel = messageLevel, Message = message
};
this.communicationManager.SendMessage(MessageType.TestMessage, testMessagePayload, this.protocolVersion);
}
/// <inheritdoc />
public void SendTestMessage(TestMessageLevel level, string message)
{
var payload = new TestMessagePayload {
MessageLevel = level, Message = message
};
this.communicationManager.SendMessage(MessageType.TestMessage, payload);
}
/// <summary>
/// Sends the test session logger warning and error messages to IDE;
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void TestRunMessageHandler(object sender, TestRunMessageEventArgs e)
{
if (e.Level == TestMessageLevel.Error || e.Level == TestMessageLevel.Warning)
{
var payload = new TestMessagePayload {
MessageLevel = e.Level, Message = e.Message
};
this.communicationManager.SendMessage(MessageType.TestMessage, payload);
}
}
public void DesignModeClientSendTestMessageShouldSendTestMessage()
{
var testPayload = new TestMessagePayload {
MessageLevel = ObjectModel.Logging.TestMessageLevel.Error, Message = "DummyMessage"
};
this.designModeClient.SendTestMessage(testPayload.MessageLevel, testPayload.Message);
this.mockCommunicationManager.Verify(cm => cm.SendMessage(MessageType.TestMessage, It.IsAny <TestMessagePayload>()), Times.Once());
}
/// <inheritdoc />
public void HandleLogMessage(TestMessageLevel level, string message)
{
var messagePayload = new TestMessagePayload()
{
MessageLevel = level,
Message = message
};
this.communicationManager.SendMessage(MessageType.TestMessage, messagePayload);
}
/// <summary>
/// Triggers the discovery for the next data object on the concurrent discoverer
/// Each concurrent discoverer calls this method, once its completed working on previous data
/// </summary>
/// <param name="ProxyDiscoveryManager">Proxy discovery manager instance.</param>
private void DiscoverTestsOnConcurrentManager(IProxyDiscoveryManager proxyDiscoveryManager)
{
// Peek to see if we have sources to trigger a discovery
if (this.TryFetchNextSource(this.sourceEnumerator, out string nextSource))
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("ProxyParallelDiscoveryManager: Triggering test discovery for next source: {0}", nextSource);
}
// Kick off another discovery task for the next source
var discoveryCriteria = new DiscoveryCriteria(new[] { nextSource }, this.actualDiscoveryCriteria.FrequencyOfDiscoveredTestsEvent, this.actualDiscoveryCriteria.DiscoveredTestEventTimeout, this.actualDiscoveryCriteria.RunSettings);
discoveryCriteria.TestCaseFilter = this.actualDiscoveryCriteria.TestCaseFilter;
Task.Run(() =>
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("ParallelProxyDiscoveryManager: Discovery started.");
}
proxyDiscoveryManager.DiscoverTests(discoveryCriteria, this.GetHandlerForGivenManager(proxyDiscoveryManager));
})
.ContinueWith(t =>
{
// Just in case, the actual discovery couldn't start for an instance. Ensure that
// we call discovery complete since we have already fetched a source. Otherwise
// discovery will not terminate
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("ParallelProxyDiscoveryManager: Failed to trigger discovery. Exception: " + t.Exception);
}
var handler = this.GetHandlerForGivenManager(proxyDiscoveryManager);
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = t.Exception.ToString()
};
handler.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload));
handler.HandleLogMessage(TestMessageLevel.Error, t.Exception.ToString());
// Send discovery complete. Similar logic is also used in ProxyDiscoveryManager.DiscoverTests.
// Differences:
// Total tests must be zero here since parallel discovery events handler adds the count
// Keep `lastChunk` as null since we don't want a message back to the IDE (discovery didn't even begin)
// Set `isAborted` as true since we want this instance of discovery manager to be replaced
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(-1, true);
handler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, null);
},
TaskContinuationOptions.OnlyOnFaulted);
}
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("ProxyParallelDiscoveryManager: No sources available for discovery.");
}
}
private void LogMessage(TestMessageLevel testMessageLevel, string message, ITestRunEventsHandler eventHandler)
{
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = testMessageLevel, Message = message
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
eventHandler.HandleRawMessage(rawMessage);
// Log to vstest.console
eventHandler.HandleLogMessage(testMessageLevel, message);
}
private void LogMessage(TestMessageLevel testMessageLevel, string message)
{
// Log to translation layer.
var testMessagePayload = new TestMessagePayload {
MessageLevel = testMessageLevel, Message = message
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
this.HandleRawMessage(rawMessage);
// Log to vstest.console layer.
this.HandleLogMessage(testMessageLevel, message);
}
public void StartTestRunShouldNotifyLogMessageOnTestMessageReceived()
{
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = "Dummy"
};
this.SetupDeserializeMessage(MessageType.TestMessage, testMessagePayload);
this.SetupFakeCommunicationChannel();
this.testRequestSender.StartTestRun(this.testRunCriteriaWithSources, this.mockExecutionEventsHandler.Object);
this.RaiseMessageReceivedEvent();
this.mockExecutionEventsHandler.Verify(eh => eh.HandleLogMessage(TestMessageLevel.Error, "Dummy"), Times.Once);
}
public void DiscoverTestShouldNotifyLogMessageOnTestMessageReceived()
{
var message = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = "Message1"
};
this.SetupDeserializeMessage(MessageType.TestMessage, message);
this.SetupFakeCommunicationChannel();
this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), this.mockDiscoveryEventsHandler.Object);
this.RaiseMessageReceivedEvent();
this.mockDiscoveryEventsHandler.Verify(eh => eh.HandleLogMessage(TestMessageLevel.Error, "Message1"));
}
public void DiscoverTestsShouldCallHandleLogMessageOnTestMessage()
{
var sources = new List <string>()
{
"Hello", "World"
};
string settingsXml = "SettingsXml";
var mockHandler = new Mock <ITestDiscoveryEventsHandler>();
var discoveryCriteria = new DiscoveryCriteria(sources, 100, settingsXml);
var rawMessage = "TestMessage";
var messagePayload = new TestMessagePayload()
{
MessageLevel = TestMessageLevel.Error, Message = rawMessage
};
var message = new Message()
{
MessageType = MessageType.TestMessage, Payload = null
};
this.SetupReceiveRawMessageAsyncAndDeserializeMessageAndInitialize(rawMessage, message);
this.mockDataSerializer.Setup(ds => ds.DeserializePayload <TestMessagePayload>(message)).Returns(messagePayload);
var completePayload = new DiscoveryCompletePayload()
{
IsAborted = false,
LastDiscoveredTests = null,
TotalTests = 1
};
var completeMessage = new Message()
{
MessageType = MessageType.DiscoveryComplete, Payload = null
};
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 <DiscoveryCompletePayload>(completeMessage)).Returns(completePayload);
});
this.testRequestSender.DiscoverTests(discoveryCriteria, mockHandler.Object);
this.mockCommunicationManager.Verify(mc => mc.SendMessage(MessageType.StartDiscovery, discoveryCriteria), Times.Once);
this.mockDataSerializer.Verify(ds => ds.DeserializeMessage(rawMessage), Times.Exactly(2));
mockHandler.Verify(mh => mh.HandleLogMessage(TestMessageLevel.Error, rawMessage), Times.Once);
mockHandler.Verify(mh => mh.HandleRawMessage(rawMessage), Times.Exactly(2));
}
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);
}
internal void OnTestSessionTimeout(object obj)
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(string.Format("TestRunRequest.OnTestSessionTimeout: calling cancellation as test run exceeded testSessionTimeout {0} milliseconds", testSessionTimeout));
}
string message = string.Format(ClientResources.TestSessionTimeoutMessage, this.testSessionTimeout);
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = message
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
this.HandleLogMessage(TestMessageLevel.Error, message);
this.HandleRawMessage(rawMessage);
this.Abort();
}
/// <inheritdoc/>
public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 eventHandler)
{
this.baseTestDiscoveryEventsHandler = eventHandler;
try
{
this.isCommunicationEstablished = this.proxyOperationManager.SetupChannel(discoveryCriteria.Sources, discoveryCriteria.RunSettings);
if (this.isCommunicationEstablished)
{
this.InitializeExtensions(discoveryCriteria.Sources);
discoveryCriteria.UpdateDiscoveryCriteria(testHostManager);
this.proxyOperationManager.RequestSender.DiscoverTests(discoveryCriteria, this);
}
}
catch (Exception exception)
{
EqtTrace.Error("ProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception);
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = exception.ToString()
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
this.HandleRawMessage(rawMessage);
// Log to vstest.console
// Send a discovery complete to caller. Similar logic is also used in ParallelProxyDiscoveryManager.DiscoverTestsOnConcurrentManager
// Aborted is `true`: in case of parallel discovery (or non shared host), an aborted message ensures another discovery manager
// created to replace the current one. This will help if the current discovery manager is aborted due to irreparable error
// and the test host is lost as well.
this.HandleLogMessage(TestMessageLevel.Error, exception.ToString());
var discoveryCompletePayload = new DiscoveryCompletePayload()
{
IsAborted = true,
LastDiscoveredTests = null,
TotalTests = -1
};
this.HandleRawMessage(this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, discoveryCompletePayload));
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(-1, true);
this.HandleDiscoveryComplete(discoveryCompleteEventsArgs, new List <ObjectModel.TestCase>());
}
}
private void LogErrorMessage(string message)
{
if (this.messageEventHandler == null)
{
EqtTrace.Error("TestRequestSender.LogErrorMessage: Message event handler not set. Error: " + message);
return;
}
// Log to vstest console
this.messageEventHandler.HandleLogMessage(TestMessageLevel.Error, message);
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = message
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
this.messageEventHandler.HandleRawMessage(rawMessage);
}
/// <summary>
/// Discovers tests
/// </summary>
/// <param name="discoveryCriteria">Settings, parameters for the discovery request</param>
/// <param name="eventHandler">EventHandler for handling discovery events from Engine</param>
public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 eventHandler)
{
try
{
var discoveryEngineStartTime = DateTime.UtcNow;
this.isCommunicationEstablished = this.SetupChannel(discoveryCriteria.Sources, this.cancellationTokenSource.Token);
if (this.isCommunicationEstablished)
{
this.InitializeExtensions(discoveryCriteria.Sources);
discoveryCriteria.UpdateDiscoveryCriteria(testHostManager);
// Collecting Time Taken to Start Discovery Engine
var discoveryEngineTotalTime = DateTime.UtcNow - discoveryEngineStartTime;
this.requestData.MetricsCollection.Add(TelemetryDataConstants.TimeTakenInSecToStartDiscoveryEngine, discoveryEngineTotalTime.TotalSeconds.ToString());
this.RequestSender.DiscoverTests(discoveryCriteria, eventHandler);
}
}
catch (Exception exception)
{
EqtTrace.Error("ProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception);
// Log to vs ide test output
var testMessagePayload = new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = exception.Message
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.TestMessage, testMessagePayload);
eventHandler.HandleRawMessage(rawMessage);
// Log to vstest.console
// Send a discovery complete to caller. Similar logic is also used in ParallelProxyDiscoveryManager.DiscoverTestsOnConcurrentManager
// Aborted is `true`: in case of parallel discovery (or non shared host), an aborted message ensures another discovery manager
// created to replace the current one. This will help if the current discovery manager is aborted due to irreparable error
// and the test host is lost as well.
eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.Message);
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(-1, true);
eventHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, new List <ObjectModel.TestCase>());
}
}
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);
}
});
}
