public void Add(XunitTestMethodTask methodTask)
{
var key = string.Format("{0}.{1}", methodTask.TypeName, methodTask.MethodName);
lock (lockObject)
{
if (!tasksByFullyQualifiedMethodName.ContainsKey(key))
AddMethodTask(key, methodTask.TypeName, new RemoteTaskWrapper(methodTask, server));
}
}
public Method(Class typeInfo, XunitTestClassTask classTask, string methodName, Action<object[]> methodBody, Parameter[] parameters, Attribute[] attributes)
{
@class = typeInfo;
Name = methodName;
Task = new XunitTestMethodTask(classTask.AssemblyLocation, classTask.TypeName, methodName, true, false);
body = methodBody;
this.parameters = parameters;
this.attributes = attributes;
TheoryTasks = GetTheoryTasks();
}
public RemoteTask GetMethodTask(string name, string type, string method)
{
var methodTask = methodTasks[type].FirstOrDefault(m => m.MethodName == method);
if (methodTask == null)
{
var classTask = GetClassTask(type);
methodTask = new XunitTestMethodTask(classTask.AssemblyLocation, type, method, true, true);
server.CreateDynamicElement(methodTask);
}
return methodTask;
}
public void SkippedTestRunReportedCorrectly()
{
const string methodName = "TestMethod";
const string displayName = "Test Display Name";
const string expectedSkipReason = "this is the skip reason";
var methodTask = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName, false);
logger.SetMethodTasks(new List<XunitTestMethodTask> { methodTask });
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask)).AtMostOnce().Verifiable();
// mockRemoteTaskServer.Setup(m => m.TaskExplain(methodTask, expectedSkipReason)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask, expectedSkipReason, TaskResult.Skipped)).AtMostOnce().Verifiable();
logger.ClassStart();
// TestStart isn't called!
logger.TestSkipped(displayName, TestClassTypeName, methodName, expectedSkipReason);
logger.TestFinished(displayName, TestClassTypeName, methodName);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
private static bool IsParentClassTask(XunitTestClassTask classTask, XunitTestMethodTask methodTask)
{
return classTask.AssemblyLocation == methodTask.AssemblyLocation
&& classTask.TypeName == methodTask.TypeName;
}
private static bool IsParentMethodTask(XunitTestMethodTask methodTask, XunitTestTheoryTask theoryTask)
{
return methodTask.AssemblyLocation == theoryTask.AssemblyLocation
&& methodTask.TypeName == theoryTask.TypeName
&& methodTask.MethodName == theoryTask.MethodName;
}
private IUnitTestElement GetDynamicMethodElement(Dictionary<RemoteTask, IUnitTestElement> tasks, XunitTestMethodTask methodTask)
{
var classElement = (from kvp in tasks
where kvp.Key is XunitTestClassTask &&
IsParentClassTask((XunitTestClassTask) kvp.Key, methodTask)
select kvp.Value).FirstOrDefault() as XunitTestClassElement;
if (classElement == null)
return null;
using (ReadLockCookie.Create())
{
var project = classElement.GetProject();
if (project == null)
return null;
var element = UnitTestElementFactory.GetTestMethod(project, classElement,
new ClrTypeName(methodTask.TypeName),
methodTask.MethodName);
// As for theories, make sure we always return an element
if (element != null)
{
// If the element is invalid, it's been removed from its parent, so add it back,
// and reset the state
if (element.State == UnitTestElementState.Invalid)
{
element.State = UnitTestElementState.Dynamic;
element.Parent = classElement;
}
return element;
}
// Dynamic methods - RunWith support
// Don't need to give a skip reason - we're adding this during a run, so
// we'll be notified if it's skipped
// TODO: Add traits
var declaredElementProvider = project.GetSolution().GetComponent<DeclaredElementProvider>();
return UnitTestElementFactory.CreateTestMethod(this, project, declaredElementProvider, classElement,
new ClrTypeName(methodTask.TypeName),
methodTask.MethodName,
string.Empty, EmptyArray<UnitTestElementCategory>.Instance,
isDynamic: true);
}
}
private void AddTheory(XunitTestMethodTask methodTask, XunitTestTheoryTask theoryTask)
{
if (!theoryTasks.ContainsKey(methodTask))
theoryTasks.Add(methodTask, new List<XunitTestTheoryTask>());
theoryTasks[methodTask].Add(theoryTask);
}
public void MethodTaskFinishesWithExceptionTaskResultWhenSecondTestRowFails()
{
const string methodName = "TestMethod";
const string displayName1 = "Test Row 1";
const string displayName2 = "Test Row 2";
const string expectedOutput1 = "This is the output of the first test row";
const string expectedOutput2 = "This is the output of the second test row";
var exception = GetException("This is the message");
var message = ExceptionUtility.GetMessage(exception);
var stackTrace = ExceptionUtility.GetStackTrace(exception);
string simplifiedMessage;
var taskExceptions = ExceptionConverter.ConvertExceptions(exception.GetType().FullName, message, stackTrace,
out simplifiedMessage);
var methodTask = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName, false);
logger.SetMethodTasks(new List<XunitTestMethodTask> { methodTask });
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask, expectedOutput1, TaskOutputType.STDOUT)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskException(methodTask, MatchExceptions(taskExceptions))).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask, expectedOutput2, TaskOutputType.STDOUT)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask, simplifiedMessage, TaskResult.Exception)).AtMostOnce().Verifiable();
logger.ClassStart();
logger.TestStart(displayName1, TestClassTypeName, methodName);
logger.TestPassed(displayName1, TestClassTypeName, methodName, 2.0, expectedOutput1);
logger.TestFinished(displayName1, TestClassTypeName, methodName);
logger.TestStart(displayName2, TestClassTypeName, methodName);
logger.TestFailed(displayName2, TestClassTypeName, methodName, 3.0, expectedOutput2, exception.GetType().FullName, message,
stackTrace);
logger.TestFinished(displayName2, TestClassTypeName, methodName);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
public void SuccessfulTestRunWithNoOutputReportedCorrectly()
{
const string methodName = "TestMethod";
const string displayName = "Test Display Name";
var methodTask = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName, false);
logger.MethodTasks = new List<XunitTestMethodTask> { methodTask };
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask, string.Empty, TaskResult.Success)).Returns(true).AtMostOnce().Verifiable();
logger.ClassStart();
logger.TestStart(displayName, TestClassTypeName, methodName);
logger.TestPassed(displayName, TestClassTypeName, methodName, 2.0, string.Empty);
logger.TestFinished(displayName, TestClassTypeName, methodName);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
private IUnitTestElement GetDynamicMethodElement(Dictionary <string, IUnitTestElement> tasks, XunitTestMethodTask methodTask)
{
IUnitTestElement parentElement;
if (!tasks.TryGetValue(methodTask.UncollapsedParentTaskId, out parentElement))
{
return(null);
}
var classElement = parentElement as XunitTestClassElement;
if (classElement == null)
{
return(null);
}
using (ReadLockCookie.Create())
{
var project = classElement.Id.GetProject();
if (project == null)
{
return(null);
}
// As for theories, make sure we always return an element
// TODO: Handle traits, notify unit test element manager
var services = project.GetSolution().GetComponent <XunitServiceProvider>();
var unitTestElementFactory = new UnitTestElementFactory(services, null, enableCache: false);
var element = unitTestElementFactory.GetOrCreateTestMethod(classElement.Id.Project, classElement,
new ClrTypeName(methodTask.TypeName), methodTask.MethodName, string.Empty,
new OneToSetMap <string, string>(), isDynamic: true);
element.State = UnitTestElementState.Dynamic;
return(element);
}
}
private RemoteTaskWrapper CreateDynamicMethodTask(ITestMethod testMethod, string methodName)
{
var classTask = GetClassTask(testMethod.TestClass);
var methodTask = new XunitTestMethodTask((XunitTestClassTask) classTask.RemoteTask, methodName, true, true);
var task = new RemoteTaskWrapper(methodTask, server);
server.CreateDynamicElement(methodTask);
return task;
}
private IUnitTestElement GetDynamicMethodElement(Dictionary<string, IUnitTestElement> tasks, XunitTestMethodTask methodTask)
{
IUnitTestElement parentElement;
if (!tasks.TryGetValue(methodTask.UncollapsedParentTaskId, out parentElement))
return null;
var classElement = parentElement as XunitTestClassElement;
if (classElement == null)
return null;
using (ReadLockCookie.Create())
{
var project = classElement.Id.GetProject();
if (project == null)
return null;
// As for theories, make sure we always return an element
// TODO: Handle traits, notify unit test element manager
var services = project.GetSolution().GetComponent<XunitServiceProvider>();
var unitTestElementFactory = new UnitTestElementFactory(services, null, enableCache: false);
var element = unitTestElementFactory.GetOrCreateTestMethod(classElement.Id.Project, classElement,
new ClrTypeName(methodTask.TypeName), methodTask.MethodName, string.Empty,
new OneToSetMap<string, string>(), isDynamic: true);
element.State = UnitTestElementState.Dynamic;
return element;
}
}
public void OneClassAndOneSuccessfulMethodAndOneSkippedMethodReportsCorrectly()
{
const string methodName1 = "TestMethod";
const string displayName1 = "Test Display Name";
const string expectedOutput1 = "This is the output of the second test";
const string methodName2 = "TestMethod2";
const string displayName2 = "Another Test Display Name";
const string expectedSkipReason = "This is the skip reason";
var methodTask1 = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName1, false);
var methodTask2 = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName2, false);
logger.SetMethodTasks(new List<XunitTestMethodTask> { methodTask1, methodTask2 });
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask1)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask1, expectedOutput1, TaskOutputType.STDOUT)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask1, string.Empty, TaskResult.Success)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask2)).AtMostOnce().Verifiable();
// mockRemoteTaskServer.Setup(m => m.TaskExplain(methodTask2, expectedSkipReason)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask2, expectedSkipReason, TaskResult.Skipped)).AtMostOnce().Verifiable();
logger.ClassStart();
logger.TestStart(displayName1, TestClassTypeName, methodName1);
logger.TestPassed(displayName1, TestClassTypeName, methodName1, 2.0, expectedOutput1);
logger.TestFinished(displayName1, TestClassTypeName, methodName1);
logger.TestSkipped(displayName2, TestClassTypeName, methodName2, expectedSkipReason);
logger.TestFinished(displayName2, TestClassTypeName, methodName2);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
public void FailingTestRunReportedCorrectly()
{
const string methodName = "TestMethod";
const string displayName = "Test Display Name";
const string expectedOutput = "This is the output of the test";
var exception = GetException("This is the message");
var message = ExceptionUtility.GetMessage(exception);
var stackTrace = ExceptionUtility.GetStackTrace(exception);
string simplifiedMessage;
var taskExceptions = ExceptionConverter.ConvertExceptions(exception.GetType().FullName, message, stackTrace,
out simplifiedMessage);
var methodTask = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName, false);
logger.MethodTasks = new List<XunitTestMethodTask> { methodTask };
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskException(methodTask, MatchExceptions(taskExceptions))).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask, expectedOutput, TaskOutputType.STDOUT)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask, simplifiedMessage, TaskResult.Exception)).Returns(true).AtMostOnce().Verifiable();
logger.ClassStart();
logger.TestStart(displayName, TestClassTypeName, methodName);
logger.TestFailed(displayName, TestClassTypeName, methodName, 3.0, expectedOutput, exception.GetType().FullName, message,
stackTrace);
logger.TestFinished(displayName, TestClassTypeName, methodName);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
public void MultipleTestRowsCallTestLoggerMultipleTimesForSameMethod()
{
const string methodName = "TestMethod";
const string displayName1 = "Test Row 1";
const string displayName2 = "Test Row 2";
const string expectedOutput1 = "This is the output of the first test row";
const string expectedOutput2 = "This is the output of the second test row";
var methodTask = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName, false);
logger.SetMethodTasks(new List<XunitTestMethodTask> { methodTask });
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask, expectedOutput1, TaskOutputType.STDOUT)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask, expectedOutput2, TaskOutputType.STDOUT)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask, string.Empty, TaskResult.Success)).AtMostOnce().Verifiable();
logger.ClassStart();
logger.TestStart(displayName1, TestClassTypeName, methodName);
logger.TestPassed(displayName1, TestClassTypeName, methodName, 2.0, expectedOutput1);
logger.TestFinished(displayName1, TestClassTypeName, methodName);
logger.TestStart(displayName2, TestClassTypeName, methodName);
logger.TestPassed(displayName2, TestClassTypeName, methodName, 2.0, expectedOutput2);
logger.TestFinished(displayName2, TestClassTypeName, methodName);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
public void TestRunWithOneClassAndTwoMethodsReportsCorrectly()
{
const string methodName1 = "TestMethod";
const string displayName1 = "Test Display Name";
const string expectedOutput1 = "This is the output of the test";
const string methodName2 = "TestMethod2";
const string displayName2 = "Another Test Display Name";
const string expectedOutput2 = "This is the output of the second test";
var methodTask1 = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName1, false);
var methodTask2 = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName2, false);
logger.MethodTasks = new List<XunitTestMethodTask> { methodTask1, methodTask2 };
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask1)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask1, expectedOutput1, TaskOutputType.STDOUT)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask1, string.Empty, TaskResult.Success)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask2)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask2, expectedOutput2, TaskOutputType.STDOUT)).Returns(true).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask2, string.Empty, TaskResult.Success)).Returns(true).AtMostOnce().Verifiable();
logger.ClassStart();
logger.TestStart(displayName1, TestClassTypeName, methodName1);
logger.TestPassed(displayName1, TestClassTypeName, methodName1, 2.0, expectedOutput1);
logger.TestFinished(displayName1, TestClassTypeName, methodName1);
logger.TestStart(displayName2, TestClassTypeName, methodName2);
logger.TestPassed(displayName2, TestClassTypeName, methodName2, 2.0, expectedOutput2);
logger.TestFinished(displayName2, TestClassTypeName, methodName2);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
public void SuccessfulTestRunReportedCorrectly()
{
const string methodName = "TestMethod";
const string displayName = "Test Display Name";
const string expectedOutput = "This is the output of the test";
var methodTask = new XunitTestMethodTask(TestAssemblyLocation, TestClassTypeName, methodName, false);
logger.SetMethodTasks(new List<XunitTestMethodTask> { methodTask });
AddSuccessfulClassExpectations();
mockRemoteTaskServer.Setup(m => m.TaskStarting(methodTask)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskOutput(methodTask, expectedOutput, TaskOutputType.STDOUT)).AtMostOnce().Verifiable();
mockRemoteTaskServer.Setup(m => m.TaskFinished(methodTask, string.Empty, TaskResult.Success)).AtMostOnce().Verifiable();
logger.ClassStart();
logger.TestStart(displayName, TestClassTypeName, methodName);
logger.TestPassed(displayName, TestClassTypeName, methodName, 2.0, expectedOutput);
logger.TestFinished(displayName, TestClassTypeName, methodName);
logger.ClassFinished();
mockRemoteTaskServer.Verify();
}
private void AddMethod(XunitTestClassTask classTask, XunitTestMethodTask methodTask)
{
methodTasks[classTask.TypeName].Add(methodTask);
}
