Merge pull request #11 from ademanuele/feature/runSettingsSupport

Feature/run settings support

Author: ademanuele

README.md

@@ -27,11 +27,14 @@ You can access the Coverage pad through `View -> Pads -> Coverage`.
 Select any test project that is currently open in the workspace using the dropdown menu and hit `Gather Coverage`.
 Your test project should start running. When complete, line and branch coverage results for each covered project are shown on the pad as well as in margins for any editors that you have open.
 
-## Planned Features
+### Configuring Coverage Collection
+This extension supports most of the coverage configuration options currently provided by coverlet.
 
-- Keyboard shortcuts
-- Configurable editor margin colors
-- Coverage graphs
+These can be set by creating a file with the extension `.runsettings` in the directory alongside your solution file.
+
+You can use this [sample runsettings file](doc/example.runsettings) as a starting point.
+
+More info can be found on [coverlet's runsettings documentation.](https://github.com/coverlet-coverage/coverlet/blob/master/Documentation/VSTestIntegration.md#advanced-options-supported-via-runsettings)
 
 ## Reporting Issues
 
@@ -53,7 +56,6 @@ If you like this tool and would like to support its development, you can...
 
 Big thanks to the [coverlet](https://github.com/tonerdo/coverlet) project, which made this extension possible.
 
-
 Big thanks to [David Karlas](https://developercommunity.visualstudio.com/users/25964/06b25657-7e73-4eef-bfae-8a6c57e7e6c9.html) for resolving an [issue](https://developercommunity.visualstudio.com/content/problem/907691/unable-to-create-custom-vs-for-mac-editor-margin.html) with the editor margin functionality.
 
 ## License

VSMac-CodeCoverage/VSMac-CodeCoverage/Coverage/CoverageResultsRepository.cs

@@ -37,8 +37,8 @@ public ICoverageResults ResultsFor(Project testProject, ConfigurationSelector co
 
       string resultsFilePath = CoverageFilePathForProject(testProject, configuration);
       if (!File.Exists(resultsFilePath)) return null;
-      using (var stream = new FileStream(resultsFilePath, FileMode.Open))
-        return parser.ParseFrom(stream);
+      using FileStream stream = new FileStream(resultsFilePath, FileMode.Open);
+      return parser.ParseFrom(stream);
     }
 
     public void SaveResults(ICoverageResults results, Project testProject, ConfigurationSelector configuration)

VSMac-CodeCoverage/VSMac-CodeCoverage/Coverage/CoverageService.cs

@@ -1,5 +1,9 @@
 using System;
+using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities;
 using MonoDevelop.Core.Execution;
 using MonoDevelop.Ide;
 using MonoDevelop.Projects;
@@ -14,7 +18,8 @@ public interface ICoverageService
 
   interface ICoverageProvider
   {
-    void Prepare(Project testProject, ConfigurationSelector configuration);
+    string RunSettingsDataCollectorFriendlyName { get; }
+    void Prepare(Project testProject, ConfigurationSelector configuration, DataCollectorSettings coverageSettings);
     ICoverageResults GetCoverage(Project testProject, ConfigurationSelector configuration);
   }
 
@@ -41,7 +46,7 @@ public async Task CollectCoverageForTestProject(Project testProject)
     }
 
     protected virtual async Task RunTests(Project testProject)
-    {      
+    {
       IExecutionHandler mode = null;
       ExecutionContext context = new ExecutionContext(mode, IdeApp.Workbench.ProgressMonitors.ConsoleFactory, null);
       var firstRootTest = UnitTestService.FindRootTest(testProject);
@@ -52,16 +57,43 @@ protected virtual async Task RunTests(Project testProject)
 
     private async void UnitTestService_TestSessionStarting(object sender, TestSessionEventArgs e)
     {
-      if (coverageCollectionCompletion == null || !(e.Test.OwnerObject is Project testProject)) return;
+      if (coverageCollectionCompletion == null || e.Test.OwnerObject is not Project testProject) return;
 
       var configuration = IdeApp.Workspace.ActiveConfiguration;
-      provider.Prepare(testProject, configuration);
+      DataCollectorSettings coverageSettings = GetRunSettings(testProject);
+      provider.Prepare(testProject, configuration, coverageSettings);
       await e.Session.Task;
       var results = provider.GetCoverage(testProject, configuration);
       if (results != null) SaveResults(results, testProject, configuration);
       coverageCollectionCompletion.SetResult(true);
     }
 
+    protected DataCollectorSettings GetRunSettings(Project testProject)
+    {
+      string solutionDirectoryPath = testProject.ParentSolution.BaseDirectory.ToString();
+      string[] runSettingsFiles = Directory.GetFiles(solutionDirectoryPath, "*.runsettings");
+      string runSettingsFile = runSettingsFiles.FirstOrDefault();
+      if (runSettingsFile == null) return null;
+
+      return ParseRunSettings(runSettingsFile);
+    }
+
+    protected virtual DataCollectorSettings ParseRunSettings(string runSettingsFile)
+    {
+      try
+      {
+        using FileStream settingsFileStream = new FileStream(runSettingsFile, FileMode.Open);
+        using StreamReader reader = new StreamReader(settingsFileStream);
+        string xml = reader.ReadToEnd();
+        DataCollectionRunSettings runSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(xml);
+        return runSettings.DataCollectorSettingsList.FirstOrDefault(
+          s => s.FriendlyName == provider.RunSettingsDataCollectorFriendlyName && s.IsEnabled);
+      } catch
+      {
+        return null;
+      }
+    }
+
     protected virtual void SaveResults(ICoverageResults results, Project testProject, ConfigurationSelector configuration)
     {
       repository.SaveResults(results, testProject, configuration);
@@ -72,4 +104,4 @@ public void Dispose()
       UnitTestService.TestSessionStarting -= UnitTestService_TestSessionStarting;
     }
   }
-}
+}

VSMac-CodeCoverage/VSMac-CodeCoverage/Coverage/LoggedCoverageService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
 using MonoDevelop.Projects;
 
 namespace CodeCoverage.Coverage
@@ -33,39 +34,54 @@ public enum LogLevel
   class LoggedCoverageService : CoverageService, ILoggedCoverageService
   {
     IProgress<Log> progress;
+    readonly ILoggingService loggingService;
 
-    public LoggedCoverageService(ICoverageProvider provider, ICoverageResultsRepository repository) : base(provider, repository) { }
+    public LoggedCoverageService(ICoverageProvider provider, ICoverageResultsRepository repository, ILoggingService loggingService) : base(provider, repository) {
+      this.loggingService = loggingService;
+    }
 
     public async Task CollectCoverageForTestProject(Project testProject, IProgress<Log> progress)
     {
       this.progress = progress;
-
+      loggingService.Info($"\n----\n");
+      loggingService.Info($"Starting coverage gathering: {testProject.Name}");
       try
       {
         await CollectCoverageForTestProject(testProject);
       }
       catch (Exception e)
       {
         progress.Report(new Log("Failed to gather coverage. See log for details.", LogLevel.Error, e));
+        loggingService.Error("Failed to gather coverage.");
       }
     }
 
     protected override async Task RunTests(Project testProject)
     {
       progress.Report(new Log("Running unit tests...", LogLevel.Info));
+      loggingService.Info($"Running unit tests: {testProject.Name}");
       await base.RunTests(testProject);
     }
 
+    protected override DataCollectorSettings ParseRunSettings(string runSettingsFile)
+    {
+      loggingService.Info($"Using run settings file: {runSettingsFile}");
+      return base.ParseRunSettings(runSettingsFile);
+    }
+
     protected override void SaveResults(ICoverageResults results, Project testProject, ConfigurationSelector configuration)
     {
       progress.Report(new Log("Saving coverage results...", LogLevel.Info));
+      loggingService.Info($"Saving coverage results...");
       base.SaveResults(results, testProject, configuration);
       FinishedGatheringCoveage();
     }
 
     void FinishedGatheringCoveage()
     {
       progress.Report(new Log("Done gathering coverage.", LogLevel.Info));
+      loggingService.Info("Done gathering coverage.");
+      loggingService.Info($"\n----\n");
     }
   }
 }

VSMac-CodeCoverage/VSMac-CodeCoverage/Coverlet/CoverletCoverageProvider.cs

@@ -1,7 +1,13 @@
 using System;
 using System.Collections.Generic;
-using Coverlet.Core.Abstracts;
+using System.Diagnostics;
+using System.IO;
+using System.Xml.Serialization;
+using Coverlet.Core;
+using Coverlet.Core.Abstractions;
 using Coverlet.Core.Helpers;
+using Coverlet.Core.Symbols;
+using Microsoft.VisualStudio.TestPlatform.ObjectModel;
 using MonoDevelop.Projects;
 using CoverletCoverage = Coverlet.Core.Coverage;
 
@@ -11,7 +17,22 @@ class CoverletCoverageProvider : ICoverageProvider
   {
     readonly Dictionary<Tuple<Project, ConfigurationSelector>, CoverletCoverage> projectCoverageMap;
     readonly ILogger logger;
-    readonly FileSystem fileSystem;    
+    readonly FileSystem fileSystem;
+
+    public string RunSettingsDataCollectorFriendlyName => "XPlat code coverage";
+
+    private static CoverageParameters defaultCoverageParameters = new CoverageParameters
+    {
+      IncludeFilters = new string[0],
+      IncludeDirectories = new string[0],
+      ExcludeFilters = new string[0],
+      ExcludedSourceFiles = new string[0],
+      ExcludeAttributes = new string[0],
+      IncludeTestAssembly = false,
+      SingleHit = false,
+      MergeWith = null,
+      UseSourceLink = false,
+    };
 
     public CoverletCoverageProvider(ILoggingService log)
     {
@@ -20,27 +41,48 @@ public CoverletCoverageProvider(ILoggingService log)
       projectCoverageMap = new Dictionary<Tuple<Project, ConfigurationSelector>, CoverletCoverage>();
     }
 
-    public void Prepare(Project testProject, ConfigurationSelector configuration)
+    public void Prepare(Project testProject, ConfigurationSelector configuration, DataCollectorSettings coverageSettings)
     {
       var unitTestDll = testProject.GetOutputFileName(configuration).ToString();
-      var instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), fileSystem);
-      var coverage = new CoverletCoverage(unitTestDll, 
-          new string[0], // Include Filters
-          new string[0], // Include directories
-          new string[0], // Exclude Filters
-          new string[0], // Excluded Source Files
-          new string[0], // Exclude Attributes
-          false, // Include test assembly
-          false, // Single hit
-          null, // Merge with
-          false, // Use source link
+      var sourceRootTranslator = new SourceRootTranslator(logger, fileSystem);
+      var cecilSymbolHelper = new CecilSymbolHelper();
+      var instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), fileSystem, logger, sourceRootTranslator);
+      var coverageParameters = GetCoverageParameters(coverageSettings);
+
+      var coverage = new CoverletCoverage(unitTestDll,
+          coverageParameters,
           logger,
           instrumentationHelper,
-          fileSystem);
+          fileSystem,
+          sourceRootTranslator,
+          cecilSymbolHelper);
       coverage.PrepareModules();
       projectCoverageMap[new Tuple<Project, ConfigurationSelector>(testProject, configuration)] = coverage;
     }
 
+    CoverageParameters GetCoverageParameters(DataCollectorSettings coverageSettings)
+    {
+      if (coverageSettings is null) return defaultCoverageParameters;
+      return ParseSettings(coverageSettings);
+    }
+
+    CoverageParameters ParseSettings(DataCollectorSettings coverageSettings)
+    {
+      try
+      {
+        string configurationXml = coverageSettings.Configuration.OuterXml;
+        XmlSerializer serializer = new XmlSerializer(typeof(CoverletRunSettingsConfiguration));
+        using StringReader reader = new StringReader(configurationXml);
+        CoverletRunSettingsConfiguration settings = (CoverletRunSettingsConfiguration)serializer.Deserialize(reader);
+        return settings.ToParameters();
+      }
+      catch (Exception e)
+      {
+        Debug.WriteLine(e);
+        return defaultCoverageParameters;
+      }
+    }
+
     public ICoverageResults GetCoverage(Project testProject, ConfigurationSelector configuration)
     {
       var key = new Tuple<Project, ConfigurationSelector>(testProject, configuration);

VSMac-CodeCoverage/VSMac-CodeCoverage/Coverlet/CoverletCoverageResults.cs

@@ -8,30 +8,30 @@ namespace CodeCoverage.Coverage
 {
   class CoverletCoverageResults : ICoverageResults
   {
+    public Dictionary<string, CoverageSummary> ModuleCoverage { get; private set; }
+    
     readonly CoverletCoverageResult result;
 
     public CoverletCoverageResults(CoverletCoverageResult result)
     {
       this.result = result;
+      SetModuleCoverage();
     }
 
-    public Dictionary<string, CoverageSummary> ModuleCoverage
+    void SetModuleCoverage()
     {
-      get
-      {
-        var modulesCoverage = new Dictionary<string, CoverageSummary>();
-        var summary = new CoverletCoverageSummary();
-
-        foreach (var moduleInfo in result.Modules)
-        {
-          var moduleLineCoverage = summary.CalculateLineCoverage(moduleInfo.Value);
-          var moduleBranchCoverage = summary.CalculateBranchCoverage(moduleInfo.Value);
-          var moduleName = moduleInfo.Key.Replace(".dll", "");
-          modulesCoverage[moduleName] = new CoverageSummary(moduleLineCoverage.Percent, moduleBranchCoverage.Percent);
-        }
+      var modulesCoverage = new Dictionary<string, CoverageSummary>();
+      var summary = new CoverletCoverageSummary();
 
-        return modulesCoverage;
+      foreach (var moduleInfo in result.Modules)
+      {
+        var moduleLineCoverage = summary.CalculateLineCoverage(moduleInfo.Value);
+        var moduleBranchCoverage = summary.CalculateBranchCoverage(moduleInfo.Value);
+        var moduleName = moduleInfo.Key.Replace(".dll", "");
+        modulesCoverage[moduleName] = new CoverageSummary(moduleLineCoverage.Percent, moduleBranchCoverage.Percent);
       }
+
+      ModuleCoverage = modulesCoverage;
     }
 
     public Dictionary<int, int> CoverageForFile(string path)

VSMac-CodeCoverage/VSMac-CodeCoverage/Coverlet/CoverletResultsParser.cs

@@ -9,13 +9,11 @@ class CoverletResultsParser : ICoverageResultsParser
 
     public ICoverageResults ParseFrom(Stream stream)
     {
-      using (StreamReader reader = new StreamReader(stream))
-      using (JsonTextReader jsonReader = new JsonTextReader(reader))
-      {
-        JsonSerializer serializer = new JsonSerializer();        
-        var coverletResults = serializer.Deserialize<Coverlet.Core.CoverageResult>(jsonReader);
-        return new CoverletCoverageResults(coverletResults);
-      }
+      using StreamReader reader = new StreamReader(stream);
+      using JsonTextReader jsonReader = new JsonTextReader(reader);
+      JsonSerializer serializer = new JsonSerializer();
+      var coverletResults = serializer.Deserialize<Coverlet.Core.CoverageResult>(jsonReader);
+      return new CoverletCoverageResults(coverletResults);
     }
   }
 }