public void Export(CoverageContext coverageContext, string reportPath)
{
var coverageSession = ConvertTo(coverageContext);
new CoverageStats().Consolidate(coverageSession);
GenerateReport(coverageSession, reportPath);
}
public override void Handle(CoverageContext coverageContext, AssemblyDefinition assemblyDefinition)
{
foreach (var module in assemblyDefinition.Modules)
{
coverageContext.AddModule(ProcessModule(module));
}
base.Handle(coverageContext, assemblyDefinition);
}
public void Execute_DotNet_Test_Command_Line()
{
var dotNetTestRunner = new DotNetTestRunner(_rpcServerMock, _process);
var coverageContext = new CoverageContext();
var testProjectOutputPath = "bin/debug";
dotNetTestRunner.Run(coverageContext, testProjectOutputPath);
_process.Received(1).Execute(Arg.Is("dotnet"), Arg.Is("test --no-build"), Arg.Any <string>());
}
public void Add_AssemblyModules_Onto_CoverageContext()
{
var analyser = new StaticCodeAnalyser();
var coverageContext = new CoverageContext();
var assemblyDefinition = AssemblyDefinition.CreateAssembly(new AssemblyNameDefinition("TestAssembly.dll", new Version(1, 0)), "TestAssembly.dll", ModuleKind.Dll);
analyser.Handle(coverageContext, assemblyDefinition);
Assert.Equal("TestAssembly", coverageContext.Modules.First().ModuleName);
}
public void Run(string testProjectOutputPath, string reportPath)
{
if (String.IsNullOrEmpty(reportPath))
{
reportPath = "coverage.xml";
}
var coverageContext = new CoverageContext();
_instrumentator.ProcessAssembliesInFolder(coverageContext, testProjectOutputPath);
_testRunner.Run(coverageContext, testProjectOutputPath);
_coverageReport.Export(coverageContext, reportPath);
}
public void Start_Rpc_Server_Before_Running_Tests()
{
var dotNetTestRunner = new DotNetTestRunner(_rpcServerMock, _process);
var testProjectOutputPath = "bin/debug";
var coverageContext = new CoverageContext();
dotNetTestRunner.Run(coverageContext, testProjectOutputPath);
Received.InOrder(() =>
{
_rpcServerMock.Start(Arg.Any <CoverageContext>());
_process.Execute(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <string>());
});
}
private static CoverageSession ConvertTo(CoverageContext coverageContext)
{
var coverageSession = new CoverageSession();
coverageSession.Modules = coverageContext.Modules.Select(x => new OpenCover.Framework.Model.Module
{
ModuleHash = x.ModuleHash,
ModuleName = x.ModuleName,
ModulePath = x.ModulePath,
ModuleTime = x.ModuleTime,
Files = x.FileReferences.Select(f => new OpenCover.Framework.Model.File {
FullPath = f.FilePath,
UniqueId = Convert.ToUInt32(f.UniqueId)
}).ToArray(),
Classes = x.Types.Select(t => new Class
{
FullName = t.FullName,
Methods = t.Methods.Select(m => new OpenCover.Framework.Model.Method
{
FullName = m.FullName,
IsGetter = m.IsGetter,
IsConstructor = m.IsConstructor,
IsSetter = m.IsSetter,
IsStatic = m.IsStatic,
Visited = m.Executed,
SequencePoints = m.SequencePoints == null ? new SequencePoint[] { } : m.SequencePoints.Select(s => new OpenCover.Framework.Model.SequencePoint
{
EndLine = s.EndLine,
Offset = s.Offset,
Ordinal = s.Ordinal,
StartLine = s.StartLine,
StartColumn = s.StartColumn,
EndColumn = s.EndColumn,
VisitCount = s.ExecutionCount,
FileId = Convert.ToUInt32(s.FileReference.UniqueId)
}).ToArray(),
BranchPoints = m.BranchPoints == null ? new BranchPoint [] {} : m.BranchPoints.Select(b => new OpenCover.Framework.Model.BranchPoint
{
Ordinal = b.Ordinal,
Offset = b.Offset,
EndOffset = b.EndOffset,
OffsetPoints = b.OffsetPoints,
FileId = Convert.ToUInt32(b.FileReference.UniqueId)
}).ToArray()
}).ToArray()
}).ToArray()
})
.ToArray();
return(coverageSession);
}
public void Run(CoverageContext coverageContext, string testProjectOutputPath)
{
var testProjectPath = GetTestProjectPath(testProjectOutputPath);
_rpcServer.Start(coverageContext);
/*
* It is important that the --no-build flag is used, otherwise dotnet-test will run a new build of the project
* which will overwrite the assembly files that were instrumented.
*/
_process.Execute("dotnet", "test --no-build", testProjectPath);
_rpcServer.Stop();
}
public override void Handle(CoverageContext coverageContext, AssemblyDefinition assemblyDefinition)
{
_logger.LogInformation($"Instrumentating Assembly: {assemblyDefinition.FullName}");
foreach (var module in assemblyDefinition.Modules)
{
if (!IsAssemblyInstrumented(assemblyDefinition))
{
ProcessModule(module);
MarkAssemblyAsInstrumented(assemblyDefinition);
}
else
{
_logger.LogInformation($"Skipping {assemblyDefinition.FullName}, assembly is already instrumented.");
}
}
base.Handle(coverageContext, assemblyDefinition);
}
public void Disregard_Lack_Of_Trailing_slash()
{
var dotNetTestRunner = new DotNetTestRunner(_rpcServerMock, _process);
var coverageContext = new CoverageContext();
string testProjectOutputPath;
string expectedProjectName;
if (IsWindows)
{
testProjectOutputPath = @"c:\git\project\src\projectname\bin\debug\netcoreapp1.1";
expectedProjectName = @"c:\git\project\src\projectname";
}
else
{
testProjectOutputPath = @"/home/user/git/project/src/projectname/bin/debug/netcoreapp1.1";
expectedProjectName = @"/home/user/git/project/src/projectname";
}
dotNetTestRunner.Run(coverageContext, testProjectOutputPath);
_process.Received(1).Execute(Arg.Any <string>(), Arg.Any <string>(), Arg.Is(expectedProjectName));
}
public void ProcessAssemblies(CoverageContext coverageContext, string[] assemblyPaths)
{
foreach (var assemblyPath in assemblyPaths)
{
_logger.LogInformation($"Processing {assemblyPath}...");
string reason;
if (AssemblyShouldBeSkipped(assemblyPath, out reason))
{
_logger.LogInformation($"Skipping {assemblyPath}: {reason}.");
continue;
}
using (var assembly = LoadAssembly(assemblyPath))
{
_assemblyInstrumentationHandler.Handle(coverageContext, assembly);
assembly.Write(new WriterParameters {
WriteSymbols = true
});
}
}
}
public ExecutionTrackerServer(CoverageContext coverageContext, ILogger logger = null)
{
_logger = logger;
_coverageContext = coverageContext;
}
public virtual void Handle(CoverageContext coverageContext, AssemblyDefinition assemblyDefinition)
{
_sucessorHandler?.Handle(coverageContext, assemblyDefinition);
}
public void ProcessAssembliesInFolder(CoverageContext coverageContext, string folderPath)
{
var assemblyPaths = Directory.GetFiles(folderPath, "*.dll");
ProcessAssemblies(coverageContext, assemblyPaths);
}
public void Start(CoverageContext coverageContext)
{
_logger.LogInformation($"Starting RPC server at {ServerAddress}:{ServerPort}.");
_server.Services.Add(ExecutionTracker.BindService(new ExecutionTrackerServer(coverageContext)));
_server.Start();
}