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); }