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 LoadCurrentCoverage_Should_ClearPreviousCoverage_BeforeLoadingDataFromStore()
{
// arrange
var doc1Coverage = new LineCoverage { DocumentPath = "doc1.cs" };
_coverageStoreMock.ReadAll().Returns(new[] { doc1Coverage });
_sut.SolutionCoverageByDocument.Add("oldDocument.cs", new List<LineCoverage>());
// act
_sut.LoadCurrentCoverage();
// assert
Assert.That(_sut.SolutionCoverageByDocument.Count, Is.EqualTo(1));
Assert.That(_sut.SolutionCoverageByDocument.Keys.First(), Is.EqualTo("doc1.cs"));
}
public static LineCoverage EvaluateAuditVariable(
AuditVariablePlaceholder variableName,
SyntaxNode testMethodNode,
string testProjectName,
string testDocName)
{
LineCoverage lineCoverage = new LineCoverage
{
TestPath = NodePathBuilder.BuildPath(testMethodNode, testDocName, testProjectName),
NodePath = variableName.NodePath,
Span = variableName.SpanStart
};
return lineCoverage;
}
public void LoadCurrentCoverage_Should_LoadDataForAllDocuments()
{
// arrange
var doc1Coverage = new LineCoverage { DocumentPath = "doc1.cs" };
var doc2Coverage = new LineCoverage { DocumentPath = "doc2.cs" };
_coverageStoreMock.ReadAll().Returns(new[] { doc1Coverage, doc2Coverage });
// act
_sut.LoadCurrentCoverage();
// assert
Assert.That(_sut.SolutionCoverageByDocument.Count, Is.EqualTo(2));
Assert.That(_sut.SolutionCoverageByDocument["doc1.cs"].Count, Is.EqualTo(1));
Assert.That(_sut.SolutionCoverageByDocument["doc2.cs"].Count, Is.EqualTo(1));
Assert.That(_sut.SolutionCoverageByDocument["doc1.cs"].First(), Is.EqualTo(doc1Coverage));
Assert.That(_sut.SolutionCoverageByDocument["doc2.cs"].First(), Is.EqualTo(doc2Coverage));
}
public async Task CalculateForMethod_Should_RemoveOldCoverageValues()
{
// arrange
const string code = "class MathHelperTests{" +
" [Test] public void Test() " +
"{}" +
"}";
var tree = CSharpSyntaxTree.ParseText(code);
var method = tree.GetRoot().GetPublicMethods().First();
const string testDocumentPath = "MathHelperTests.cs";
var oldTestLineCoverage = new LineCoverage();
oldTestLineCoverage.DocumentPath = testDocumentPath;
oldTestLineCoverage.NodePath = "CurrentProject.MathHelperTests.Test";
oldTestLineCoverage.TestPath = "CurrentProject.MathHelperTests.Test";
var newTestLineCoverage = new LineCoverage();
newTestLineCoverage.DocumentPath = testDocumentPath;
newTestLineCoverage.NodePath = "CurrentProject.MathHelperTests.Test";
newTestLineCoverage.TestPath = "CurrentProject.MathHelperTests.Test";
_sut.SolutionCoverageByDocument.Add(testDocumentPath, new List<LineCoverage>() { oldTestLineCoverage });
_solutionCoverageEngineMock.CalculateForMethod(Arg.Any<string>(), Arg.Any<MethodDeclarationSyntax>()).
Returns(new CoverageResult(new[] { newTestLineCoverage }));
// act
await _sut.CalculateForSelectedMethodAsync("CurrentProject", method);
// assert
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath].Count, Is.EqualTo(1));
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath].First(), Is.EqualTo(newTestLineCoverage));
}
public async Task CalculateForDocument_ShouldClearAllCoverage_When_CompilationExceptionIsThrown()
{
// arrange
const string documentPath = "EmployeeRepository.cs";
var lineCoverage = new LineCoverage();
lineCoverage.TestPath = lineCoverage.NodePath = "CurrentProject.MathHelperTests";
_sut.SolutionCoverageByDocument.Add(documentPath, new List<LineCoverage>() { lineCoverage });
_solutionCoverageEngineMock.CalculateForDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>()).
Returns(new CoverageResult(new LineCoverage[0]));
// act
await _sut.CalculateForDocumentAsync("CurrentProject", documentPath, string.Empty);
// assert
Assert.That(_sut.SolutionCoverageByDocument[documentPath].Count, Is.EqualTo(1));
}
public async Task CalculateForAllDocuments_ShouldNot_ClearCoverageOfUnrelatedDocuments()
{
// arrange
var testLineCoverage = new LineCoverage();
testLineCoverage.NodePath = "CurrentProject.MathHelperTests";
testLineCoverage.TestPath = "CurrentProject.MathHelperTests";
var codeLineCoverage = new LineCoverage();
codeLineCoverage.NodePath = "CurrentProject.MathHelper";
codeLineCoverage.TestPath = "CurrentProject.MathHelperTests";
_sut.SolutionCoverageByDocument.Add("doc1.xml", new List<LineCoverage>() { testLineCoverage, codeLineCoverage });
_solutionCoverageEngineMock.CalculateForAllDocumentsAsync().
Throws(new TestCoverageCompilationException(new string[0]));
// act
await _sut.CalculateForAllDocumentsAsync();
// assert
Assert.That(_sut.SolutionCoverageByDocument.Count, Is.EqualTo(0));
}
public async Task CalculateForDocument_Should_PopulateCoverageWithNewData_When_NewDataIsAvailable()
{
// arrange
const string newDocumentPath = "MathHelper.cs";
var coverage = new LineCoverage { DocumentPath = newDocumentPath };
_solutionCoverageEngineMock.CalculateForDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>()).
Returns(new CoverageResult(new[] { coverage }));
// act
await _sut.CalculateForDocumentAsync("CurrentProject", "MathHelperTests.cs", string.Empty);
// assert
Assert.That(_sut.SolutionCoverageByDocument[newDocumentPath].Count, Is.EqualTo(1));
Assert.That(_sut.SolutionCoverageByDocument[newDocumentPath][0], Is.EqualTo(coverage));
}
public async Task CalculateForDocument_Should_RemoveOldCoverageValues()
{
// arrange
const string testDocumentPath = "MathHelperTests.cs";
var oldTestLineCoverage = new LineCoverage();
oldTestLineCoverage.DocumentPath = testDocumentPath;
oldTestLineCoverage.NodePath = "CurrentProject.MathHelperTests";
oldTestLineCoverage.TestPath = "CurrentProject.MathHelperTests";
var newTestLineCoverage = new LineCoverage();
newTestLineCoverage.DocumentPath = testDocumentPath;
newTestLineCoverage.NodePath = "CurrentProject.MathHelperTests";
newTestLineCoverage.TestPath = "CurrentProject.MathHelperTests";
_sut.SolutionCoverageByDocument.Add(testDocumentPath, new List<LineCoverage>() { oldTestLineCoverage });
_solutionCoverageEngineMock.CalculateForDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>()).
Returns(new CoverageResult(new[] { newTestLineCoverage }));
// act
await _sut.CalculateForDocumentAsync("CurrentProject", testDocumentPath, string.Empty);
// assert
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath].Count, Is.EqualTo(1));
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath].First(), Is.EqualTo(newTestLineCoverage));
}
public async Task When_CalculateForMethod_Fails_Should_MarkCoverageAsFaileddOnlyFromExecutedPath()
{
// arrange
const string code = "class MathHelperTests{" +
" [Test] public void Test() " +
"{}" +
" [Test] public void Test2() " +
"{}" +
"}";
var tree = CSharpSyntaxTree.ParseText(code);
var method = tree.GetRoot().GetPublicMethods()[1];
const string testDocumentPath = "MathHelperTests.cs";
var oldTestLineCoverage1 = new LineCoverage();
oldTestLineCoverage1.DocumentPath = testDocumentPath;
oldTestLineCoverage1.NodePath = "CurrentProject..MathHelperTests.AnotherTest";
oldTestLineCoverage1.TestPath = "CurrentProject..MathHelperTests.AnotherTest";
var coverageToBeRecalculated = new LineCoverage();
coverageToBeRecalculated.DocumentPath = testDocumentPath;
coverageToBeRecalculated.NodePath = "CurrentProject..MathHelperTests.Test2";
coverageToBeRecalculated.TestPath = "CurrentProject..MathHelperTests.Test2";
_sut.SolutionCoverageByDocument.Add(testDocumentPath, new List<LineCoverage>() { oldTestLineCoverage1, coverageToBeRecalculated });
_solutionCoverageEngineMock.CalculateForMethod(Arg.Any<string>(), Arg.Any<MethodDeclarationSyntax>()).
Throws(new TestCoverageCompilationException(new string[1]));
// act
await _sut.CalculateForSelectedMethodAsync("CurrentProject", method);
// assert
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath].Count, Is.EqualTo(2));
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath][0], Is.EqualTo(oldTestLineCoverage1));
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath][1].NodePath, Is.EqualTo(coverageToBeRecalculated.NodePath));
Assert.That(_sut.SolutionCoverageByDocument[testDocumentPath][1].TestPath, Is.EqualTo(coverageToBeRecalculated.TestPath));
Assert.IsFalse(_sut.SolutionCoverageByDocument[testDocumentPath][1].IsSuccess);
Assert.IsNotNull(_sut.SolutionCoverageByDocument[testDocumentPath][1].ErrorMessage);
}
private void InsertLineCoverage(SqlCeConnection connection, LineCoverage[] coverage)
{
using (DataTable table = new DataTable())
{
table.Columns.Add("NodePath");
table.Columns.Add("TestPath");
table.Columns.Add("DocumentPath");
table.Columns.Add("TestDocumentPath");
table.Columns.Add("Span");
table.Columns.Add("IsSuccess");
table.Columns.Add("ErrorMessage");
foreach (var lineCoverage in coverage)
{
DataRow row = table.NewRow();
row["NodePath"] = lineCoverage.NodePath;
row["TestPath"] = lineCoverage.TestPath;
row["DocumentPath"] = lineCoverage.DocumentPath;
row["TestDocumentPath"] = lineCoverage.TestDocumentPath;
row["Span"] = lineCoverage.Span;
row["IsSuccess"] = lineCoverage.IsSuccess;
row["ErrorMessage"] = lineCoverage.ErrorMessage.Truncate(4000);
table.Rows.Add(row);
}
DoBulkCopy(connection, new DataTableReader(table));
}
}
public CoverageResult(LineCoverage[] coverage)
{
CoverageByDocument = coverage.
GroupBy(x => x.DocumentPath).
ToDictionary(x => x.Key, x => x.ToArray());
}
