private List <NodeTest> LoadTestCaseDetails(ITestCaseDiscoveryMessage testCaseDiscoveryMessage, ITypeInfo testClass)
{
try
{
#if CORECLR
var specType = testCaseDiscoveryMessage.TestAssembly.Assembly.GetType(testClass.Name).ToRuntimeType();
#else
var testAssembly = Assembly.LoadFrom(testCaseDiscoveryMessage.TestAssembly.Assembly.AssemblyPath);
var specType = testAssembly.GetType(testClass.Name);
#endif
var roles = RoleNames(specType);
var details = roles.Select((r, i) => new NodeTest
{
Node = i + 1,
Role = r.Name,
TestName = testClass.Name,
TypeName = testClass.Name,
MethodName = testCaseDiscoveryMessage.TestCase.TestMethod.Method.Name,
SkipReason = testCaseDiscoveryMessage.TestCase.SkipReason,
}).ToList();
return(details);
}
catch (Exception ex)
{
// If something goes wrong with loading test details - just keep going with other tests
Console.WriteLine($"Failed to load test details for [{testClass.Name}] test class: {ex}");
return(new List <NodeTest>());
}
}
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
if (string.IsNullOrEmpty(testCase.SkipReason) &&
_filters.Filter(testCase))
{
//
// Get the performance metrics for this method
//
var testMethod = testCaseDiscovered.TestMethod;
List <PerformanceMetricInfo> metrics = new List <PerformanceMetricInfo>();
foreach (var metricAttr in GetMetricAttributes(testMethod))
{
var discovererAttr = metricAttr.GetCustomAttributes(typeof(PerformanceMetricDiscovererAttribute).AssemblyQualifiedName).First();
var discoverer = GetPerformanceMetricDiscoverer(discovererAttr);
metrics.AddRange(discoverer.GetMetrics(metricAttr));
}
if (metrics.Count > 0)
{
Tests.Add(new PerformanceTestInfo {
Assembly = _assembly, TestCase = testCaseDiscovered.TestCase, Metrics = metrics
});
}
}
return(true);
}
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
if (string.IsNullOrEmpty(testCase.SkipReason)) /* TODO: Currently there are not filters */
{
var testMethod = testCaseDiscovered.TestMethod;
var metrics = new List <PerformanceMetricInfo>();
var attributesInfo = GetMetricAttributes(testMethod);
foreach (var attributeInfo in attributesInfo)
{
var assemblyQualifiedAttributeTypeName = typeof(PerformanceMetricDiscovererAttribute).AssemblyQualifiedName;
var discovererAttr = attributeInfo.GetCustomAttributes(assemblyQualifiedAttributeTypeName).FirstOrDefault();
var discoverer = GetPerformanceMetricDiscoverer(discovererAttr);
metrics.AddRange(discoverer.GetMetrics(attributeInfo));
}
if (metrics.Count > 0)
{
Tests.Add(new PerformanceTestMessage
{
TestCase = testCaseDiscovered.TestCase,
Metrics = metrics
});
}
}
return(true);
}
protected override void OnTestDiscovered(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
if (_testCaseNameSet.Contains(testCase.DisplayName))
{
_testCaseList.Add(testCaseDiscovered.TestCase);
}
}
protected override bool Visit(ITestCaseDiscoveryMessage discovery)
{
if (filter == null || filter(discovery.TestCase))
{
TestCases.Add(discovery.TestCase);
}
return(true);
}
protected override bool Visit(ITestCaseDiscoveryMessage discovery)
{
Logger.LogVerbose("Discovered: {0}", discovery.TestCase.Format());
if (ShouldRunTestCase(discovery.TestCase))
{
TestCases.Add(discovery.TestCase);
}
return(true);
}
protected override void OnTestDiscovered(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
if (_testCaseNameSet.Contains(testCase.DisplayName))
{
_testCaseList.Add(testCaseDiscovered.TestCase);
}
}
protected override void OnTestDiscovered(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
if (_testCaseUniqueIDSet.Contains(testCase.UniqueID))
{
_testCaseList.Add(testCaseDiscovered.TestCase);
}
}
protected override void OnTestDiscovered(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
var testCaseData = new TestCaseData(
testCase.DisplayName,
testCase.SkipReason,
testCaseDiscovered.TestAssembly.Assembly.AssemblyPath,
testCase.Traits);
_writer.Write(TestDataKind.Value);
_writer.Write(testCaseData);
}
private NodeTest GetTestDetails(ITestCaseDiscoveryMessage nodeTest)
{
var matches = Regex.Match(nodeTest.TestClass.Class.Name, "(.+)([0-9]+)");
return new NodeTest
{
Node = Convert.ToInt32(matches.Groups[2].Value),
TestName = matches.Groups[1].Value,
TypeName = nodeTest.TestClass.Class.Name,
MethodName = nodeTest.TestCase.TestMethod.Method.Name
};
}
protected override void OnTestDiscovered(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
var testCaseData = new TestCaseData(
testCase.DisplayName,
testCase.SkipReason,
testCaseDiscovered.TestAssembly.Assembly.AssemblyPath,
testCase.Traits);
_writer.Write(TestDataKind.Value);
_writer.Write(testCaseData);
}
private NodeTest GetTestDetails(ITestCaseDiscoveryMessage nodeTest)
{
var matches = Regex.Match(nodeTest.TestClass.Class.Name, "(.+)([0-9]+)");
return(new NodeTest
{
Node = Convert.ToInt32(matches.Groups[2].Value),
TestName = matches.Groups[1].Value,
TypeName = nodeTest.TestClass.Class.Name,
MethodName = nodeTest.TestCase.TestMethod.Method.Name
});
}
private bool OnDiscoveryMessage(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
var testCaseData = new TestCaseData(
testCase.DisplayName,
testCaseDiscovered.TestAssembly.Assembly.AssemblyPath,
testCase.Traits);
_writer.Write(TestDataKind.Value);
_writer.Write(testCaseData);
return _writer.IsConnected;
}
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
if (testCaseDiscovered.TestCases != null)
{
foreach (var testCase in testCaseDiscovered.TestCases)
{
_sink.SendTest(testCase.ToTest());
}
}
else
{
_sink.SendTest(testCaseDiscovered.TestCase.ToTest());
}
return(base.Visit(testCaseDiscovered));
}
protected override bool Visit(ITestCaseDiscoveryMessage discovery)
{
var testCase = discovery.TestCase;
var testClass = $"{testCase.TestMethod.TestClass.Class.Name}.{testCase.TestMethod.Method.Name}";
if (lastTestClass != testClass)
{
SendExistingTestCases();
}
lastTestClass = testClass;
lastTestClassTestCases.Add(testCase);
TotalTests++;
return(!cancelThunk());
}
protected override bool Visit(ITestCaseDiscoveryMessage discovery)
{
var testCase = discovery.TestCase;
string testClass = String.Format("{0}.{1}", testCase.Class.Name, testCase.Method.Name);
if (lastTestClass != testClass)
{
SendExistingTestCases();
}
lastTestClass = testClass;
lastTestClassTestCases.Add(testCase);
TotalTests++;
return(!cancelThunk());
}
protected override bool Visit(ITestCaseDiscoveryMessage discovery)
{
var name = discovery.TestAssembly.Assembly.AssemblyPath.Split('\\').Last();
if (!name.Equals(_assemblyName, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
var testName = discovery.TestClass.Class.Name;
if (testName.Equals(_className, StringComparison.OrdinalIgnoreCase))
{
TestCases.Add(discovery.TestCase);
}
return(true);
}
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
var testCase = testCaseDiscovered.TestCase;
TestCases.Add(new TestCaseViewModel(discoverer.Serialize(testCase), testCase.DisplayName, testCaseDiscovered.TestAssembly.Assembly.AssemblyPath));
foreach (var k in testCase.Traits.Keys)
{
IList <string> value;
if (!Traits.TryGetValue(k, out value))
{
value = new List <string>();
Traits[k] = value;
}
value.AddRange(testCase.Traits[k]);
}
return(true);
}
protected override bool Visit(ITestCaseDiscoveryMessage discovery)
{
TestCases.Add(discovery.TestCase);
return(true);
}
/// <inheritdoc/>
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
TestCases.Add(testCaseDiscovered.TestCase);
return(true);
}
/// <summary>
/// Called when an instance of <see cref="ITestCaseDiscoveryMessage"/> is sent to the message sink.
/// </summary>
/// <param name="testCaseDiscovered">The message.</param>
/// <returns>Return <c>true</c> to continue discovering tests; <c>false</c> otherwise.</returns>
protected virtual bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
return(true);
}
_TestCaseDiscovered AdaptTestCaseDiscoveryMessage(ITestCaseDiscoveryMessage message)
{
var testCase = message.TestCase;
// Clean up the cache
lock (testUniqueIDsByTestCase)
testUniqueIDsByTestCase.Remove(testCase);
var testCollectionUniqueID = UniqueIDForTestCollection(assemblyUniqueID, message.TestCollection);
var testClassUniqueID = UniqueIDForTestClass(testCollectionUniqueID, message.TestClass);
var testMethodUniqueID = UniqueIDForTestMethod(testClassUniqueID, message.TestMethod);
var testCaseUniqueID = testCase.UniqueID;
string? @namespace = null;
string? @class = null;
var typeName = testCase.TestMethod?.TestClass?.Class.Name;
if (typeName != null)
{
var namespaceIdx = typeName.LastIndexOf('.');
if (namespaceIdx < 0)
{
@class = typeName;
}
else
{
@namespace = typeName.Substring(0, namespaceIdx);
@class = typeName.Substring(namespaceIdx + 1);
var innerClassIdx = @class.LastIndexOf('+');
if (innerClassIdx >= 0)
{
@class = @class.Substring(innerClassIdx + 1);
}
}
}
var result = new _TestCaseDiscovered
{
AssemblyUniqueID = assemblyUniqueID,
SkipReason = testCase.SkipReason,
SourceFilePath = testCase.SourceInformation?.FileName,
SourceLineNumber = testCase.SourceInformation?.LineNumber,
TestCaseDisplayName = testCase.DisplayName,
TestCaseUniqueID = testCaseUniqueID,
TestCollectionUniqueID = testCollectionUniqueID,
TestClass = @class,
TestClassUniqueID = testClassUniqueID,
TestClassWithNamespace = typeName,
TestMethod = testCase.TestMethod?.Method.Name,
TestMethodUniqueID = testMethodUniqueID,
TestNamespace = @namespace,
Traits = testCase.Traits
};
if (discoverer != null)
{
result.Serialization = discoverer.Serialize(testCase);
}
return(result);
}
protected abstract void OnTestDiscovered(ITestCaseDiscoveryMessage testCaseDiscovered);
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
Calls.Add("ITestCaseDiscoveryMessage");
return base.Visit(testCaseDiscovered);
}
protected abstract void OnTestDiscovered(ITestCaseDiscoveryMessage testCaseDiscovered);
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
Calls.Add("ITestCaseDiscoveryMessage");
return(base.Visit(testCaseDiscovered));
}
protected override bool Visit(ITestCaseDiscoveryMessage testCaseDiscovered)
{
_testHandler(testCaseDiscovered);
return(true);
}
