public void SetUp() { fakeTestNode = new NUnitTestCase(FakeTestData.GetTestNode()); var settings = Substitute.For <IAdapterSettings>(); settings.CollectSourceInformation.Returns(true); testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings); }
protected override void OnCreateTests () { if (testInfo.Tests == null) return; foreach (NunitTestInfo test in testInfo.Tests) { UnitTest newTest; if (test.Tests != null) newTest = new NUnitTestSuite (rootSuite, test); else newTest = new NUnitTestCase (rootSuite, test, ClassName); newTest.FixtureTypeName = test.FixtureTypeName; newTest.FixtureTypeNamespace = test.FixtureTypeNamespace; Tests.Add (newTest); } }
private List <NUnitTestCase> ConvertTestRunToNUnitCases(TestRun testRun) { var testCases = new List <NUnitTestCase>(); foreach (var unitTest in testRun.TestDefinitions) { var currentTestCase = new NUnitTestCase { FullName = $"{unitTest.TestMethod.className}.{unitTest.TestMethod.name}", ClassName = unitTest.TestMethod.className, Id = Guid.Parse(unitTest.id), }; testCases.Add(currentTestCase); } return(testCases); }
public void SetUp() { testLog = new FakeFrameworkHandle(); settings = Substitute.For <IAdapterSettings>(); executor = Substitute.For <INUnit3TestExecutor>(); executor.Settings.Returns(settings); settings.CollectSourceInformation.Returns(true); using (var testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings)) { fakeTestNode = new NUnitTestCase(FakeTestData.GetTestNode()); // Ensure that the converted testcase is cached testConverter.ConvertTestCase(fakeTestNode); Assert.NotNull(testConverter.GetCachedTestCase("123")); listener = new NUnitEventListener(testLog, testConverter, executor); } }
public static void AddTraitsFromTestNode(this TestCase testCase, NUnitTestCase testNCase, IDictionary <string, CachedTestCaseInfo> traitsCache, ITestLogger logger, IAdapterSettings adapterSettings) { var testNode = testNCase.Node; var ancestor = testNode.ParentNode; var key = ancestor?.Attributes?["id"]?.Value; var categoryList = new CategoryList(testCase, adapterSettings); // Reading ancestor properties of a test-case node. And adding to the cache. while (ancestor != null && key != null) { if (traitsCache.ContainsKey(key)) { categoryList.AddRange(traitsCache[key].Traits.Where(o => o.Name == NunitTestCategoryLabel).Select(prop => prop.Value).ToList()); if (traitsCache[key].Explicit) { testCase.SetPropertyValue(CategoryList.NUnitExplicitProperty, true); } var traitsList = traitsCache[key].Traits.Where(o => o.Name != NunitTestCategoryLabel).ToList(); if (traitsList.Count > 0) { testCase.Traits.AddRange(traitsList); } } else { categoryList.ProcessTestCaseProperties(ancestor, true, key, traitsCache); // Adding entry to dictionary, so that we will not make SelectNodes call again. if (categoryList.LastNodeListCount == 0 && !traitsCache.ContainsKey(key)) { traitsCache[key] = new CachedTestCaseInfo(); } } ancestor = ancestor.ParentNode; key = ancestor?.Attributes?["id"]?.Value; } // No Need to store test-case properties in cache. categoryList.ProcessTestCaseProperties(testNode, false); categoryList.UpdateCategoriesToVs(); }
/// <summary> /// Converts an NUnit test into a TestCase for Visual Studio, /// using the best method available according to the exact /// type passed and caching results for efficiency. /// </summary> public TestCase ConvertTestCase(NUnitTestCase testNode) { if (!testNode.IsTestCase) { throw new ArgumentException("The argument must be a test case", nameof(testNode)); } // Return cached value if we have one string id = testNode.Id; if (_vsTestCaseMap.ContainsKey(id)) { return(_vsTestCaseMap[id]); } // Convert to VS TestCase and cache the result var testCase = MakeTestCaseFromXmlNode(testNode); _vsTestCaseMap.Add(id, testCase); return(testCase); }
public void ThatRunStateIsHandledForNone() { var sut = new NUnitTestCase(XmlHelper.CreateXmlNode(xml_none)); Assert.That(sut.RunState, Is.EqualTo(NUnitTestCase.eRunState.NA)); }
public void ThatRunStateIsHandledForExplicit() { var sut = new NUnitTestCase(XmlHelper.CreateXmlNode(xml_explicit)); Assert.That(sut.RunState, Is.EqualTo(NUnitTestCase.eRunState.Explicit)); }
/// <summary> /// Makes a TestCase from an NUnit test, adding /// navigation data if it can be found. /// </summary> private TestCase MakeTestCaseFromXmlNode(NUnitTestCase testNode) { string fullyQualifiedName = testNode.FullName; if (adapterSettings.UseParentFQNForParametrizedTests) { var parent = testNode.Parent(); if (parent.IsParameterizedMethod) { var parameterizedTestFullName = parent.FullName; // VS expected FullyQualifiedName to be the actual class+type name,optionally with parameter types // in parenthesis, but they must fit the pattern of a value returned by object.GetType(). // It should _not_ include custom name or param values (just their types). // However, the "fullname" from NUnit's file generation is the custom name of the test, so // this code must convert from one to the other. // Reference: https://github.com/microsoft/vstest-docs/blob/master/RFCs/0017-Managed-TestCase-Properties.md // Using the nUnit-provided "fullname" will cause failures at test execution time due to // the FilterExpressionWrapper not being able to parse the test names passed-in as filters. // To resolve this issue, for parameterized tests (which are the only tests that allow custom names), // the parent node's "fullname" value is used instead. This is the name of the actual test method // and will allow the filtering to work as expected. // Note that this also means you can no longer select a single tests of these to run. // When you do that, all tests within the parent node will be executed if (!string.IsNullOrEmpty(parameterizedTestFullName)) { fullyQualifiedName = parameterizedTestFullName; } } } var testCase = new TestCase( fullyQualifiedName, new Uri(NUnitTestAdapter.ExecutorUri), _sourceAssembly) { DisplayName = testNode.Name, CodeFilePath = null, LineNumber = 0, }; if (adapterSettings.UseNUnitIdforTestCaseId) { var id = testNode.Id; testCase.Id = EqtHash.GuidFromString(id); } if (CollectSourceInformation && _navigationDataProvider != null) { var className = testNode.ClassName; var methodName = testNode.MethodName; var navData = _navigationDataProvider.GetNavigationData(className, methodName); if (navData.IsValid) { testCase.CodeFilePath = navData.FilePath; testCase.LineNumber = navData.LineNumber; } } testCase.AddTraitsFromTestNode(testNode, TraitsCache, _logger, adapterSettings); return(testCase); }
void FillTests (NunitTestInfo ti) { if (ti.Tests == null) return; foreach (NunitTestInfo test in ti.Tests) { UnitTest newTest; if (test.Tests != null) newTest = new NUnitTestSuite (this, test); else newTest = new NUnitTestCase (this, test, test.PathName); newTest.FixtureTypeName = test.FixtureTypeName; newTest.FixtureTypeNamespace = test.FixtureTypeNamespace; Tests.Add (newTest); } oldList = new UnitTest [Tests.Count]; Tests.CopyTo (oldList, 0); }