public void UsingTestFilterBuilderAddTest(string testName, int count)
{
var builder = new TestFilterBuilder();
builder.AddTest(testName);
Assert.That(_driver.CountTestCases(builder.GetFilter().Text), Is.EqualTo(count));
}
public IList <string> FindTests()
{
var runner = getRunner();
var builder = new TestFilterBuilder();
var filter = builder.GetFilter();
var explore = runner.Explore(filter);
var testNodes = explore.SelectNodes(@"//test-case");
return(testNodes.Cast <XmlNode>().Select(s => s.Attributes["name"].Value).ToList());
}
public string RunTest(string testName)
{
var runner = getRunner();
var builder = new TestFilterBuilder();
builder.SelectWhere($"method==\"{testName}\"");
var filter = builder.GetFilter();
var results = runner.Run(this, filter);
var testNodes = results.SelectNodes(@"//test-case");
return(testNodes.Cast <XmlNode>().Select(s => s.Attributes["result"].Value).First());
}
/// <summary>
/// Creates the test filter.
/// </summary>
/// <param name="assembly"></param>
/// <param name="features">The features.</param>
/// <returns><see cref="TestFilter"/>.</returns>
public static TestFilter CreateTestFilter(Assembly assembly, List <string> features)
{
ITestFilterBuilder filterBuilder = new TestFilterBuilder();
List <string> filters = features.Select(feature =>
$"class = {TypeLocatorHelper.GetTypeByAttributeAndName(assembly, typeof(DescriptionAttribute), feature)}")
.ToList();
filterBuilder.SelectWhere(string.Join(" || ", filters));
return(filterBuilder.GetFilter());
}
public static TestFilter CreateFilter(XmlNode node)
{
var filterBuilder = new TestFilterBuilder();
node.SelectNodes("//test-case/@fullname")
.OfType <XmlAttribute>()
.Select(x => x.Value)
.ToList()
.ForEach(filterBuilder.AddTest);
return(filterBuilder.GetFilter());
}
private TestFilter GetTestFilter(IEnumerable <string> tests)
{
var testFilterBuilder = new TestFilterBuilder();
if (tests != null)
{
foreach (var test in tests)
{
testFilterBuilder.AddTest(test);
}
}
return(testFilterBuilder.GetFilter());
}
public static string RunAllTests(string pathToAssembly)
{
XmlNode xml;
using (var activator = new CustomTestEngineActivator())
using (var engine = activator.CreateInstance())
{
using (var runner = engine.GetRunner(new TestPackage(pathToAssembly)))
{
var filter = new TestFilterBuilder().GetFilter();
xml = runner.Run(new NopTestEventListener(), filter);
}
}
return(xml.ToString());
}
private static TestRunResult RunTests(
IEnumerable <string> testAssemblyFilePaths,
IEnumerable <string> testMethodNames,
ITestEventListener testEventListener)
{
using (var testEngine = CreateTestEngine())
using (var testRunner = testEngine.GetRunner(CreateTestPackage(testAssemblyFilePaths)))
{
var filterBuilder = new TestFilterBuilder();
testMethodNames.ToList().ForEach(tn =>
filterBuilder.AddTest(tn));
var results = testRunner.Run(testEventListener, filterBuilder.GetFilter());
return(NUnitRunResults.Parse(results));
}
}
protected override TestExecutionResults ExecuteImpl(string testModule, IEnumerable <IMemberDefinition> testsToRun, string[] arguments)
{
logger.Info(string.Format("Running NUnit2 executor in App domain: {0}", AppDomain.CurrentDomain.FriendlyName));
result = new TestExecutionResults();
var appDomain = AppDomain.CreateDomain("nunit2-test", null, testModule, null, false);
NUnit2FrameworkDriver driver = new NUnit2FrameworkDriver(appDomain)
{
ID = "1"
}; // Not sure why "1" but necessary
var settings = new Dictionary <string, object>();
string x = driver.Load(testModule, settings);
TestFilterBuilder filterBuilder = new TestFilterBuilder();
foreach (var t in testsToRun)
{
filterBuilder.AddTest(t.GetFullName());
}
string filter = filterBuilder.GetFilter().Text;
string discoveryXmlString = driver.Explore(filter);
// TODO: Check if discovery information can be otained from
// execution results. Not sure if execution results contain all
// test methods and classes or only executed ones
ParseDiscoveryResults(discoveryXmlString.ToXmlDocument());
if (testsToRun.Count() > 0)
{
string xmlString = driver.Run(this, filter);
ParseExecutionResults(xmlString.ToXmlDocument());
}
else
{
logger.Info("No tests selected for run");
}
AppDomain.Unload(appDomain);
var temp = result;
// clean the local field for the next time
result = null;
return(temp);
}
private static IEnumerable <string> GetFailedTests(ITestRunner testRunner,
Type implementationType, Type testsType)
{
var builder = new TestFilterBuilder();
builder.AddTest(testsType.FullName);
var report = testRunner.Run(null, builder.GetFilter());
Debug.Assert(report != null);
File.WriteAllText($"{implementationType.Name}.nunitReport.xml", report.OuterXml);
var failedTestCases = report.SelectNodes("//test-case[@result='Failed']");
Debug.Assert(failedTestCases != null);
foreach (var xmlNode in failedTestCases.Cast <XmlNode>())
{
Debug.Assert(xmlNode.Attributes != null);
yield return(xmlNode.Attributes["name"].Value);
}
}
TestFilter CreateTestFilter(IEnumerable <string> testList)
{
ITestFilterBuilder builder = new TestFilterBuilder();
foreach (string testName in testList)
{
builder.AddTest(testName);
}
foreach (string testName in _options.TestList)
{
builder.AddTest(testName);
}
if (_options.WhereClauseSpecified)
{
builder.SelectWhere(_options.WhereClause);
}
return(builder.GetFilter());
}
// This is public static for ease of testing
public static TestFilter CreateTestFilter(ConsoleOptions options)
{
TestFilterBuilder builder = new TestFilterBuilder();
foreach (string testName in options.TestList)
{
builder.Tests.Add(testName);
}
// TODO: Support multiple include / exclude options
if (options.Include != null)
{
builder.Include.Add(options.Include);
}
if (options.Exclude != null)
{
builder.Exclude.Add(options.Exclude);
}
return(builder.GetFilter());
}
public IDictionary <string, IList <string> > FindTests()
{
var testStructure = new Dictionary <string, IList <string> >();
var runner = getRunner();
var builder = new TestFilterBuilder();
var filter = builder.GetFilter();
var explore = runner.Explore(filter);
var testFileNodes = explore.SelectNodes(@"//test-suite/test-suite/test-suite");
foreach (var testFileNode in testFileNodes.Cast <XmlNode>())
{
var fileName = testFileNode.Attributes["name"].Value;
var tests = testFileNode
.SelectNodes(@"./test-case")
.Cast <XmlNode>()
.Select(s => s.Attributes["name"].Value)
.ToList();
testStructure.Add(fileName, tests);
}
return(testStructure);
}
/// <summary>
/// Goes through every category and prints out how many tests were found per category
/// </summary>
/// <param name="categories"></param>
private void PrintNumTestsInEveryCategory(IEnumerable <string> categories)
{
foreach (var category in categories)
{
ITestFilterBuilder filterBuilder = new TestFilterBuilder();
filterBuilder.SelectWhere($"cat == {category}");
var filter = filterBuilder.GetFilter();
var count = Runner.CountTestCases(filter);
Console.WriteLine("\n\n....................................................");
Console.WriteLine($"Searching for test cases for category \"{category}\".");
if (count == 0)
{
Console.WriteLine($"Category {category} yielded no results.");
}
else
{
Console.WriteLine($"{count} tests found.");
}
}
}
public void CreateBuilder()
{
this.builder = new TestFilterBuilder();
}
// This is public static for ease of testing
public static TestFilter CreateTestFilter(ConsoleOptions options)
{
TestFilterBuilder builder = new TestFilterBuilder();
foreach (string testName in options.TestList)
builder.Tests.Add(testName);
// TODO: Support multiple include / exclude options
if (options.Include != null)
builder.Include.Add(options.Include);
if (options.Exclude != null)
builder.Exclude.Add(options.Exclude);
return builder.GetFilter();
}
protected override TestExecutionResults ExecuteImpl(string testModule, IEnumerable <IMemberDefinition> testsToRun, string[] args)
{
logger.Info(string.Format("Running NUnit3 executor in App domain: {0}", AppDomain.CurrentDomain.FriendlyName));
result = new TestExecutionResults();
TestFilterBuilder filterBuilder = new TestFilterBuilder();
foreach (var t in testsToRun)
{
filterBuilder.AddTest(t.GetFullName());
}
using (var engine = TestEngineActivator.CreateInstance())
{
TestPackage package = new TestPackage(testModule);
using (var runner = engine.GetRunner(package))
{
// explore all tests (default filter used)
XmlNode explorationResults = runner.Explore(new TestFilterBuilder().GetFilter());
ParseDiscoveryResults(explorationResults);
//foreach (var test in result.TestClasses)
//{
// if (!testsToRun.Contains(test))
// {
// result.NotExecutedTestClasses.Add(test);
// }
//}
//foreach (var test in testsToRun)
//{
// if (!result.TestClasses.Contains(test))
// {
// logger.Debug($"Test: {test} found during analyzes phase but not discovered using Runner");
// }
//}
if (testsToRun.Count() > 0)
{
XmlNode runResults = runner.Run(this, filterBuilder.GetFilter());
ParseExecutionResults(runResults);
try
{
runner.Unload();
}
catch (Exception e)
{
logger.Warn("Error while unloading runner", e);
}
}
else
{
logger.Info("No tests selected for run");
}
}
}
var temp = result;
// clean the local field for the next time
result = null;
return(temp);
}
private ConsoleTestRunnerResult RunTests(TestPackage package)
{
var labels = (_options.DisplayTestLabels ?? LabelsOutputMode.On).ToString().ToUpperInvariant();
XmlNode?result = null;
NUnitEngineUnloadException?unloadException = null;
NUnitEngineException? engineException = null;
try
{
using (new SaveConsoleOutput())
using (var runner = _engine.GetRunner(package))
{
var eventHandler = new TestEventHandler(_outWriter, labels);
var testFilter = new TestFilterBuilder().GetFilter();
result = runner.Run(eventHandler, testFilter);
}
}
catch (NUnitEngineUnloadException ex)
{
unloadException = ex;
}
catch (NUnitEngineException ex)
{
engineException = ex;
}
if (result != null)
{
var reporter = new ResultReporter(result, _outWriter, _options);
reporter.ReportResults();
if (engineException != null)
{
_outWriter.WriteLine(ColorStyle.Error, Environment.NewLine + ExceptionHelper.BuildMessage(engineException));
return(new ConsoleTestRunnerResult(new UnexpectedError(engineException)));
}
if (unloadException != null)
{
_outWriter.WriteLine(ColorStyle.Warning, Environment.NewLine + ExceptionHelper.BuildMessage(unloadException));
}
if (reporter.Summary.UnexpectedError)
{
return(new ConsoleTestRunnerResult(default(UnexpectedError)));
}
if (reporter.Summary.InvalidAssemblies > 0)
{
return(new ConsoleTestRunnerResult(default(InvalidAssembly)));
}
if (reporter.Summary.InvalidTestFixtures > 0)
{
return(new ConsoleTestRunnerResult(default(InvalidTestFixture)));
}
var failureCount = reporter.Summary.FailureCount + reporter.Summary.ErrorCount + reporter.Summary.InvalidCount;
if (failureCount == 0)
{
return(new ConsoleTestRunnerResult(new SomeFailures(reporter.Summary)));
}
return(new ConsoleTestRunnerResult(new AllSuccess(reporter.Summary)));
}
// If we got here, it's because we had an exception, but check anyway
if (engineException != null)
{
_outWriter.WriteLine(ColorStyle.Error, ExceptionHelper.BuildMessage(engineException));
_outWriter.WriteLine();
_outWriter.WriteLine(ColorStyle.Error, ExceptionHelper.BuildMessageAndStackTrace(engineException));
}
return(new ConsoleTestRunnerResult(new UnexpectedError(engineException)));
}
public void CreateBuilder()
{
this.builder = new TestFilterBuilder();
}
public void UsingTestFilterBuilderSelectWhere(string expression, int count)
{
var builder = new TestFilterBuilder();
builder.SelectWhere(expression);
Assert.That(_driver.CountTestCases(builder.GetFilter().Text), Is.EqualTo(count));
}