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 UsingTestFilterBuilderSelectWhere(string expression, int count) { var builder = new TestFilterBuilder(); builder.SelectWhere(expression); Assert.That(_driver.CountTestCases(builder.GetFilter().Text), Is.EqualTo(count)); }