public void RunAllTestsInDocument_ShouldExtractAllTestCases()
{
// arrange
var project = CreateProject("SampleTestsProject");
var semanticModel = Substitute.For<ISemanticModel>();
var testNode = CSharpSyntaxTree.ParseText("[TestFixture]class HelloWorldTests{" +
" [Test] public void TestMethod()" +
"{}" +
"}");
var testClass = testNode.GetRoot().GetClassDeclarationSyntax();
var fixtureDetails = new TestFixtureDetails();
var testCase = new TestCase(fixtureDetails) { SyntaxNode = testClass.GetPublicMethods().Single() };
fixtureDetails.Cases.Add(testCase);
_testExtractorMock.GetTestClasses(Arg.Any<CSharpSyntaxNode>())
.Returns(new[] { testClass });
_testExtractorMock.GetTestFixtureDetails(Arg.Any<ClassDeclarationSyntax>(), Arg.Any<ISemanticModel>()).Returns(fixtureDetails);
var rewrittenDocument = new RewrittenDocument(testNode, null, false);
// act
_sut.RunAllTestsInDocument(rewrittenDocument, semanticModel, project, new string[0]);
// assert
_testExtractorMock.Received(1).GetTestFixtureDetails(testClass, semanticModel);
}
public void CalculateForAllTests_Should_CompileProvidedDocuments()
{
// arrange
var rewrittenItemsByProject = new Dictionary<Project, List<RewrittenDocument>>();
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("foo1.dll", LanguageNames.CSharp);
RewriteResult rewriteResult = new RewriteResult(rewrittenItemsByProject);
var rewrittenTree = CSharpSyntaxTree.ParseText("");
var rewrittenDocument1 = new RewrittenDocument( rewrittenTree, null, false);
rewriteResult.Items[project1] = new List<RewrittenDocument>() { rewrittenDocument1 };
var compiledItem = Substitute.For<ICompiledItem>();
compiledItem.Project.Returns(project1);
_compiledAllItems.Add(compiledItem);
// act
_sut.CalculateForAllTests(rewriteResult);
// assert
_compilerMock.Received(1).Compile
(Arg.Is<IEnumerable<CompilationItem>>(x => x.First().SyntaxTrees[0] ==
rewriteResult.ToCompilationItems().First().SyntaxTrees[0]));
}
public void RunAllTestsInDocument_ShouldExtractAllProjectReferences_And_PassItTo_TestSandbox()
{
// arrange
var project = CreateProject("SampleTestsProject");
string[] allProjectReferences = { "A" };
_solutionExplorerMock.GetAllProjectReferences(project.Name).Returns(allProjectReferences);
var testNode = CSharpSyntaxTree.ParseText("[TestFixture]class HelloWorldTests{" +
" [Test] public void TestMethod()" +
"{}" +
"}");
var testClass = testNode.GetRoot().GetClassDeclarationSyntax();
var fixtureDetails = new TestFixtureDetails();
var testCase = new TestCase(fixtureDetails) { SyntaxNode = testClass.GetPublicMethods().Single() };
fixtureDetails.Cases.Add(testCase);
_testExtractorMock.GetTestClasses(Arg.Any<CSharpSyntaxNode>())
.Returns(new[] { testClass });
_testExtractorMock.GetTestFixtureDetails(testClass, Arg.Any<ISemanticModel>()).Returns(fixtureDetails);
var rewrittenDocument = new RewrittenDocument(testNode, null, false);
// act
_sut.RunAllTestsInDocument(rewrittenDocument, null, project, new string[0]);
// assert
_testExecutorEngineMock.Received(1).
RunTestFixture(Arg.Is<string[]>(x => x[0] == allProjectReferences[0]), Arg.Any<TestFixtureExecutionScriptParameters>());
}
public void GetReferencedTests_Should_ReturnDocumentContainingTest_When_CoverageWasBeforeCalculated()
{
// arrange
var tree = CSharpSyntaxTree.ParseText("public class MathHelper" +
"{ public int Divide(int a,b) {return a/b;}}");
var testTree = CSharpSyntaxTree.ParseText(@"class MathHelperTests{ public void DivideTest();}}");
var lineCoverage = new LineCoverage
{
NodePath = "Math.MathHelper.MathHelper.Divide",
TestDocumentPath = @"c:\\MathHelperTests.cs",
TestPath = "MathTests.MathHelperTests.MathHelperTests.DivideTest"
};
_coverageStoreMock.ReadAll().Returns(new[] { lineCoverage });
_solutionExplorerMock.OpenFile(lineCoverage.TestDocumentPath).Returns(testTree);
var document = new RewrittenDocument( tree, @"c:\MathHelper.cs",false);
// act
RewrittenDocument[] output = _sut.GetReferencedTests(document, "Math");
// assert
Assert.That(output.Length,Is.EqualTo(1));
Assert.That(output[0].DocumentPath,Is.EqualTo(lineCoverage.TestDocumentPath));
Assert.That(output[0].SyntaxTree, Is.EqualTo(testTree));
}
public void CalculateForAllTests_Should_Return_OneCoverage_From_AllTests_When_There_IsOneProject_And_OneLineCoverage()
{
// arrange
var rewrittenItemsByProject = new Dictionary<Project, List<RewrittenDocument>>();
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("foo1.dll", LanguageNames.CSharp);
RewriteResult rewriteResult = new RewriteResult(rewrittenItemsByProject);
var rewrittenTree = CSharpSyntaxTree.ParseText("");
var rewrittenDocument1 = new RewrittenDocument( rewrittenTree, null, true);
rewriteResult.Items[project1] = new List<RewrittenDocument>() { rewrittenDocument1 };
var semanticModel = Substitute.For<ISemanticModel>();
var compiledItem = Substitute.For<ICompiledItem>();
string assembly = "assembly path";
compiledItem.Project.Returns(project1);
compiledItem.DllPath.Returns(assembly);
compiledItem.GetSemanticModel(rewrittenDocument1.SyntaxTree).Returns(semanticModel);
_compiledAllItems.Add(compiledItem);
var expectedLineCoverage = new[] {new LineCoverage()};
_testRunnerMock.RunAllTestsInDocument(rewrittenDocument1,
semanticModel,
project1,
Arg.Is<string[]>(x=>assembly==x[0]))
.Returns(expectedLineCoverage);
// act
LineCoverage[] output = _sut.CalculateForAllTests(rewriteResult);
// assert
Assert.That(output, Is.EquivalentTo(expectedLineCoverage));
}
public LineCoverage[] RunTest(Project project,
RewrittenDocument rewrittenDocument,
MethodDeclarationSyntax method,
ISemanticModel semanticModel,
string[] rewrittenAssemblies)
{
var testClass = method.GetParentClass();
var rewrittenTestClass =
rewrittenDocument.SyntaxTree
.GetRoot()
.DescendantNodes()
.OfType<ClassDeclarationSyntax>().First(x => x.Identifier.ToString() == testClass.Identifier.ToString());
var fixtureDetails = _testsExtractor.GetTestFixtureDetails(rewrittenTestClass, semanticModel);
var allReferences = _solutionExplorer.GetAllProjectReferences(project.Name);
fixtureDetails.Cases.RemoveAll(x => x.MethodName != method.Identifier.ToString());
if (fixtureDetails.Cases.Count == 0)
return null;
var compiledTestInfo = new CompiledTestFixtureInfo
{
AllReferences = allReferences.Union(rewrittenAssemblies).ToArray(),
TestDocumentPath = rewrittenDocument.DocumentPath,
SemanticModel = semanticModel
};
var coverage = RunTestFixture(fixtureDetails, compiledTestInfo, project.Name);
return coverage;
}
public LineCoverage[] RunAllTestsInDocument(RewrittenDocument rewrittenDocument,
ISemanticModel semanticModel,
Project project,
string[] rewrittenAssemblies)
{
var allReferences = _solutionExplorer.GetAllProjectReferences(project.Name);
var compiledTestInfo = new CompiledTestFixtureInfo
{
AllReferences = allReferences.Union(rewrittenAssemblies).ToArray(),
TestDocumentPath = rewrittenDocument.DocumentPath,
SemanticModel = semanticModel
};
var coverage = new List<LineCoverage>();
var testClasses = _testsExtractor.GetTestClasses(rewrittenDocument.SyntaxTree.GetRoot());
if (testClasses.Length == 0)
return null;
foreach (ClassDeclarationSyntax testClass in testClasses)
{
compiledTestInfo.TestClass = testClass;
var partialCoverage = RunAllTestsInFixture(compiledTestInfo, project.Name);
coverage.AddRange(partialCoverage);
}
return coverage.ToArray();
}
public LineCoverage[] CalculateForDocument(Project project, RewrittenDocument rewrittenDocument)
{
ICompiledItem[] newCompiledItems;
string[] allAssemblies = CompileDocument(project, rewrittenDocument, out newCompiledItems);
ISemanticModel semanticModel = newCompiledItems[0].GetSemanticModel(rewrittenDocument.SyntaxTree);
LineCoverage[] fullCoverage = _testRunner.RunAllTestsInDocument(rewrittenDocument, semanticModel, project, allAssemblies);
if (fullCoverage == null)
fullCoverage = CalculateCoverageForReferencedTests(project, rewrittenDocument, allAssemblies);
return fullCoverage.ToArray();
}
public LineCoverage[] CalculateForMethod(Project project, RewrittenDocument rewrittenDocument, MethodDeclarationSyntax method)
{
ICompiledItem[] newCompiledItems;
string[] rewrittenAssemblies = CompileDocument(project, rewrittenDocument, out newCompiledItems);
ISemanticModel semanticModel = newCompiledItems[0].GetSemanticModel(rewrittenDocument.SyntaxTree);
LineCoverage[] fullCoverage = _testRunner.RunTest(project,
rewrittenDocument,
method,
semanticModel, rewrittenAssemblies);
if (fullCoverage == null)
fullCoverage = CalculateCoverageForReferencedTests(project, rewrittenDocument, rewrittenAssemblies);
return fullCoverage.ToArray();
}
public RewrittenDocument[] GetReferencedTests(RewrittenDocument document, string projectName)
{
var methods = document.SyntaxTree.GetRoot().GetPublicMethods();
string documentName = Path.GetFileNameWithoutExtension(document.DocumentPath);
var currentCoverage = _coverageStore.ReadAll();
var rewrittenDocuments = new List<RewrittenDocument>();
foreach (var method in methods)
{
string path = NodePathBuilder.BuildPath(method, documentName, projectName);
foreach (var docCoverage in currentCoverage.Where(x => x.NodePath == path))
{
if (rewrittenDocuments.All(x => x.DocumentPath != docCoverage.TestDocumentPath))
{
SyntaxTree testRoot = _solutionExplorer.OpenFile(docCoverage.TestDocumentPath);
var rewrittenDocument = new RewrittenDocument(testRoot, docCoverage.TestDocumentPath, false);
rewrittenDocuments.Add(rewrittenDocument);
}
}
}
return rewrittenDocuments.ToArray();
}
public void RunAllTestsInDocument_ShouldExtractAllTestClasses()
{
// arrange
var project = CreateProject("SampleTestsProject");
var testNode = CSharpSyntaxTree.ParseText("[TestFixture]class HelloWorldTests{" +
" [Test] public void TestMethod()" +
"{}" +
"}");
var rewrittenDocument = new RewrittenDocument(testNode, null, false);
// act
_sut.RunAllTestsInDocument(rewrittenDocument, null, project, new string[0]);
// assert
_testExtractorMock.Received(1).GetTestClasses(testNode.GetRoot());
}
public void RunAllTestsInDocument_ShouldReturn_One_Line_Coverage_When_ThereIsOneClass_And_OneTestCase_And_ItContains_One_LineCoverage()
{
// arrange
var testNode = CSharpSyntaxTree.ParseText("[TestFixture]class HelloWorldTests{" +
" [Test] public void TestMethod()" +
"{}" +
"}");
var testClass = testNode.GetRoot().GetClassDeclarationSyntax();
var fixtureDetails = new TestFixtureDetails();
var testCase = new TestCase(fixtureDetails) { SyntaxNode = testClass.GetPublicMethods().Single(), MethodName = "TestMethod" };
fixtureDetails.Cases.Add(testCase);
_testExtractorMock.GetTestClasses(Arg.Any<CSharpSyntaxNode>())
.Returns(new[] { testClass });
_testExtractorMock.GetTestFixtureDetails(testClass, Arg.Any<ISemanticModel>()).Returns(fixtureDetails);
var testRunResultMock = Substitute.For<ITestRunResult>();
testRunResultMock.TestName.Returns("TestMethod");
var expectedLineCoverage = new[] { new LineCoverage() };
testRunResultMock.GetCoverage(Arg.Any<SyntaxNode>(), Arg.Any<string>(),
Arg.Any<string>())
.Returns(expectedLineCoverage);
_testExecutorEngineMock.RunTestFixture(Arg.Any<string[]>(), Arg.Any<TestFixtureExecutionScriptParameters>()).
Returns(new[] { testRunResultMock });
var project = CreateProject("SampleTestsProject");
var rewrittenDocument = new RewrittenDocument(testNode, null, false);
// act
LineCoverage[] output = _sut.RunAllTestsInDocument(rewrittenDocument, null, project, new string[0]);
// assert
Assert.That(output, Is.SameAs(output));
}
public void CalculateForAllTests_Should_Return_TwoLinesCoverage_From_AllTests_When_There_AreTwoProjects_And_EachProjectHasOneLineCoverage()
{
// arrange
var rewrittenItemsByProject = new Dictionary<Project, List<RewrittenDocument>>();
var workspace = new AdhocWorkspace();
var project1 = workspace.AddProject("foo1.dll", LanguageNames.CSharp);
var project2 = workspace.AddProject("foo2.dll", LanguageNames.CSharp);
RewriteResult rewriteResult = new RewriteResult(rewrittenItemsByProject);
var rewrittenTree = CSharpSyntaxTree.ParseText("");
var rewrittenDocument1 = new RewrittenDocument(rewrittenTree, null, true);
rewriteResult.Items[project1] = new List<RewrittenDocument>() { rewrittenDocument1 };
rewriteResult.Items[project2] = new List<RewrittenDocument>() { rewrittenDocument1 };
var compiledItem1 = Substitute.For<ICompiledItem>();
var compiledItem2 = Substitute.For<ICompiledItem>();
compiledItem1.Project.Returns(project1);
compiledItem2.Project.Returns(project2);
_compiledAllItems.Add(compiledItem1);
_compiledAllItems.Add(compiledItem2);
var expectedLineCoverage = new[] { new LineCoverage() };
_testRunnerMock.RunAllTestsInDocument(rewrittenDocument1,
Arg.Any<ISemanticModel>(),
project1,
Arg.Any<string[]>())
.Returns(expectedLineCoverage);
_testRunnerMock.RunAllTestsInDocument(rewrittenDocument1,
Arg.Any<ISemanticModel>(),
project2,
Arg.Any<string[]>())
.Returns(expectedLineCoverage);
// act
LineCoverage[] output = _sut.CalculateForAllTests(rewriteResult);
// assert
Assert.That(output.Length, Is.EqualTo(2));
}
public void CalculateForDocument_Should_Execute_TestsInReferencedTestDocuments_When_ProvidedDocumentIsNotTestDocument()
{
// arrange
var rewrittenItemsByProject = new Dictionary<Project, List<RewrittenDocument>>();
var workspace = new AdhocWorkspace();
var testProject = workspace.AddProject("TestProject.dll", LanguageNames.CSharp);
var businessLogicProject = workspace.AddProject("BusinessLogicProject.dll", LanguageNames.CSharp);
RewriteResult rewriteResult = new RewriteResult(rewrittenItemsByProject);
var rewrittenTree = CSharpSyntaxTree.ParseText("");
var businessLogicDocument = new RewrittenDocument( rewrittenTree, null, false);
var testDocument = new RewrittenDocument( rewrittenTree, null, false);
rewriteResult.Items[businessLogicProject] = new List<RewrittenDocument>() { businessLogicDocument };
rewriteResult.Items[testProject] = new List<RewrittenDocument>() { testDocument };
var compiledItem1 = Substitute.For<ICompiledItem>();
compiledItem1.Project.Returns(testProject);
_compiledSingleProjectItems.Add(compiledItem1);
_testRunnerMock.RunAllTestsInDocument(businessLogicDocument,
Arg.Any<ISemanticModel>(),
businessLogicProject,
Arg.Any<string[]>())
.Returns((LineCoverage[])null);
var expectedLineCoverage = new[] { new LineCoverage() };
_testRunnerMock.RunAllTestsInDocument(testDocument,
Arg.Any<ISemanticModel>(),
testProject,
Arg.Any<string[]>())
.Returns(expectedLineCoverage);
_testExplorerMock.GetReferencedTests(businessLogicDocument, businessLogicProject.Name)
.Returns(new[] {testDocument});
_solutionExplorerMock.GetProjectByDocument(testDocument.DocumentPath).Returns(testProject);
// act
LineCoverage[] output = _sut.CalculateForDocument(businessLogicProject, businessLogicDocument);
// assert
Assert.That(output, Is.EquivalentTo(expectedLineCoverage));
}
private LineCoverage[] CalculateCoverageForReferencedTests(Project project,
RewrittenDocument rewrittenDocument,
string[] allAssemblies)
{
List<LineCoverage> finalCoverage = new List<LineCoverage>();
var referencedTests = _testExplorer.GetReferencedTests(rewrittenDocument, project.Name);
foreach (RewrittenDocument referencedTest in referencedTests)
{
var semanticModel = _testExplorer.SolutionExplorer.GetSemanticModelByDocument(referencedTest.DocumentPath);
var testProject = _testExplorer.SolutionExplorer.GetProjectByDocument(referencedTest.DocumentPath);
var coverage = _testRunner.RunAllTestsInDocument(referencedTest, semanticModel, testProject, allAssemblies);
finalCoverage.AddRange(coverage);
}
return finalCoverage.ToArray();
}
private string[] CompileDocument(Project project, RewrittenDocument rewrittenDocument, out ICompiledItem[] newItems)
{
List<string> assemblies = _testExplorer.SolutionExplorer.GetCompiledAssemblies(project.Name).ToList();
SyntaxTree[] projectTrees = _testExplorer.SolutionExplorer.LoadRewrittenProjectSyntaxTrees(project, rewrittenDocument.DocumentPath).ToArray();
var allProjectTrees = projectTrees.Union(new[] { rewrittenDocument.SyntaxTree }).ToArray();
var compiledItems = _compiler.Compile(new CompilationItem(project, allProjectTrees), assemblies);
assemblies.AddRange(compiledItems.Select(x => x.DllPath));
newItems = compiledItems;
return assemblies.ToArray();
}