public void SetUp()
{
fakeTestNode = new NUnitEventTestCase(FakeTestData.GetTestNode());
var settings = Substitute.For <IAdapterSettings>();
settings.ConsoleOut.Returns(0);
settings.UseTestNameInConsoleOutput.Returns(false);
settings.CollectSourceInformation.Returns(true);
testConverterForXml = new TestConverterForXml(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings);
}
public void SetUp()
{
testLog = new FakeFrameworkHandle();
settings = Substitute.For <IAdapterSettings>();
executor = Substitute.For <INUnit3TestExecutor>();
executor.Settings.Returns(settings);
executor.FrameworkHandle.Returns(testLog);
settings.CollectSourceInformation.Returns(true);
using var testConverter = new TestConverterForXml(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings);
fakeTestNode = new NUnitEventTestCase(FakeTestData.GetTestNode());
// Ensure that the converted testcase is cached
testConverter.ConvertTestCase(fakeTestNode);
Assert.That(testConverter.GetCachedTestCase("123"), Is.Not.Null);
listener = new NUnitEventListener(testConverter, executor);
}
public static void AddTraitsFromXmlTestNode(this TestCase testCase, NUnitEventTestCase testNCase,
IDictionary <string, CachedTestCaseInfo> traitsCache, ITestLogger logger, IAdapterSettings adapterSettings)
{
var ancestor = testNCase.Parent;
var key = ancestor?.Id;
var categoryList = new CategoryList(testCase, adapterSettings);
// Reading ancestor properties of a test-case node. And adding to the cache.
while (ancestor != null && key != null)
{
AddingToCache(testCase, traitsCache, key, categoryList, ancestor, categoryList.ProcessTestCaseProperties);
ancestor = ancestor.Parent;
key = ancestor?.Id;
}
// No Need to store test-case properties in cache.
categoryList.ProcessTestCaseProperties(testNCase, false);
categoryList.UpdateCategoriesToVs();
}
public static void AddTraitsFromXmlTestNode(this TestCase testCase, NUnitEventTestCase testNCase,
IDictionary <string, CachedTestCaseInfo> traitsCache, ITestLogger logger, IAdapterSettings adapterSettings)
{
var ancestor = testNCase.Parent;
var key = ancestor?.Id;
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.Parent;
key = ancestor?.Id;
}
// No Need to store test-case properties in cache.
categoryList.ProcessTestCaseProperties(testNCase, 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(NUnitEventTestCase 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);
}
/// <summary>
/// Makes a TestCase from an NUnit test, adding
/// navigation data if it can be found.
/// </summary>
private TestCase MakeTestCaseFromXmlNode(NUnitEventTestCase testNode)
{
string fullyQualifiedName = testNode.FullName;
if (adapterSettings.UseParentFQNForParametrizedTests)
{
var parent = testNode.Parent;
if (parent != null && 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 = CreateDisplayName(fullyQualifiedName, testNode.Name),
CodeFilePath = null,
LineNumber = 0,
};
if (adapterSettings.UseNUnitIdforTestCaseId)
{
var id = testNode.Id;
testCase.Id = EqtHash.GuidFromString(id);
}
if (CollectSourceInformation && _navigationDataProvider != null)
{
if (!CheckCodeFilePathOverride())
{
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;
}
}
}
else
{
_ = CheckCodeFilePathOverride();
}
testCase.AddTraitsFromXmlTestNode(testNode, TraitsCache, _logger, adapterSettings);
return(testCase);
bool CheckCodeFilePathOverride()
{
var codeFilePath = testNode.Properties.FirstOrDefault(p => p.Name == "_CodeFilePath");
if (codeFilePath == null)
{
return(false);
}
testCase.CodeFilePath = codeFilePath.Value;
var lineNumber = testNode.Properties.FirstOrDefault(p => p.Name == "_LineNumber");
testCase.LineNumber = lineNumber != null?Convert.ToInt32(lineNumber.Value) : 1;
return(true);
}
}
public void ThatRunStateIsHandledForNone()
{
var sut = new NUnitEventTestCase(XmlHelper.CreateXmlNode(XmlNone));
Assert.That(sut.RunState, Is.EqualTo(RunStateEnum.NA));
}
public void ThatRunStateIsHandledForExplicit()
{
var sut = new NUnitEventTestCase(XmlHelper.CreateXmlNode(xml_explicit));
Assert.That(sut.RunState, Is.EqualTo(RunStateEnum.Explicit));
}
