public void RunTestAssemblyWithTestInitAndTestCleanup() { var runner = new Runner(); runner.Assemblies.Add(new MsTestAssemblyFactory().Load("TestInitTestCleanup.dll")); runner.MethodRunners.Add(new AppDomainMethodRunner()); var report = runner.Run(); }
public void OneFailingTestMethod() { var runner = new Runner(); runner.Assemblies.Add(new MsTestAssemblyFactory().Load("OneFailingTestMethod.dll")); runner.MethodRunners.Add(new AppDomainMethodRunner()); var report = runner.Run().First() as FailedMethodExecutionReport; Assert.AreEqual("TestMethod1", report.Method.Name); Assert.IsInstanceOfType(report.Exception, typeof(AssertFailedException)); }
public void RunOneTest() { var runner = new Runner(); runner.Assemblies.Add(new MsTestAssemblyFactory().Load("OneTestMethodOnly.dll")); runner.MethodRunners.Add(new AppDomainMethodRunner()); var report = runner.Run(); Assert.AreEqual(1, report.Count()); Assert.AreEqual("TestMethod1", report.First().Method.Name); Assert.IsTrue(report.First() is SuccessMethodExecutionReport); }
public void RunTwoTestClassesWithOneTestMethodInEachOnTwoRunners() { var runner = new Runner(); runner.Assemblies.Add(new MsTestAssemblyFactory().Load("TwoTestClassesWithOneTestMethodInEach.dll")); runner.MethodRunners.Add(new AppDomainMethodRunner()); runner.MethodRunners.Add(new AppDomainMethodRunner()); var watch = Stopwatch.StartNew(); var report = runner.Run(); watch.Stop(); Assert.IsTrue(report.Select(r => r.Method.Name).Contains("TestMethod1")); Assert.IsTrue(report.Select(r => r.Method.Name).Contains("TestMethod2")); Assert.AreEqual(2, report.Count()); Assert.IsTrue(watch.Elapsed < TimeSpan.FromSeconds(6)); }
public void GivenThereIsATestClassWithAAssemblyInitThenItShouldRunTheAssemblyInitOnceForAllTheTestsInTheAssembly() { var methodRunner1 = new Mock<IMethodRunner>(); var methodRunner2 = new Mock<IMethodRunner>(); var assembly = new TestAssembly(""); var type1 = assembly.AddTestClass("type1"); var assemblyInit = assembly.SetAssemblyInit(new Method("assemblyInit",type1)); var method1 = type1.AddTestMethod("method1"); var method2 = type1.AddTestMethod("method2"); var type2 = assembly.AddTestClass("type2"); var method3 = type2.AddTestMethod("method3"); var method4 = type2.AddTestMethod("method4"); var runner = new Runner() { MethodRunners = new List<IMethodRunner> { methodRunner1.Object, methodRunner2.Object }, Assemblies = new List<TestAssembly>() { assembly }, }; var report1 = new SuccessMethodExecutionReport() { Method = method1, ConsoleOutput = "Executed 1" }; var report2 = new SuccessMethodExecutionReport() { Method = method2, ConsoleOutput = "Executed 2" }; var report3 = new SuccessMethodExecutionReport() { Method = method3, ConsoleOutput = "Executed 3" }; var report4 = new SuccessMethodExecutionReport() { Method = method4, ConsoleOutput = "Executed 4" }; var reportForRunner1 = new List<MethodExecutionReport> { report1, report3 }; var reportForRunner2 = new List<MethodExecutionReport> { report2, report4 }; methodRunner1.Setup(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { assemblyInit, method1, method3 })))).Returns(reportForRunner1); methodRunner2.Setup(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { assemblyInit, method2, method4 })))).Returns(reportForRunner2); runner.Run(); var actualReport = runner.Run(); Assert.AreEqual(actualReport.Count(), 4); Assert.IsTrue(actualReport.Contains(report1)); Assert.IsTrue(actualReport.Contains(report2)); Assert.IsTrue(actualReport.Contains(report3)); Assert.IsTrue(actualReport.Contains(report4)); }
public void GivenThereIsTwoTestMethodsInTheSameTestClassAndTwoRunnersThenEachRunnerShouldRunOneOfTheMethods() { var methodRunner1 = new Mock<IMethodRunner>(); var methodRunner2 = new Mock<IMethodRunner>(); var type = new TestAssembly("").AddTestClass(""); TestMethod method1 = type.AddTestMethod("method1"); TestMethod method2 = type.AddTestMethod("method2"); var runner = new Runner() { MethodRunners = new List<IMethodRunner> { methodRunner1.Object, methodRunner2.Object }, Assemblies = new List<TestAssembly>() { type.TestAssembly }, }; var report1 = new SuccessMethodExecutionReport() { Method = method1, ConsoleOutput = "Executed 1" }; var report2 = new SuccessMethodExecutionReport() { Method = method2, ConsoleOutput = "Executed 2" }; var reportForRunner1 = new List<MethodExecutionReport> { report1 }; var reportForRunner2 = new List<MethodExecutionReport> { report2 }; methodRunner1.Setup(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { method1 })))).Returns(reportForRunner1); methodRunner2.Setup(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { method2 })))).Returns(reportForRunner2); var actualReport = runner.Run(); Assert.AreEqual(actualReport.Count(), 2); Assert.IsTrue(actualReport.Contains(report1)); Assert.IsTrue(actualReport.Contains(report2)); }
public void GivenThereIsTwoTestMethodsInTheSameTestClassAndOneRunnerThenItShouldRunTheseMethods() { var methodRunner = new Mock<IMethodRunner>(); var type = new TestAssembly("").AddTestClass(""); TestMethod method1 = type.AddTestMethod("method1"); TestMethod method2 = type.AddTestMethod("method2"); var runner = new Runner() { MethodRunners = new List<IMethodRunner> { methodRunner.Object }, Assemblies = new List<TestAssembly>() { type.TestAssembly }, }; runner.Run(); methodRunner.Verify(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { method1, method2 }))), Times.Once()); var report1 = new SuccessMethodExecutionReport() { Method = method1, ConsoleOutput = "Executed 1" }; var report2 = new SuccessMethodExecutionReport() { Method = method2, ConsoleOutput = "Executed 2" }; var expectedReport = new List<MethodExecutionReport> { report1, report2 }; methodRunner.Setup(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { method1, method2 })))).Returns(expectedReport); var actualReport = runner.Run(); Assert.AreEqual(actualReport.Count(), 2); Assert.IsTrue(actualReport.Contains(report1)); Assert.IsTrue(actualReport.Contains(report2)); }
public void GivenThereIsOnlyOneTestMethodThenTheRunnerShouldRunThatMethod() { var methodRunner = new Mock<IMethodRunner>(); var method = new TestAssembly("").AddTestClass("").AddTestMethod("method1"); var runner = new Runner() { MethodRunners = new List<IMethodRunner> { methodRunner.Object }, Assemblies = new List<TestAssembly>() { method.OwningTestAssembly }, }; var expectedReport = new List<MethodExecutionReport> { new SuccessMethodExecutionReport(){Method = method,ConsoleOutput="Executed"} }; methodRunner.Setup(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.First() == method))).Returns(expectedReport); var actualReport = runner.Run(); Assert.AreEqual(expectedReport[0], actualReport.First()); }
public void GivenThereIsATestClassWithATestInitThenItShouldRunTheTestInitBeforeTheTestMethodAndOnlyForTheTestMethodsInThatTestClass() { var methodRunner1 = new Mock<IMethodRunner>(); var methodRunner2 = new Mock<IMethodRunner>(); var assembly = new TestAssembly(""); var type1 = assembly.AddTestClass("type1"); var testInit1 = type1.AddTestInit("testInit1"); var method1 = type1.AddTestMethod("method1"); var method2 = type1.AddTestMethod("method2"); var type2 = assembly.AddTestClass("type2"); var method3 = type2.AddTestMethod("method3"); var method4 = type2.AddTestMethod("method4"); var runner = new Runner() { MethodRunners = new List<IMethodRunner> { methodRunner1.Object, methodRunner2.Object }, Assemblies = new List<TestAssembly>() { assembly }, }; runner.Run(); methodRunner1.Verify(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { testInit1, method1, method3 }))), Times.Once()); methodRunner2.Verify(m => m.Invoke(It.Is<IEnumerable<Method>>(e => e.SequenceEqual(new List<Method> { testInit1, method2, method4 }))), Times.Once()); }