Refactor coverage parameters (#876)

Refactor coverage parameters

src/coverlet.collector/DataCollection/CoverageWrapper.cs

@@ -17,17 +17,22 @@ namespace Coverlet.Collector.DataCollection
         /// <returns>Coverage object</returns>
         public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper)
         {
+            CoverageParameters parameters = new CoverageParameters
+            {
+                IncludeFilters = settings.IncludeFilters,
+                IncludeDirectories = settings.IncludeDirectories,
+                ExcludeFilters = settings.ExcludeFilters,
+                ExcludedSourceFiles = settings.ExcludeSourceFiles,
+                ExcludeAttributes = settings.ExcludeAttributes,
+                IncludeTestAssembly = settings.IncludeTestAssembly,
+                SingleHit = settings.SingleHit,
+                MergeWith = settings.MergeWith,
+                UseSourceLink = settings.UseSourceLink
+            };
+
             return new Coverage(
                 settings.TestModule,
-                settings.IncludeFilters,
-                settings.IncludeDirectories,
-                settings.ExcludeFilters,
-                settings.ExcludeSourceFiles,
-                settings.ExcludeAttributes,
-                settings.IncludeTestAssembly,
-                settings.SingleHit,
-                settings.MergeWith,
-                settings.UseSourceLink,
+                parameters,
                 coverletLogger,
                 instrumentationHelper,
                 fileSystem,

src/coverlet.console/Program.cs

@@ -34,7 +34,7 @@ namespace Coverlet.Console
 
             ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
 
-            var logger = (ConsoleLogger) serviceProvider.GetService<ILogger>();
+            var logger = (ConsoleLogger)serviceProvider.GetService<ILogger>();
             var fileSystem = serviceProvider.GetService<IFileSystem>();
 
             var app = new CommandLineApplication();
@@ -76,22 +76,28 @@ namespace Coverlet.Console
                     // Adjust log level based on user input.
                     logger.Level = verbosity.ParsedValue;
                 }
+
+                CoverageParameters parameters = new CoverageParameters
+                {
+                    IncludeFilters = includeFilters.Values.ToArray(),
+                    IncludeDirectories = includeDirectories.Values.ToArray(),
+                    ExcludeFilters = excludeFilters.Values.ToArray(),
+                    ExcludedSourceFiles = excludedSourceFiles.Values.ToArray(),
+                    ExcludeAttributes = excludeAttributes.Values.ToArray(),
+                    IncludeTestAssembly = includeTestAssembly.HasValue(),
+                    SingleHit = singleHit.HasValue(),
+                    MergeWith = mergeWith.Value(),
+                    UseSourceLink = useSourceLink.HasValue()
+                };
+
                 Coverage coverage = new Coverage(module.Value,
-                    includeFilters.Values.ToArray(),
-                    includeDirectories.Values.ToArray(),
-                    excludeFilters.Values.ToArray(),
-                    excludedSourceFiles.Values.ToArray(),
-                    excludeAttributes.Values.ToArray(),
-                    includeTestAssembly.HasValue(),
-                    singleHit.HasValue(),
-                    mergeWith.Value(),
-                    useSourceLink.HasValue(),
-                    logger,
-                    serviceProvider.GetRequiredService<IInstrumentationHelper>(),
-                    fileSystem,
-                    serviceProvider.GetRequiredService<ISourceRootTranslator>(),
-                    serviceProvider.GetRequiredService<ICecilSymbolHelper>());
-                coverage.PrepareModules();
+                                                 parameters,
+                                                 logger,
+                                                 serviceProvider.GetRequiredService<IInstrumentationHelper>(),
+                                                 fileSystem,
+                                                 serviceProvider.GetRequiredService<ISourceRootTranslator>(),
+                                                 serviceProvider.GetRequiredService<ICecilSymbolHelper>());
+                                                 coverage.PrepareModules();
 
                 Process process = new Process();
                 process.StartInfo.FileName = target.Value();

src/coverlet.core/Coverage.cs

@@ -10,6 +10,20 @@ using Newtonsoft.Json.Linq;
 
 namespace Coverlet.Core
 {
+    internal class CoverageParameters
+    {
+        public string Module { get; set; }
+        public string[] IncludeFilters { get; set; }
+        public string[] IncludeDirectories { get; set; }
+        public string[] ExcludeFilters { get; set; }
+        public string[] ExcludedSourceFiles { get; set; }
+        public string[] ExcludeAttributes { get; set; }
+        public bool IncludeTestAssembly { get; set; }
+        public bool SingleHit { get; set; }
+        public string MergeWith { get; set; }
+        public bool UseSourceLink { get; set; }
+    }
+
     internal class Coverage
     {
         private string _module;
@@ -36,15 +50,7 @@ namespace Coverlet.Core
         }
 
         public Coverage(string module,
-            string[] includeFilters,
-            string[] includeDirectories,
-            string[] excludeFilters,
-            string[] excludedSourceFiles,
-            string[] excludeAttributes,
-            bool includeTestAssembly,
-            bool singleHit,
-            string mergeWith,
-            bool useSourceLink,
+            CoverageParameters parameters,
             ILogger logger,
             IInstrumentationHelper instrumentationHelper,
             IFileSystem fileSystem,
@@ -52,15 +58,15 @@ namespace Coverlet.Core
             ICecilSymbolHelper cecilSymbolHelper)
         {
             _module = module;
-            _includeFilters = includeFilters;
-            _includeDirectories = includeDirectories ?? Array.Empty<string>();
-            _excludeFilters = excludeFilters;
-            _excludedSourceFiles = excludedSourceFiles;
-            _excludeAttributes = excludeAttributes;
-            _includeTestAssembly = includeTestAssembly;
-            _singleHit = singleHit;
-            _mergeWith = mergeWith;
-            _useSourceLink = useSourceLink;
+            _includeFilters = parameters.IncludeFilters;
+            _includeDirectories = parameters.IncludeDirectories ?? Array.Empty<string>();
+            _excludeFilters = parameters.ExcludeFilters;
+            _excludedSourceFiles = parameters.ExcludedSourceFiles;
+            _excludeAttributes = parameters.ExcludeAttributes;
+            _includeTestAssembly = parameters.IncludeTestAssembly;
+            _singleHit = parameters.SingleHit;
+            _mergeWith = parameters.MergeWith;
+            _useSourceLink = parameters.UseSourceLink;
             _logger = logger;
             _instrumentationHelper = instrumentationHelper;
             _fileSystem = fileSystem;

src/coverlet.msbuild.tasks/InstrumentationTask.cs

@@ -138,28 +138,28 @@ namespace Coverlet.MSbuild.Tasks
 
             try
             {
-                var includeFilters = _include?.Split(',');
-                var includeDirectories = _includeDirectory?.Split(',');
-                var excludeFilters = _exclude?.Split(',');
-                var excludedSourceFiles = _excludeByFile?.Split(',');
-                var excludeAttributes = _excludeByAttribute?.Split(',');
                 var fileSystem = ServiceProvider.GetService<IFileSystem>();
 
+                CoverageParameters parameters = new CoverageParameters
+                {
+                    IncludeFilters = _include?.Split(','),
+                    IncludeDirectories = _includeDirectory?.Split(','),
+                    ExcludeFilters = _exclude?.Split(','),
+                    ExcludedSourceFiles = _excludeByFile?.Split(','),
+                    ExcludeAttributes = _excludeByAttribute?.Split(','),
+                    IncludeTestAssembly = _includeTestAssembly,
+                    SingleHit = _singleHit,
+                    MergeWith = _mergeWith,
+                    UseSourceLink = _useSourceLink
+                };
+
                 Coverage coverage = new Coverage(_path,
-                    includeFilters,
-                    includeDirectories,
-                    excludeFilters,
-                    excludedSourceFiles,
-                    excludeAttributes,
-                    _includeTestAssembly,
-                    _singleHit,
-                    _mergeWith,
-                    _useSourceLink,
-                    _logger,
-                    ServiceProvider.GetService<IInstrumentationHelper>(),
-                    fileSystem,
-                    ServiceProvider.GetService<ISourceRootTranslator>(),
-                    ServiceProvider.GetService<ICecilSymbolHelper>());
+                                                 parameters,
+                                                 _logger,
+                                                 ServiceProvider.GetService<IInstrumentationHelper>(),
+                                                 ServiceProvider.GetService<IFileSystem>(),
+                                                 ServiceProvider.GetService<ISourceRootTranslator>(),
+                                                 ServiceProvider.GetService<ICecilSymbolHelper>());
 
                 CoveragePrepareResult prepareResult = coverage.PrepareModules();
                 InstrumenterState = new TaskItem(System.IO.Path.GetTempFileName());

test/coverlet.collector.tests/CoverletCoverageDataCollectorTests.cs

@@ -114,7 +114,19 @@ namespace Coverlet.Collector.Tests
                                           new Mock<ILogger>().Object,
                                           new Mock<ISourceRootTranslator>().Object);
 
-            Coverage coverage = new Coverage("abc.dll", null, null, null, null, null, true, true, "abc.json", true, It.IsAny<ILogger>(), instrumentationHelper, new Mock<IFileSystem>().Object, new Mock<ISourceRootTranslator>().Object, new Mock<ICecilSymbolHelper>().Object);
+            CoverageParameters parameters = new CoverageParameters
+            {
+                IncludeFilters = null,
+                IncludeDirectories = null,
+                ExcludedSourceFiles = null,
+                ExcludeAttributes = null,
+                IncludeTestAssembly = true,
+                SingleHit = true,
+                MergeWith = "abc.json",
+                UseSourceLink = true
+            };
+
+            Coverage coverage = new Coverage("abc.dll", parameters, It.IsAny<ILogger>(), instrumentationHelper, new Mock<IFileSystem>().Object, new Mock<ISourceRootTranslator>().Object, new Mock<ICecilSymbolHelper>().Object);
 
             sessionStartProperties.Add("TestSources", new List<string> { "abc.dll" });
             _mockCoverageWrapper.Setup(x => x.CreateCoverage(It.IsAny<CoverletSettings>(), It.IsAny<ILogger>(), It.IsAny<IInstrumentationHelper>(), It.IsAny<IFileSystem>(), It.IsAny<ISourceRootTranslator>(), It.IsAny<ICecilSymbolHelper>())).Returns(coverage);

test/coverlet.core.tests/Coverage/CoverageTests.ExcludeFromCoverageAttribute.cs

@@ -33,9 +33,21 @@ namespace Coverlet.Core.Tests
                 new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem(), new Mock<ILogger>().Object,
                                           new SourceRootTranslator(excludedbyattributeDll, new Mock<ILogger>().Object, new FileSystem()));
 
+            CoverageParameters parameters = new CoverageParameters
+            {
+                IncludeFilters = new string[] { "[coverlet.tests.projectsample.excludedbyattribute*]*" },
+                IncludeDirectories = Array.Empty<string>(),
+                ExcludeFilters = Array.Empty<string>(),
+                ExcludedSourceFiles = Array.Empty<string>(),
+                ExcludeAttributes = Array.Empty<string>(),
+                IncludeTestAssembly = true,
+                SingleHit = false,
+                MergeWith = string.Empty,
+                UseSourceLink = false
+            };
+
             // test skip module include test assembly feature
-            var coverage = new Coverage(excludedbyattributeDll, new string[] { "[coverlet.tests.projectsample.excludedbyattribute*]*" }, Array.Empty<string>(), Array.Empty<string>(),
-                                        Array.Empty<string>(), Array.Empty<string>(), true, false, string.Empty, false, loggerMock.Object, instrumentationHelper, partialMockFileSystem.Object,
+            var coverage = new Coverage(excludedbyattributeDll, parameters, loggerMock.Object, instrumentationHelper, partialMockFileSystem.Object,
                                         new SourceRootTranslator(loggerMock.Object, new FileSystem()), new CecilSymbolHelper());
             CoveragePrepareResult result = coverage.PrepareModules();
             Assert.Empty(result.Results);

test/coverlet.core.tests/Coverage/CoverageTests.cs

@@ -29,8 +29,20 @@ namespace Coverlet.Core.Tests
                 new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem(), new Mock<ILogger>().Object,
                                           new SourceRootTranslator(module, new Mock<ILogger>().Object, new FileSystem()));
 
-            var coverage = new Coverage(Path.Combine(directory.FullName, Path.GetFileName(module)), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(),
-                                        Array.Empty<string>(), false, false, string.Empty, false, _mockLogger.Object, instrumentationHelper, new FileSystem(), new SourceRootTranslator(_mockLogger.Object, new FileSystem()), new CecilSymbolHelper());
+            CoverageParameters parameters = new CoverageParameters
+            {
+                IncludeFilters = new string[] { "[coverlet.tests.projectsample.excludedbyattribute*]*" },
+                IncludeDirectories = Array.Empty<string>(),
+                ExcludeFilters = Array.Empty<string>(),
+                ExcludedSourceFiles = Array.Empty<string>(),
+                ExcludeAttributes = Array.Empty<string>(),
+                IncludeTestAssembly = false,
+                SingleHit = false,
+                MergeWith = string.Empty,
+                UseSourceLink = false
+            };
+
+            var coverage = new Coverage(Path.Combine(directory.FullName, Path.GetFileName(module)), parameters, _mockLogger.Object, instrumentationHelper, new FileSystem(), new SourceRootTranslator(_mockLogger.Object, new FileSystem()), new CecilSymbolHelper());
             coverage.PrepareModules();
 
             var result = coverage.GetCoverageResult();
@@ -55,8 +67,20 @@ namespace Coverlet.Core.Tests
                 new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem(), new Mock<ILogger>().Object,
                                           new SourceRootTranslator(module, new Mock<ILogger>().Object, new FileSystem()));
 
-            var coverage = new Coverage(Path.Combine(directory.FullName, Path.GetFileName(module)), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(),
-                                        Array.Empty<string>(), true, false, string.Empty, false, _mockLogger.Object, instrumentationHelper, new FileSystem(),
+            CoverageParameters parameters = new CoverageParameters
+            {
+                IncludeFilters = Array.Empty<string>(),
+                IncludeDirectories = Array.Empty<string>(),
+                ExcludeFilters = Array.Empty<string>(),
+                ExcludedSourceFiles = Array.Empty<string>(),
+                ExcludeAttributes = Array.Empty<string>(),
+                IncludeTestAssembly = true,
+                SingleHit = false,
+                MergeWith = string.Empty,
+                UseSourceLink = false
+            };
+
+            var coverage = new Coverage(Path.Combine(directory.FullName, Path.GetFileName(module)), parameters, _mockLogger.Object, instrumentationHelper, new FileSystem(),
                                         new SourceRootTranslator(module, _mockLogger.Object, new FileSystem()), new CecilSymbolHelper());
             coverage.PrepareModules();
 

test/coverlet.core.tests/Coverage/InstrumenterHelper.cs

@@ -86,19 +86,30 @@ namespace Coverlet.Core.Tests
             SetTestContainer(newPath, disableRestoreModules);
 
             static string[] defaultFilters(string _) => Array.Empty<string>();
+
+            CoverageParameters parameters = new CoverageParameters
+            {
+                IncludeFilters = (includeFilter is null ? defaultFilters(fileName) : includeFilter(fileName)).Concat(
+                new string[]
+                {
+                    $"[{Path.GetFileNameWithoutExtension(fileName)}*]{typeof(T).FullName}*"
+                }).ToArray(),
+                IncludeDirectories = Array.Empty<string>(),
+                ExcludeFilters = (excludeFilter is null ? defaultFilters(fileName) : excludeFilter(fileName)).Concat(new string[]
+                {
+                    "[xunit.*]*",
+                    "[coverlet.*]*"
+                }).ToArray(),
+                ExcludedSourceFiles = Array.Empty<string>(),
+                ExcludeAttributes = Array.Empty<string>(),
+                IncludeTestAssembly = true,
+                SingleHit = false,
+                MergeWith = string.Empty,
+                UseSourceLink = false
+            };
+
             // Instrument module
-            Coverage coverage = new Coverage(newPath,
-            includeFilters: (includeFilter is null ? defaultFilters(fileName) : includeFilter(fileName)).Concat(
-            new string[]
-            {
-                $"[{Path.GetFileNameWithoutExtension(fileName)}*]{typeof(T).FullName}*"
-            }).ToArray(),
-            Array.Empty<string>(),
-            excludeFilters: (excludeFilter is null ? defaultFilters(fileName) : excludeFilter(fileName)).Concat(new string[]
-            {
-                "[xunit.*]*",
-                "[coverlet.*]*"
-            }).ToArray(), Array.Empty<string>(), Array.Empty<string>(), true, false, "", false, new Logger(logFile),
+            Coverage coverage = new Coverage(newPath, parameters, new Logger(logFile),
             _processWideContainer.GetService<IInstrumentationHelper>(), _processWideContainer.GetService<IFileSystem>(), _processWideContainer.GetService<ISourceRootTranslator>(), _processWideContainer.GetService<ICecilSymbolHelper>());
             CoveragePrepareResult prepareResult = coverage.PrepareModules();