public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
{
if (lastChunk != null)
{
this.DiscoveredTestCases.AddRange(lastChunk);
}
}
void Discovery_Connect(DiscoveryCompleteEventArgs e)
{
//var reference = e.Reference;
//foreach (var warning in reference.Warnings) logger.Warn(warning);
//foreach (var error in reference.Errors) logger.Error(error);
//if (reference.HasErrors)
// logger.Write("Cannot create a connection.");
//else
//{
logger.Write("Click \"Next\" to continue.");
// var reset = string.IsNullOrEmpty(Model.BindingName) ||
// !reference.Bindings.Any(b => b.Name == Model.BindingName);
// if (reset)
// {
// Model.BindingName = reference.Bindings.Count > 0
// ? reference.Bindings[0].Name : "";
// }
// BindingBox.ItemsSource = reference.Bindings.Select(b => b.Name);
// BindingBox.SelectedItem = Model.BindingName;
//}
RestartButton.IsEnabled = true;
Progress.IsIndeterminate = false;
LogBox.ScrollToEnd();
//if (!reference.HasErrors && !reference.HasWarnings)
//{
//SetVisiblePage(2);
FinishButton.IsEnabled = true;
//}
}
public void HandleDiscoveryCompleteShouldCallLastChunkResultsIfPresent()
{
string payload = "Tests";
int totalTests = 10;
bool aborted = false;
var lastChunk = new List <TestCase>();
this.mockDataSerializer.Setup(mds => mds.SerializePayload(MessageType.TestCasesFound, lastChunk))
.Returns(payload);
this.mockParallelProxyDiscoveryManager.Setup(mp => mp.HandlePartialDiscoveryComplete(
this.mockProxyDiscoveryManager.Object, totalTests, lastChunk, aborted)).Returns(false);
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(totalTests, aborted, null);
this.parallelDiscoveryEventsHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, lastChunk);
// Raw message must be sent
this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleRawMessage(payload), Times.Once);
this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveredTests(lastChunk), Times.Once);
this.mockParallelProxyDiscoveryManager.Verify(mp => mp.HandlePartialDiscoveryComplete(
this.mockProxyDiscoveryManager.Object, totalTests, null, aborted), Times.Once);
}
public void DiscoverTestsShouldCollectMetricsOnHandleDiscoveryComplete()
{
var dict = new Dictionary <string, string>();
dict.Add("DummyMessage", "DummyValue");
var mockHandler = new Mock <ITestDiscoveryEventsHandler2>();
var completePayload = new DiscoveryCompletePayload()
{
IsAborted = false,
LastDiscoveredTests = null,
TotalTests = 1,
Metrics = dict
};
this.SetupDeserializeMessage(MessageType.DiscoveryComplete, completePayload);
this.SetupFakeCommunicationChannel();
DiscoveryCompleteEventArgs actualDiscoveryCompleteEventArgs = null;
mockHandler.Setup(md => md.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), null))
.Callback <DiscoveryCompleteEventArgs, IEnumerable <TestCase> >(
(discoveryCompleteEventArgs, testCase) =>
{
actualDiscoveryCompleteEventArgs = discoveryCompleteEventArgs;
});
// Act.
this.testRequestSender.DiscoverTests(new DiscoveryCriteria(), mockHandler.Object);
this.RaiseMessageReceivedEvent();
// Verify
Assert.AreEqual(dict, actualDiscoveryCompleteEventArgs.Metrics);
}
/// <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 void HandleDiscoveryCompleteShouldInformClient()
{
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(0, false);
this.testDiscoveryEventHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, null);
this.mockClient.Verify(th => th.DiscoveryComplete(discoveryCompleteEventArgs, null), Times.Once);
}
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);
}
public void RaiseDiscoveryCompleteShouldInvokeRegisteredEventHandler()
{
bool discoveryCompleteReceived = false;
DiscoveryCompleteEventArgs receivedEventArgs = null;
EventWaitHandle waitHandle = new AutoResetEvent(false);
DiscoveryCompleteEventArgs discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(2, false);
// Register for the discovery complete event.
loggerEvents.DiscoveryComplete += (sender, e) =>
{
discoveryCompleteReceived = true;
receivedEventArgs = e;
waitHandle.Set();
};
loggerEvents.EnableEvents();
// Send the discovery complete event.
loggerEvents.RaiseDiscoveryComplete(discoveryCompleteEventArgs);
var waitSuccess = waitHandle.WaitOne(500);
Assert.IsTrue(waitSuccess, "Event must be raised within timeout.");
Assert.IsTrue(discoveryCompleteReceived);
Assert.IsNotNull(receivedEventArgs);
Assert.AreEqual(receivedEventArgs, discoveryCompleteEventArgs);
}
public void HandleDiscoveryCompleteShouldCallTestDiscoveryCompleteOnActualHandlerIfParallelManagerReturnsCompleteAsTrue()
{
string payload = "DiscoveryComplete";
int totalTests = 10;
bool aborted = false;
this.mockParallelProxyDiscoveryManager.Setup(mp => mp.HandlePartialDiscoveryComplete(
this.mockProxyDiscoveryManager.Object, totalTests, null, aborted)).Returns(true);
this.mockDataSerializer.Setup(mds => mds.SerializeMessage(MessageType.DiscoveryComplete)).Returns(payload);
// Act
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(totalTests, aborted, null);
this.parallelDiscoveryEventsHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, null);
// Verify
this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveredTests(null), Times.Never);
this.mockParallelProxyDiscoveryManager.Verify(mp => mp.HandlePartialDiscoveryComplete(
this.mockProxyDiscoveryManager.Object, totalTests, null, aborted), Times.Once);
this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleRawMessage(It.IsAny <string>()), Times.Once);
this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), null), Times.Once);
}
private void Events_DiscoveryComplete(object sender, DiscoveryCompleteEventArgs e)
{
var content = JsonSerializer.Serialize(TestCaseInfos.ToArray());
string path = Path.Combine(TestRunDirectory, "TestCaseInfo.json");
File.WriteAllText(path, content);
}
/// <summary>
/// Handle discovery complete.
/// </summary>
/// <param name="discoveryCompleteEventArgs"> Discovery Complete Events Args. </param>
/// <param name="lastChunk"> The last chunk. </param>
public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
{
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info(discoveryCompleteEventArgs.IsAborted ? "Discover Aborted." : "Discover Finished.");
}
this.requestHandler.DiscoveryComplete(discoveryCompleteEventArgs, lastChunk);
}
/// <inheritdoc/>
public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
{
var totalTests = discoveryCompleteEventArgs.TotalCount;
var isAborted = discoveryCompleteEventArgs.IsAborted;
// we get discovery complete events from each host process
// so we cannot "complete" the actual operation until all sources are consumed
// We should not block last chunk results while we aggregate overall discovery data
if (lastChunk != null)
{
ConvertToRawMessageAndSend(MessageType.TestCasesFound, lastChunk);
this.HandleDiscoveredTests(lastChunk);
}
// Aggregate for final discovery complete
discoveryDataAggregator.Aggregate(totalTests, isAborted);
// Aggregate Discovery Data Metrics
discoveryDataAggregator.AggregateDiscoveryDataMetrics(discoveryCompleteEventArgs.Metrics);
// Do not send TestDiscoveryComplete to actual test discovery handler
// We need to see if there are still sources left - let the parallel manager decide
var parallelDiscoveryComplete = this.parallelProxyDiscoveryManager.HandlePartialDiscoveryComplete(
this.proxyDiscoveryManager,
totalTests,
null, // lastChunk should be null as we already sent this data above
isAborted);
if (parallelDiscoveryComplete)
{
// In case of sequential discovery - RawMessage would have contained a 'DiscoveryCompletePayload' object
// To send a raw message - we need to create raw message from an aggregated payload object
var testDiscoveryCompletePayload = new DiscoveryCompletePayload()
{
TotalTests = discoveryDataAggregator.TotalTests,
IsAborted = discoveryDataAggregator.IsAborted,
LastDiscoveredTests = null
};
// Collecting Final Discovery State
this.requestData.MetricsCollection.Add(TelemetryDataConstants.DiscoveryState, isAborted ? "Aborted" : "Completed");
// Collect Aggregated Metrics Data
var aggregatedDiscoveryDataMetrics = discoveryDataAggregator.GetAggregatedDiscoveryDataMetrics();
testDiscoveryCompletePayload.Metrics = aggregatedDiscoveryDataMetrics;
// we have to send raw messages as we block the discovery complete actual raw messages
this.ConvertToRawMessageAndSend(MessageType.DiscoveryComplete, testDiscoveryCompletePayload);
var finalDiscoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(this.discoveryDataAggregator.TotalTests,
this.discoveryDataAggregator.IsAborted);
finalDiscoveryCompleteEventArgs.Metrics = aggregatedDiscoveryDataMetrics;
// send actual test discovery complete to clients
this.actualDiscoveryEventsHandler.HandleDiscoveryComplete(finalDiscoveryCompleteEventArgs, null);
}
}
public void HandleDiscoveryCompleteShouldInvokeHandleDiscoveryCompleteOfLoggerManager()
{
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false);
var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2;
eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, Enumerable.Empty <TestCase>());
loggerManager.Verify(lm => lm.HandleDiscoveryComplete(discoveryCompleteEventArgs), Times.Once);
}
public void HandleDiscoveryCompleteShouldNotInvokeHandleDiscoveredTestsIfLastChunkNotPresent()
{
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false);
var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2;
eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, Enumerable.Empty <TestCase>());
loggerManager.Verify(lm => lm.HandleDiscoveredTests(It.IsAny <DiscoveredTestsEventArgs>()), Times.Never);
}
public void RaiseDiscoveryCompleteShouldThrowExceptionIfAlreadyDisposed()
{
var loggerEvents = GetDisposedLoggerEvents();
DiscoveryCompleteEventArgs discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(2, false);
Assert.ThrowsException <ObjectDisposedException>(() =>
{
loggerEvents.RaiseDiscoveryComplete(discoveryCompleteEventArgs);
});
}
/// <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.");
}
}
/// <inheritdoc/>
public void DiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
{
var discoveryCompletePayload = new DiscoveryCompletePayload
{
TotalTests = discoveryCompleteEventArgs.TotalCount,
LastDiscoveredTests = discoveryCompleteEventArgs.IsAborted ? null : lastChunk,
IsAborted = discoveryCompleteEventArgs.IsAborted,
Metrics = discoveryCompleteEventArgs.Metrics
};
this.communicationManager.SendMessage(MessageType.DiscoveryComplete, discoveryCompletePayload, this.protocolVersion);
}
/// <summary>
/// Raises discovery complete event to the enabled loggers.
/// </summary>
/// <param name="args"> Arguments to be raised. </param>
internal void RaiseDiscoveryComplete(DiscoveryCompleteEventArgs args)
{
ValidateArg.NotNull <DiscoveryCompleteEventArgs>(args, "args");
CheckDisposed();
// Sending 0 size as this event is not expected to contain any data.
SafeInvokeAsync(() => this.DiscoveryComplete, args, 0, "InternalTestLoggerEvents.SendDiscoveryComplete");
// Wait for the loggers to finish processing the messages for the run.
this.loggerEventQueue.Flush();
}
/// <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 DiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
{
var data = this.dataSerializer.SerializePayload(
MessageType.DiscoveryComplete,
new DiscoveryCompletePayload
{
TotalTests = discoveryCompleteEventArgs.TotalCount,
LastDiscoveredTests = discoveryCompleteEventArgs.IsAborted ? null : lastChunk,
IsAborted = discoveryCompleteEventArgs.IsAborted,
Metrics = discoveryCompleteEventArgs.Metrics
},
this.protocolVersion);
this.SendData(data);
}
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);
}
}
public void HandleDiscoveryCompleteShouldInvokeHandleDiscoveredTestsIfLastChunkPresent()
{
var activeTestCases = new List <ObjectModel.TestCase>
{
new ObjectModel.TestCase(
"A.C.M2",
new Uri("executor://dummy"),
"A")
};
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false);
var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2;
eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, activeTestCases);
loggerManager.Verify(lm => lm.HandleDiscoveredTests(It.IsAny <DiscoveredTestsEventArgs>()), Times.Once);
}
/// <summary>
/// Handles LoggerManager's DiscoveryComplete.
/// </summary>
/// <param name="discoveryCompletePayload">Discovery complete payload.</param>
private void HandleLoggerManagerDiscoveryComplete(DiscoveryCompletePayload discoveryCompletePayload)
{
if (this.LoggerManager.LoggersInitialized && discoveryCompletePayload != null)
{
// Send last chunk to logger manager.
if (discoveryCompletePayload.LastDiscoveredTests != null)
{
var discoveredTestsEventArgs = new DiscoveredTestsEventArgs(discoveryCompletePayload.LastDiscoveredTests);
this.LoggerManager.HandleDiscoveredTests(discoveredTestsEventArgs);
}
// Send discovery complete to logger manager.
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(discoveryCompletePayload.TotalTests, discoveryCompletePayload.IsAborted);
discoveryCompleteEventArgs.Metrics = discoveryCompletePayload.Metrics;
this.LoggerManager.HandleDiscoveryComplete(discoveryCompleteEventArgs);
}
}
/// <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>
/// Handles discovery complete event.
/// </summary>
/// <param name="e">DiscoveryComplete event args.</param>
public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs e)
{
if (!this.isDisposed)
{
try
{
this.loggerEvents.RaiseDiscoveryComplete(e);
}
finally
{
this.Dispose();
}
}
else
{
// Note: We are not raising warning in case testLoggerManager is disposed as HandleRawMessage and HandleDiscoveryComplete both can call HandleDiscoveryComplete.
EqtTrace.Verbose("TestLoggerManager.HandleDiscoveryComplete: Ignoring as the object is disposed.");
}
}
/// <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>());
}
}
public void HandleDiscoveryCompleteShouldNotCallLastChunkResultsIfNotPresent()
{
int totalTests = 10;
bool aborted = false;
this.mockParallelProxyDiscoveryManager.Setup(mp => mp.HandlePartialDiscoveryComplete(
this.mockProxyDiscoveryManager.Object, totalTests, null, aborted)).Returns(false);
var discoveryCompleteEventsArgs = new DiscoveryCompleteEventArgs(totalTests, aborted, null);
this.parallelDiscoveryEventsHandler.HandleDiscoveryComplete(discoveryCompleteEventsArgs, null);
// Raw message must be sent
this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleRawMessage(It.IsAny <string>()), Times.Never);
this.mockTestDiscoveryEventsHandler.Verify(mt => mt.HandleDiscoveredTests(null), Times.Never);
this.mockParallelProxyDiscoveryManager.Verify(mp => mp.HandlePartialDiscoveryComplete(
this.mockProxyDiscoveryManager.Object, totalTests, null, aborted), Times.Once);
}
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;
}
}
public void HandleDiscoveryCompleteShouldCollectMetrics()
{
var mockMetricsCollector = new Mock <IMetricsCollection>();
var dict = new Dictionary <string, string>();
dict.Add("DummyMessage", "DummyValue");
mockMetricsCollector.Setup(mc => mc.Metrics).Returns(dict);
this.mockRequestData.Setup(rd => rd.MetricsCollection).Returns(mockMetricsCollector.Object);
var eventsHandler = this.discoveryRequest as ITestDiscoveryEventsHandler2;
var discoveryCompleteEventArgs = new DiscoveryCompleteEventArgs(1, false);
discoveryCompleteEventArgs.Metrics = dict;
// Act
eventsHandler.HandleDiscoveryComplete(discoveryCompleteEventArgs, Enumerable.Empty <TestCase>());
// Verify.
mockMetricsCollector.Verify(rd => rd.Add(TelemetryDataConstants.TimeTakenInSecForDiscovery, It.IsAny <string>()), Times.Once);
mockMetricsCollector.Verify(rd => rd.Add("DummyMessage", "DummyValue"), Times.Once);
}
public void DiscoverTestsShouldSendMetricsOnDiscoveryComplete()
{
var metricsCollector = new MetricsCollection();
metricsCollector.Add("DummyMessage", "DummyValue");
this.mockRequestData.Setup(rd => rd.MetricsCollection).Returns(metricsCollector);
DiscoveryCompleteEventArgs receivedDiscoveryCompleteEventArgs = null;
TestPluginCacheHelper.SetupMockExtensions(
new string[] { typeof(DiscovererEnumeratorTests).GetTypeInfo().Assembly.Location },
() => { });
var sources = new List <string>
{
typeof(DiscoveryManagerTests).GetTypeInfo().Assembly.Location
};
var mockLogger = new Mock <ITestDiscoveryEventsHandler2>();
var criteria = new DiscoveryCriteria(sources, 1, null);
mockLogger.Setup(ml => ml.HandleDiscoveryComplete(It.IsAny <DiscoveryCompleteEventArgs>(), It.IsAny <IEnumerable <TestCase> >()))
.Callback(
(DiscoveryCompleteEventArgs complete,
IEnumerable <TestCase> tests) =>
{
receivedDiscoveryCompleteEventArgs = complete;
});
// Act.
this.discoveryManager.DiscoverTests(criteria, mockLogger.Object);
// Assert
Assert.IsNotNull(receivedDiscoveryCompleteEventArgs.Metrics);
Assert.IsTrue(receivedDiscoveryCompleteEventArgs.Metrics.Any());
Assert.IsTrue(receivedDiscoveryCompleteEventArgs.Metrics.ContainsKey("DummyMessage"));
}
