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