private void OnDiscoveryAbort(ITestDiscoveryEventsHandler2 eventHandler, Exception exception, bool getClientError)
{
if (this.IsOperationComplete())
{
EqtTrace.Verbose("TestRequestSender: OnDiscoveryAbort: Operation is already complete. Skip error message.");
return;
}
EqtTrace.Verbose("TestRequestSender: OnDiscoveryAbort: Set operation complete.");
this.SetOperationComplete();
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true);
var reason = this.GetAbortErrorMessage(exception, getClientError);
EqtTrace.Error("TestRequestSender: Aborting test discovery because {0}", reason);
this.LogErrorMessage(string.Format(CommonResources.AbortedTestDiscovery, reason));
// Notify discovery abort to IDE test output
var payload = new DiscoveryCompletePayload()
{
IsAborted = true,
LastDiscoveredTests = null,
TotalTests = -1
};
var rawMessage = this.dataSerializer.SerializePayload(MessageType.DiscoveryComplete, payload);
eventHandler.HandleRawMessage(rawMessage);
// Complete discovery
eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null);
}
/// <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)
{
Task.Run(() =>
{
try
{
// Initialize extension before discovery
this.InitializeExtensions(discoveryCriteria.Sources);
discoveryCriteria.UpdateDiscoveryCriteria(testHostManager);
this.discoveryManager.DiscoverTests(discoveryCriteria, eventHandler);
}
catch (Exception exception)
{
EqtTrace.Error("InProcessProxyDiscoveryManager.DiscoverTests: Failed to discover tests: {0}", exception);
// Send a discovery complete to caller.
eventHandler.HandleLogMessage(TestMessageLevel.Error, exception.ToString());
var discoveryCompeleteEventsArg = new DiscoveryCompleteEventArgs(-1, true);
eventHandler.HandleDiscoveryComplete(discoveryCompeleteEventsArg, Enumerable.Empty <TestCase>());
}
});
}
public ParallelDiscoveryEventsHandler(IRequestData requestData,
IProxyDiscoveryManager proxyDiscoveryManager,
ITestDiscoveryEventsHandler2 actualDiscoveryEventsHandler,
IParallelProxyDiscoveryManager parallelProxyDiscoveryManager,
ParallelDiscoveryDataAggregator discoveryDataAggregator) :
this(requestData, proxyDiscoveryManager, actualDiscoveryEventsHandler, parallelProxyDiscoveryManager, discoveryDataAggregator, JsonDataSerializer.Instance)
{
}
/// <inheritdoc/>
public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
try
{
this.communicationManager.SendMessage(MessageType.StartDiscovery, discoveryCriteria, version: this.protocolVersion);
var isDiscoveryComplete = 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 (!isDiscoveryComplete)
{
var rawMessage = this.TryReceiveRawMessage();
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("Received message: {0}", rawMessage);
}
// Send raw message first to unblock handlers waiting to send message to IDEs
discoveryEventsHandler.HandleRawMessage(rawMessage);
var message = this.dataSerializer.DeserializeMessage(rawMessage);
if (string.Equals(MessageType.TestCasesFound, message.MessageType))
{
var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(message);
discoveryEventsHandler.HandleDiscoveredTests(testCases);
}
else if (string.Equals(MessageType.DiscoveryComplete, message.MessageType))
{
var discoveryCompletePayload = this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(message);
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted, discoveryCompletePayload.Metrics);
discoveryEventsHandler.HandleDiscoveryComplete(
discoveryCompleteEventArgs,
discoveryCompletePayload.LastDiscoveredTests);
isDiscoveryComplete = true;
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
discoveryEventsHandler.HandleLogMessage(
testMessagePayload.MessageLevel,
testMessagePayload.Message);
}
}
}
catch (Exception ex)
{
this.OnDiscoveryAbort(discoveryEventsHandler, ex);
}
}
/// <inheritdoc/>
public void DiscoverTests(
IEnumerable <string> sources,
string discoverySettings,
TestPlatformOptions options,
ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
this.DiscoverTests(
sources,
discoverySettings,
options,
testSessionInfo: null,
discoveryEventsHandler);
}
/// <inheritdoc/>
public void DiscoverTests(
IEnumerable <string> sources,
string discoverySettings,
TestPlatformOptions options,
ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
// TODO (copoiena): Hook into the wrapper and pass session info here.
this.consoleWrapper.DiscoverTests(
sources,
discoverySettings,
options,
discoveryEventsHandler);
}
/// <inheritdoc/>
public async Task DiscoverTestsAsync(
IEnumerable <string> sources,
string discoverySettings,
TestPlatformOptions options,
ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
await this.DiscoverTestsAsync(
sources,
discoverySettings,
options,
testSessionInfo : null,
discoveryEventsHandler);
}
internal ParallelDiscoveryEventsHandler(IRequestData requestData,
IProxyDiscoveryManager proxyDiscoveryManager,
ITestDiscoveryEventsHandler2 actualDiscoveryEventsHandler,
IParallelProxyDiscoveryManager parallelProxyDiscoveryManager,
ParallelDiscoveryDataAggregator discoveryDataAggregator,
IDataSerializer dataSerializer)
{
this.proxyDiscoveryManager = proxyDiscoveryManager;
this.actualDiscoveryEventsHandler = actualDiscoveryEventsHandler;
this.parallelProxyDiscoveryManager = parallelProxyDiscoveryManager;
this.discoveryDataAggregator = discoveryDataAggregator;
this.dataSerializer = dataSerializer;
this.requestData = requestData;
}
/// <summary>
/// Initializes the discovery manager.
/// </summary>
/// <param name="pathToAdditionalExtensions"> The path to additional extensions. </param>
public void Initialize(IEnumerable <string> pathToAdditionalExtensions, ITestDiscoveryEventsHandler2 eventHandler)
{
this.testPlatformEventSource.AdapterSearchStart();
this.testDiscoveryEventsHandler = eventHandler;
if (pathToAdditionalExtensions != null && pathToAdditionalExtensions.Any())
{
// Start using these additional extensions
TestPluginCache.Instance.DefaultExtensionPaths = pathToAdditionalExtensions;
}
// Load and Initialize extensions.
TestDiscoveryExtensionManager.LoadAndInitializeAllExtensions(false);
this.testPlatformEventSource.AdapterSearchStop();
}
private void OnDiscoveryMessageReceived(ITestDiscoveryEventsHandler2 discoveryEventsHandler, MessageReceivedEventArgs args)
{
try
{
var rawMessage = args.Data;
// Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification.
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("TestRequestSender.OnDiscoveryMessageReceived: Received message: {0}", rawMessage);
}
// Send raw message first to unblock handlers waiting to send message to IDEs
discoveryEventsHandler.HandleRawMessage(rawMessage);
var data = this.dataSerializer.DeserializeMessage(rawMessage);
switch (data.MessageType)
{
case MessageType.TestCasesFound:
var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(data);
discoveryEventsHandler.HandleDiscoveredTests(testCases);
break;
case MessageType.DiscoveryComplete:
var discoveryCompletePayload =
this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(data);
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted);
discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics;
discoveryEventsHandler.HandleDiscoveryComplete(
discoveryCompleteEventArgs,
discoveryCompletePayload.LastDiscoveredTests);
this.SetOperationComplete();
break;
case MessageType.TestMessage:
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(
data);
discoveryEventsHandler.HandleLogMessage(
testMessagePayload.MessageLevel,
testMessagePayload.Message);
break;
}
}
catch (Exception ex)
{
this.OnDiscoveryAbort(discoveryEventsHandler, ex, false);
}
}
/// <inheritdoc/>
public void DiscoverTests(
IEnumerable <string> sources,
string discoverySettings,
TestPlatformOptions options,
TestSessionInfo testSessionInfo,
ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
this.testPlatformEventSource.TranslationLayerDiscoveryStart();
this.EnsureInitialized();
// TODO (copoiena): Add session info as a parameter.
this.requestSender.DiscoverTests(
sources,
discoverySettings,
options,
discoveryEventsHandler);
}
/// <inheritdoc/>
public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
this.messageEventHandler = discoveryEventsHandler;
this.onDisconnected = (disconnectedEventArgs) =>
{
this.OnDiscoveryAbort(discoveryEventsHandler, disconnectedEventArgs.Error, true);
};
this.onMessageReceived = (sender, args) => this.OnDiscoveryMessageReceived(discoveryEventsHandler, args);
this.channel.MessageReceived += this.onMessageReceived;
var message = this.dataSerializer.SerializePayload(
MessageType.StartDiscovery,
discoveryCriteria,
this.protocolVersion);
this.channel.Send(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, ITestDiscoveryEventsHandler2 eventHandler)
{
this.baseTestDiscoveryEventsHandler = eventHandler;
try
{
this.isCommunicationEstablished = this.SetupChannel(discoveryCriteria.Sources, discoveryCriteria.RunSettings);
if (this.isCommunicationEstablished)
{
this.InitializeExtensions(discoveryCriteria.Sources);
discoveryCriteria.UpdateDiscoveryCriteria(testHostManager);
this.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>());
}
}
/// <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 OnDiscoveryAbort(ITestDiscoveryEventsHandler2 eventHandler, Exception exception)
{
try
{
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
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true, null);
eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null);
this.CleanupCommunicationIfProcessExit();
}
catch (Exception ex)
{
EqtTrace.Error(ex);
throw ex;
}
}
private async Task SendMessageAndListenAndReportTestCasesAsync(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 eventHandler)
{
try
{
this.communicationManager.SendMessage(
MessageType.StartDiscovery,
new DiscoveryRequestPayload()
{
Sources = sources, RunSettings = runSettings, TestPlatformOptions = options
},
this.protocolVersion);
var isDiscoveryComplete = false;
// 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 (!isDiscoveryComplete)
{
var message = await this.TryReceiveMessageAsync();
if (string.Equals(MessageType.TestCasesFound, message.MessageType))
{
var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(message);
eventHandler.HandleDiscoveredTests(testCases);
}
else if (string.Equals(MessageType.DiscoveryComplete, message.MessageType))
{
var discoveryCompletePayload =
this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(message);
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted);
// Adding Metrics from VsTestConsole
discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics;
eventHandler.HandleDiscoveryComplete(
discoveryCompleteEventArgs,
discoveryCompletePayload.LastDiscoveredTests);
isDiscoveryComplete = true;
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
}
}
}
catch (Exception exception)
{
EqtTrace.Error("Aborting Test Discovery Operation: {0}", exception);
eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsDiscovery);
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true);
eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null);
CleanupCommunicationIfProcessExit();
}
this.testPlatformEventSource.TranslationLayerDiscoveryStop();
}
/// <summary>
/// Asynchronous equivalent of <see cref="DiscoverTests"/>.
/// </summary>
public async Task DiscoverTestsAsync(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 eventHandler)
{
await this.SendMessageAndListenAndReportTestCasesAsync(sources, runSettings, options, eventHandler);
}
public void DiscoverTests(IEnumerable <string> sources, string discoverySettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 discoveryEventsHandler) => inner.DiscoverTests(sources, discoverySettings, options, discoveryEventsHandler);
/// <inheritdoc/>
public void DiscoverTests(IEnumerable <string> sources, string discoverySettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
this.testPlatformEventSource.TranslationLayerDiscoveryStart();
this.EnsureInitialized();
this.requestSender.DiscoverTests(sources, discoverySettings, options, discoveryEventsHandler);
}
/// <summary>
/// Asynchronous equivalent of <see cref="DiscoverTests"/>.
/// </summary>
public async Task DiscoverTestsAsync(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 eventHandler)
{
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("VsTestConsoleRequestSender.DiscoverTestsAsync: Starting test discovery.");
}
await this.SendMessageAndListenAndReportTestCasesAsync(sources, runSettings, options, eventHandler);
}
private async Task SendMessageAndListenAndReportTestCasesAsync(IEnumerable <string> sources, string runSettings, TestPlatformOptions options, ITestDiscoveryEventsHandler2 eventHandler)
{
try
{
this.communicationManager.SendMessage(
MessageType.StartDiscovery,
new DiscoveryRequestPayload()
{
Sources = sources, RunSettings = runSettings, TestPlatformOptions = options
},
this.protocolVersion);
var isDiscoveryComplete = false;
// 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 (!isDiscoveryComplete)
{
var message = await this.TryReceiveMessageAsync();
if (string.Equals(MessageType.TestCasesFound, message.MessageType))
{
var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(message);
eventHandler.HandleDiscoveredTests(testCases);
}
else if (string.Equals(MessageType.DiscoveryComplete, message.MessageType))
{
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("VsTestConsoleRequestSender.SendMessageAndListenAndReportTestCasesAsync: Discovery complete.");
}
var discoveryCompletePayload =
this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(message);
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted);
// Adding Metrics from VsTestConsole
discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics;
eventHandler.HandleDiscoveryComplete(
discoveryCompleteEventArgs,
discoveryCompletePayload.LastDiscoveredTests);
isDiscoveryComplete = true;
}
else if (string.Equals(MessageType.TestMessage, message.MessageType))
{
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(message);
eventHandler.HandleLogMessage(testMessagePayload.MessageLevel, testMessagePayload.Message);
}
}
}
catch (Exception exception)
{
EqtTrace.Error("Aborting Test Discovery Operation: {0}", exception);
eventHandler.HandleLogMessage(TestMessageLevel.Error, TranslationLayerResources.AbortedTestsDiscovery);
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(-1, true);
eventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, 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.TranslationLayerDiscoveryStop();
}
/// <inheritdoc />
public void DiscoverTests(DiscoveryCriteria discoveryCriteria, ITestDiscoveryEventsHandler2 discoveryEventsHandler)
{
this.messageEventHandler = discoveryEventsHandler;
this.onDisconnected = (disconnectedEventArgs) =>
{
this.OnDiscoveryAbort(discoveryEventsHandler, disconnectedEventArgs.Error, true);
};
this.onMessageReceived = (sender, args) =>
{
try
{
var rawMessage = args.Data;
// Currently each of the operations are not separate tasks since they should not each take much time. This is just a notification.
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("TestRequestSender: Received message: {0}", rawMessage);
}
// Send raw message first to unblock handlers waiting to send message to IDEs
discoveryEventsHandler.HandleRawMessage(rawMessage);
var data = this.dataSerializer.DeserializeMessage(rawMessage);
switch (data.MessageType)
{
case MessageType.TestCasesFound:
var testCases = this.dataSerializer.DeserializePayload <IEnumerable <TestCase> >(data);
discoveryEventsHandler.HandleDiscoveredTests(testCases);
break;
case MessageType.DiscoveryComplete:
var discoveryCompletePayload =
this.dataSerializer.DeserializePayload <DiscoveryCompletePayload>(data);
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted, discoveryCompletePayload.Metrics);
discoveryEventsHandler.HandleDiscoveryComplete(
discoveryCompleteEventsArgs,
discoveryCompletePayload.LastDiscoveredTests);
this.SetOperationComplete();
break;
case MessageType.TestMessage:
var testMessagePayload = this.dataSerializer.DeserializePayload <TestMessagePayload>(
data);
discoveryEventsHandler.HandleLogMessage(
testMessagePayload.MessageLevel,
testMessagePayload.Message);
break;
}
}
catch (Exception ex)
{
this.OnDiscoveryAbort(discoveryEventsHandler, ex, false);
}
};
this.channel.MessageReceived += this.onMessageReceived;
var message = this.dataSerializer.SerializePayload(
MessageType.StartDiscovery,
discoveryCriteria,
this.protocolVersion);
this.channel.Send(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, ITestDiscoveryEventsHandler2 eventHandler)
{
var discoveryResultCache = new DiscoveryResultCache(
discoveryCriteria.FrequencyOfDiscoveredTestsEvent,
discoveryCriteria.DiscoveredTestEventTimeout,
this.OnReportTestCases);
try
{
this.discoveryCriteria = discoveryCriteria;
EqtTrace.Info("TestDiscoveryManager.DoDiscovery: Background test discovery started.");
this.testDiscoveryEventsHandler = eventHandler;
var verifiedExtensionSourceMap = new Dictionary <string, IEnumerable <string> >();
// Validate the sources
foreach (var kvp in discoveryCriteria.AdapterSourceMap)
{
var verifiedSources = GetValidSources(kvp.Value, this.sessionMessageLogger);
if (verifiedSources.Any())
{
verifiedExtensionSourceMap.Add(kvp.Key, kvp.Value);
}
}
// If there are sources to discover
if (verifiedExtensionSourceMap.Any())
{
new DiscovererEnumerator(this.requestData, discoveryResultCache, cancellationTokenSource.Token).LoadTests(
verifiedExtensionSourceMap,
RunSettingsUtilities.CreateAndInitializeRunSettings(discoveryCriteria.RunSettings),
discoveryCriteria.TestCaseFilter,
this.sessionMessageLogger);
}
}
finally
{
// Discovery complete. Raise the DiscoveryCompleteEvent.
EqtTrace.Verbose("TestDiscoveryManager.DoDiscovery: Background Test Discovery complete.");
var totalDiscoveredTestCount = discoveryResultCache.TotalDiscoveredTests;
var lastChunk = discoveryResultCache.Tests;
EqtTrace.Verbose("TestDiscoveryManager.DiscoveryComplete: Calling DiscoveryComplete callback.");
if (eventHandler != null)
{
if (lastChunk != null)
{
UpdateTestCases(lastChunk, this.discoveryCriteria.Package);
}
// Collecting Discovery State
this.requestData.MetricsCollection.Add(TelemetryDataConstants.DiscoveryState, "Completed");
// Collecting Total Tests Discovered
this.requestData.MetricsCollection.Add(TelemetryDataConstants.TotalTestsDiscovered, totalDiscoveredTestCount);
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(totalDiscoveredTestCount, false)
{
Metrics = this.requestData.MetricsCollection.Metrics
};
eventHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, lastChunk);
}
else
{
EqtTrace.Warning(
"DiscoveryManager: Could not pass the discovery complete message as the callback is null.");
}
EqtTrace.Verbose("TestDiscoveryManager.DiscoveryComplete: Called DiscoveryComplete callback.");
this.testDiscoveryEventsHandler = null;
}
}
