public void RaiseDiscoveredTestsShouldInvokeRegisteredEventHandler()
{
bool discoveredTestsReceived = false;
DiscoveredTestsEventArgs receivedEventArgs = null;
EventWaitHandle waitHandle = new AutoResetEvent(false);
List <TestCase> testCases = new List <TestCase> {
new TestCase("This is a string.", new Uri("some://uri"), "DummySourceFileName")
};
DiscoveredTestsEventArgs discoveredTestsEventArgs = new DiscoveredTestsEventArgs(testCases);
// Register for the discovered tests event.
loggerEvents.DiscoveredTests += (sender, e) =>
{
discoveredTestsReceived = true;
receivedEventArgs = e;
waitHandle.Set();
};
loggerEvents.EnableEvents();
// Send the discovered tests event.
loggerEvents.RaiseDiscoveredTests(discoveredTestsEventArgs);
var waitSuccess = waitHandle.WaitOne(500);
Assert.IsTrue(waitSuccess, "Event must be raised within timeout.");
Assert.IsTrue(discoveredTestsReceived);
Assert.IsNotNull(receivedEventArgs);
Assert.AreEqual(receivedEventArgs, discoveredTestsEventArgs);
}
private void discoveryRequest_OnDiscoveredTests(Object sender, DiscoveredTestsEventArgs args)
{
if (args == null)
{
throw new TestPlatformException("DiscoveredTestsEventArgs cannot be null.");
}
// Initializing the test case filter here because the filter value is read late.
this.testCasefilter.Initialize(this.options.TestCaseFilterValue);
var discoveredTests = args.DiscoveredTestCases.ToList();
var filteredTests = this.testCasefilter.FilterTests(discoveredTests).ToList();
// remove any duplicate tests
filteredTests = filteredTests.Select(test => test.FullyQualifiedName)
.Distinct()
.Select(fqdn => filteredTests.First(test => test.FullyQualifiedName == fqdn))
.ToList();
this.discoveredTests.AddRange(filteredTests.Select(test => test.FullyQualifiedName));
if (this.ObjectWriter != null)
{
foreach (var test in discoveredTests)
{
this.ObjectWriter.SendObject(test);
}
}
}
/// <inheritdoc/>
public void HandleDiscoveredTests(IEnumerable <TestCase> discoveredTestCases)
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("DiscoveryRequest.SendDiscoveredTests: Starting.");
}
lock (this.syncObject)
{
if (this.disposed)
{
if (EqtTrace.IsWarningEnabled)
{
EqtTrace.Warning("DiscoveryRequest.SendDiscoveredTests: Ignoring as the object is disposed.");
}
return;
}
var discoveredTestsEvent = new DiscoveredTestsEventArgs(discoveredTestCases);
this.LoggerManager.HandleDiscoveredTests(discoveredTestsEvent);
this.OnDiscoveredTests.SafeInvoke(this, discoveredTestsEvent, "DiscoveryRequest.OnDiscoveredTests");
}
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("DiscoveryRequest.SendDiscoveredTests: Completed.");
}
}
/// <summary>
/// Raises discovered tests event to the enabled loggers.
/// </summary>
/// <param name="args"> Arguments to be raised. </param>
internal void RaiseDiscoveredTests(DiscoveredTestsEventArgs args)
{
ValidateArg.NotNull <DiscoveredTestsEventArgs>(args, "args");
CheckDisposed();
SafeInvokeAsync(() => this.DiscoveredTests, args, 0, "InternalTestLoggerEvents.SendDiscoveredTests");
}
private void Events_DiscoveredTests(object sender, DiscoveredTestsEventArgs e)
{
TestCaseInfos = TestCaseInfos.Concat(e.DiscoveredTestCases.Select(testCase =>
{
string name = testCase.DisplayName;
string[] categories;
try
{
categories = testCase.GetPropertyValue <string[]>(TestProperty.Find("MSTestDiscoverer.TestCategory"), new string[] { });
}
catch
{
categories = new string[] { };
}
string description;
try
{
description = testCase.GetPropertyValue <string>(TestProperty.Find("Description"), String.Empty);
}
catch
{
description = String.Empty;
}
var testcaseToolTipBuilder = new StringBuilder();
testcaseToolTipBuilder.Append(name);
if (categories.Length > 0)
{
testcaseToolTipBuilder.Append(Environment.NewLine + "Category:");
foreach (var category in categories)
{
testcaseToolTipBuilder.Append(Environment.NewLine + " " + category);
}
}
if (!string.IsNullOrEmpty(description))
{
testcaseToolTipBuilder.Append(Environment.NewLine + "Description:");
testcaseToolTipBuilder.Append(Environment.NewLine + " " + description);
}
return(new TestCaseInfo
{
Category = categories,
Description = description,
FullName = testCase.FullyQualifiedName,
Name = testCase.DisplayName,
ToolTipOnUI = testcaseToolTipBuilder.ToString(),
});
}));
}
/// <summary>
/// Handle discovered tests.
/// </summary>
/// <param name="e">DiscoveredTests event args.</param>
public void HandleDiscoveredTests(DiscoveredTestsEventArgs e)
{
if (this.isDisposed)
{
EqtTrace.Warning("TestLoggerManager.HandleDiscoveredTests: Ignoring as the object is disposed.");
return;
}
this.loggerEvents.RaiseDiscoveredTests(e);
}
private void discoveryRequest_OnDiscoveredTests(Object sender, DiscoveredTestsEventArgs args)
{
// List out each of the tests.
foreach (var test in args.DiscoveredTestCases)
{
this.output.WriteLine(String.Format(CultureInfo.CurrentUICulture,
CommandLineResources.AvailableTestsFormat,
test.DisplayName),
OutputLevel.Information);
}
}
public void RaiseDiscoveredTestsShouldThrowExceptionIfAlreadyDisposed()
{
var loggerEvents = GetDisposedLoggerEvents();
List <TestCase> testCases = new List <TestCase> {
new TestCase("This is a string.", new Uri("some://uri"), "DummySourceFileName")
};
DiscoveredTestsEventArgs discoveredTestsEventArgs = new DiscoveredTestsEventArgs(testCases);
Assert.ThrowsException <ObjectDisposedException>(() =>
{
loggerEvents.RaiseDiscoveredTests(discoveredTestsEventArgs);
});
}
/// <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>
/// Filter discovered tests and find matching tests from given search strings.
/// Any name of the test that can match multiple strings will be added only once.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void discoveryRequest_OnDiscoveredTests(object sender, DiscoveredTestsEventArgs args)
{
this.discoveredTestCount += args.DiscoveredTestCases.Count();
foreach (var testCase in args.DiscoveredTestCases)
{
foreach (var nameCriteria in this.selectedTestNames)
{
if (testCase.FullyQualifiedName.IndexOf(nameCriteria, StringComparison.OrdinalIgnoreCase) != -1)
{
this.selectedTestCases.Add(testCase);
// If a testcase matched then a filter matched - so remove the filter from not found list
this.undiscoveredFilters.Remove(nameCriteria);
break;
}
}
}
}
public void DiscoveryRequestRaiseShouldInvokeDiscoveredTestsHandlerOfLoggersOnlyIfRegistered()
{
counter = 0;
waitHandle.Reset();
List <TestCase> testCases = new List <TestCase> {
new TestCase("This is a string.", new Uri("some://uri"), "DummySourceFileName")
};
DiscoveredTestsEventArgs discoveredTestsEventArgs = new DiscoveredTestsEventArgs(testCases);
// mock for IDiscoveryRequest
var discoveryRequest = new Mock <IDiscoveryRequest>();
// setup TestLogger
TestLoggerManager.Instance.AddLogger(new Uri(loggerUri), new Dictionary <string, string>());
TestLoggerManager.Instance.EnableLogging();
// Register DiscoveryRequest object
TestLoggerManager.Instance.RegisterDiscoveryEvents(discoveryRequest.Object);
//Raise an event on mock object
discoveryRequest.Raise(
m => m.OnDiscoveredTests += null,
discoveredTestsEventArgs);
// Assertions when discovery events registered
waitHandle.WaitOne();
Assert.AreEqual(counter, 1);
// Unregister DiscoveryRequest object
TestLoggerManager.Instance.UnregisterDiscoveryEvents(discoveryRequest.Object);
//Raise an event on mock object
discoveryRequest.Raise(
m => m.OnDiscoveredTests += null,
discoveredTestsEventArgs);
// Assertions when discovery events unregistered
Assert.AreEqual(counter, 1);
}
public void HandleDiscoveryComplete_Otherwise_RaisesTestCasesDiscoveredWithLastChunkAsDiscoveredTestCases(int testCaseCount)
{
var vstest = Substitute.For <IVsTestConsoleWrapper>();
var uut = new TestCaseDiscoveryManager(vstest);
uut.DiscoverTestCasesAsync(Enumerable.Empty <string>()).Wait();
DiscoveredTestsEventArgs args = null;
var handler = Substitute.For <EventHandler <DiscoveredTestsEventArgs> >();
handler.When(x => x.Invoke(Arg.Any <object>(), Arg.Any <DiscoveredTestsEventArgs>())).Do(x => args = (DiscoveredTestsEventArgs)x[1]);
uut.TestCasesDiscovered += handler;
var lastChunk = Enumerable.Repeat(1, testCaseCount).Select(x => new TestCase()
{
Id = Guid.NewGuid()
}).ToArray();
uut.HandleDiscoveryComplete(0, lastChunk, false);
handler.Received(1).Invoke(uut, Arg.Any <DiscoveredTestsEventArgs>());
CollectionAssert.AreEquivalent(lastChunk, args.DiscoveredTestCases);
}
/**********************************************************************/
#region Event Handlers
private void OnTestCasesDiscovered(object sender, DiscoveredTestsEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
var addedTestResults = new List <ITestResult>(e.DiscoveredTestCases.Count());
var modifiedTestResults = new List <ITestResult>(_testResultsByTestCaseId.Count);
foreach (var testCase in e.DiscoveredTestCases)
{
if (_testResultsByTestCaseId.ContainsKey(testCase.Id))
{
var oldTestResult = _testResultsByTestCaseId[testCase.Id];
var newTestResult = _testObjectFactory.CloneTestResult(oldTestResult, testCase);
_testResultsByTestCaseId[testCase.Id] = newTestResult;
modifiedTestResults.Add(newTestResult);
}
else
{
var newTestResult = _testObjectFactory.CreateTestResult(testCase);
_testResultsByTestCaseId.Add(testCase.Id, newTestResult);
addedTestResults.Add(newTestResult);
}
_discoverySessionTestResultTestCaseIds.Add(testCase.Id);
}
if (addedTestResults.Count > 0)
{
RaiseTestResultsAdded(addedTestResults);
}
if (modifiedTestResults.Count > 0)
{
RaiseTestResultsModified(modifiedTestResults);
}
}
/// <inheritdoc/>
public void HandleDiscoveryComplete(DiscoveryCompleteEventArgs discoveryCompleteEventArgs, IEnumerable <TestCase> lastChunk)
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("DiscoveryRequest.DiscoveryComplete: Starting. Aborted:{0}, TotalTests:{1}", discoveryCompleteEventArgs.IsAborted, discoveryCompleteEventArgs.TotalCount);
}
lock (this.syncObject)
{
if (this.disposed)
{
if (EqtTrace.IsWarningEnabled)
{
EqtTrace.Warning("DiscoveryRequest.DiscoveryComplete: Ignoring as the object is disposed.");
}
return;
}
// If discovery event is already raised, ignore current one.
if (this.discoveryCompleted.WaitOne(0))
{
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("DiscoveryRequest.DiscoveryComplete:Ignoring duplicate DiscoveryComplete. Aborted:{0}, TotalTests:{1}", discoveryCompleteEventArgs.IsAborted, discoveryCompleteEventArgs.TotalCount);
}
return;
}
// Close the discovery session and terminate any test host processes. This operation should never
// throw.
this.DiscoveryManager?.Close();
try
{
// Raise onDiscoveredTests event if there are some tests in the last chunk.
// (We don't want to send the tests in the discovery complete event so that programming on top of
// RS client is easier i.e. user does not have to listen on discovery complete event.)
if (lastChunk != null && lastChunk.Any())
{
var discoveredTestsEvent = new DiscoveredTestsEventArgs(lastChunk);
this.LoggerManager.HandleDiscoveredTests(discoveredTestsEvent);
this.OnDiscoveredTests.SafeInvoke(this, discoveredTestsEvent, "DiscoveryRequest.DiscoveryComplete");
}
this.LoggerManager.HandleDiscoveryComplete(discoveryCompleteEventArgs);
this.OnDiscoveryComplete.SafeInvoke(this, discoveryCompleteEventArgs, "DiscoveryRequest.DiscoveryComplete");
}
finally
{
// Notify the waiting handle that discovery is complete
if (this.discoveryCompleted != null)
{
this.discoveryCompleted.Set();
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("DiscoveryRequest.DiscoveryComplete: Notified the discovery complete event.");
}
}
else
{
if (EqtTrace.IsWarningEnabled)
{
EqtTrace.Warning("DiscoveryRequest.DiscoveryComplete: Discovery complete event was null.");
}
}
this.discoveryInProgress = false;
var discoveryFinalTimeTaken = DateTime.UtcNow - this.discoveryStartTime;
// Fill in the Metrics From Test Host Process
var metrics = discoveryCompleteEventArgs.Metrics;
if (metrics != null && metrics.Count != 0)
{
foreach (var metric in metrics)
{
this.requestData.MetricsCollection.Add(metric.Key, metric.Value);
}
}
// Collecting Total Time Taken
this.requestData.MetricsCollection.Add(
TelemetryDataConstants.TimeTakenInSecForDiscovery, discoveryFinalTimeTaken.TotalSeconds);
}
}
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("DiscoveryRequest.DiscoveryComplete: Completed.");
}
}
private void DiscoveredTestsHandler(object sender, DiscoveredTestsEventArgs e)
{
TestLoggerManagerTests.counter++;
TestLoggerManagerTests.waitHandle.Set();
}
/// <summary>
/// Send discovered tests to all registered listeners.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DiscoveredTestsHandler(object sender, DiscoveredTestsEventArgs e)
{
this.loggerEvents.RaiseDiscoveredTests(e);
}
public void OnDiscoveredTests(DiscoveredTestsEventArgs e) => DiscoveredTests?.Invoke(this, e);
