Merge pull request #64 from ido-namely/exclude-files-by-path

tonerdo · web-flow · commit b3d108a2e1b7 · 2018-04-29T21:40:12.000+01:00
Implementation exclusion of files according to source file paths
diff --git a/README.md b/README.md
@@ -78,13 +78,24 @@ The above command will automatically fail the build if the average code coverage
 
 ### Excluding From Coverage
 
+#### Attributes  
 You can ignore a method or an entire class from code coverage by creating and applying any of the following attributes:
 
 * ExcludeFromCoverage
 * ExcludeFromCoverageAttribute
 
 Coverlet just uses the type name, so the attributes can be created under any namespace of your choosing.
 
+#### File Path  
+You can also ignore specific source files from code coverage using the `Exclude` property
+ - Use single or multiple paths (separate by comma)
+ - Use absolute or relative paths (relative to the project directory)
+ - Use file path or directory path with globbing (e.g `dir1/*.cs`)
+
+```bash
+dotnet test /p:CollectCoverage=true /p:Exclude=\"../dir1/class1.cs,../dir2/*.cs,../dir3/**/*.cs,\"
+```
+
 ## Roadmap
 
 * Filter modules to be instrumented
diff --git a/build.proj b/build.proj
@@ -24,11 +24,15 @@
   </Target>
 
   <Target Name="RunTests" AfterTargets="CopyMSBuildScripts">
-    <Exec Command="dotnet test $(MSBuildThisFileDirectory)test\coverlet.core.tests\coverlet.core.tests.csproj -c $(Configuration) /p:CollectCoverage=true /p:CoverletOutputFormat=opencover" />
+    <Exec Command="dotnet test $(MSBuildThisFileDirectory)test\coverlet.core.tests\coverlet.core.tests.csproj -c $(Configuration) /p:CollectCoverage=true /p:CoverletOutputFormat=opencover"/>
+  </Target>
+  
+  <Target Name="RunTestsWithExclude" AfterTargets="RunTests">
+    <Exec Command="dotnet test --no-build $(MSBuildThisFileDirectory)test\coverlet.core.tests\coverlet.core.tests.csproj -c $(Configuration) /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:Exclude=\&quot;../../src/coverlet.core/Instrumentation/**/*.cs,$(MSBuildThisFileDirectory)/src/coverlet.core/Reporters/**/*.cs\&quot;"/>
   </Target>
 
-  <Target Name="CreateNuGetPackage" AfterTargets="RunTests" Condition="$(Configuration) == 'Release'">
+  <Target Name="CreateNuGetPackage" AfterTargets="RunTestsWithExclude" Condition="$(Configuration) == 'Release'">
     <Exec Command="dotnet pack $(MSBuildThisFileDirectory)src\coverlet.msbuild.tasks\coverlet.msbuild.tasks.csproj -c $(Configuration) -o $(OutputPath) /p:NuspecFile=$(NuspecFile)" />
   </Target>
 
-</Project>
+</Project>
diff --git a/src/coverlet.core/Coverage.cs b/src/coverlet.core/Coverage.cs
@@ -12,21 +12,24 @@ public class Coverage
     {
         private string _module;
         private string _identifier;
+        private IEnumerable<string> _excludeRules;
         private List<InstrumenterResult> _results;
 
-        public Coverage(string module, string identifier)
+        public Coverage(string module, string identifier, IEnumerable<string> excludeRules = null)
         {
             _module = module;
             _identifier = identifier;
+            _excludeRules = excludeRules;
             _results = new List<InstrumenterResult>();
         }
 
         public void PrepareModules()
         {
             string[] modules = InstrumentationHelper.GetDependencies(_module);
+            var excludedFiles =  InstrumentationHelper.GetExcludedFiles(_excludeRules);
             foreach (var module in modules)
             {
-                var instrumenter = new Instrumenter(module, _identifier);
+                var instrumenter = new Instrumenter(module, _identifier, excludedFiles);
                 if (instrumenter.CanInstrument())
                 {
                     InstrumentationHelper.BackupOriginalModule(module, _identifier);
diff --git a/src/coverlet.core/Helpers/InstrumentationHelper.cs b/src/coverlet.core/Helpers/InstrumentationHelper.cs
@@ -3,8 +3,10 @@
 using System.IO;
 using System.Linq;
 using System.Reflection.PortableExecutable;
+using Microsoft.Extensions.FileSystemGlobbing;
 
 using Coverlet.Core.Instrumentation;
+using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
 
 namespace Coverlet.Core.Helpers
 {
@@ -107,5 +109,44 @@ public static void DeleteHitsFile(string path)
 
             RetryHelper.Retry(() => File.Delete(path), retryStrategy, 10);
         }
+        
+        public static IEnumerable<string> GetExcludedFiles(IEnumerable<string> excludeRules, 
+                                                           string parentDir = null) 
+        {
+            const string RELATIVE_KEY = nameof(RELATIVE_KEY);
+            parentDir = string.IsNullOrWhiteSpace(parentDir)? Directory.GetCurrentDirectory() : parentDir;
+            
+            if (excludeRules == null || !excludeRules.Any()) return Enumerable.Empty<string>();
+            
+            var matcherDict = new Dictionary<string, Matcher>(){ {RELATIVE_KEY, new Matcher()}};
+            foreach (var excludeRule in excludeRules)
+            {
+                if (Path.IsPathRooted(excludeRule)) {
+                    var root = Path.GetPathRoot(excludeRule);
+                    if (!matcherDict.ContainsKey(root)) {
+                        matcherDict.Add(root, new Matcher());
+                    } 
+                    matcherDict[root].AddInclude(excludeRule.Substring(root.Length));
+                } else {
+                    matcherDict[RELATIVE_KEY].AddInclude(excludeRule);
+                }
+                
+            }
+            
+            var files = new List<string>();
+            foreach(var entry in matcherDict)
+            {
+                var root = entry.Key;
+                var matcher = entry.Value;
+                var directoryInfo = new DirectoryInfo(root.Equals(RELATIVE_KEY) ? parentDir : root);
+                var fileMatchResult = matcher.Execute(new DirectoryInfoWrapper(directoryInfo));
+                var currentFiles = fileMatchResult.Files
+                    .Select(f => Path.GetFullPath(Path.Combine(directoryInfo.ToString(), f.Path)));
+                files.AddRange(currentFiles);
+            }
+            
+            return files.Distinct();
+        }
     }
-}
+}
+
diff --git a/src/coverlet.core/Instrumentation/Instrumenter.cs b/src/coverlet.core/Instrumentation/Instrumenter.cs
@@ -6,19 +6,22 @@
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
+using System.Collections.Generic;
 
 namespace Coverlet.Core.Instrumentation
 {
     internal class Instrumenter
     {
         private readonly string _module;
         private readonly string _identifier;
+        private IEnumerable<string> _excludedFiles;
         private InstrumenterResult _result;
 
-        public Instrumenter(string module, string identifier)
+        public Instrumenter(string module, string identifier, IEnumerable<string> excludedFiles = null)
         {
             _module = module;
             _identifier = identifier;
+            _excludedFiles = excludedFiles ?? Enumerable.Empty<string>();
         }
 
         public bool CanInstrument() => InstrumentationHelper.HasPdb(_module);
@@ -59,6 +62,10 @@ private void InstrumentModule()
 
                         foreach (var method in type.Methods)
                         {
+	                        var sourceFile = method.DebugInformation.SequencePoints.Select(s => s.Document.Url).FirstOrDefault();
+	                        if (!string.IsNullOrEmpty(sourceFile) && _excludedFiles.Contains(sourceFile)) {
+	                            continue;
+	                        }
                             if (!method.CustomAttributes.Any(a => a.AttributeType.Name == "ExcludeFromCoverageAttribute" || a.AttributeType.Name == "ExcludeFromCoverage"))
                                 InstrumentMethod(method);
                         }
diff --git a/src/coverlet.core/coverlet.core.csproj b/src/coverlet.core/coverlet.core.csproj
@@ -9,6 +9,7 @@
     <PackageReference Include="Jil" Version="2.15.4" />
     <PackageReference Include="Mono.Cecil" Version="0.10.0" />
     <PackageReference Include="System.Reflection.Metadata" Version="1.5.0" />
+    <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="2.0.1" />
   </ItemGroup>
 
 </Project>
diff --git a/src/coverlet.msbuild.tasks/InstrumentationTask.cs b/src/coverlet.msbuild.tasks/InstrumentationTask.cs
@@ -1,35 +1,26 @@
 ﻿using System;
 using Coverlet.Core;
-
 using Microsoft.Build.Framework;
-using Microsoft.Build.Utilities;
-
+using Microsoft.Build.Utilities;
+
 namespace Coverlet.MSbuild.Tasks
 {
     public class InstrumentationTask : Task
-    {
-        private string _path;
-        private static Coverage _coverage;
-
-        internal static Coverage Coverage
-        {
-            get { return _coverage; }
-            private set { _coverage = value; }
-        }
+    {        
+        internal static Coverage Coverage { get; private set; }
 
         [Required]
-        public string Path
-        {
-            get { return _path; }
-            set { _path = value; }
-        }
-
+        public string Path { get; set; }
+        
+        public string Exclude { get; set; }
+                
         public override bool Execute()
         {
             try
             {
-                _coverage = new Coverage(_path, Guid.NewGuid().ToString());
-                _coverage.PrepareModules();
+                var excludeRules = Exclude?.Split(',');
+                Coverage = new Coverage(Path, Guid.NewGuid().ToString(), excludeRules);
+                Coverage.PrepareModules();
             }
             catch(Exception ex)
             {
diff --git a/src/coverlet.msbuild/coverlet.msbuild.props b/src/coverlet.msbuild/coverlet.msbuild.props
@@ -6,7 +6,7 @@
     <CoverletOutputDirectory Condition="$(CoverletOutputDirectory) == ''">$(MSBuildProjectDirectory)</CoverletOutputDirectory>
     <CoverletOutputName Condition=" '$(CoverletOutputName)' == '' ">coverage</CoverletOutputName>
     <CoverletOutput>$([MSBuild]::EnsureTrailingSlash('$(CoverletOutputDirectory)'))$(CoverletOutputName)</CoverletOutput>
-
+    <Exclude Condition="$(Exclude) == ''"></Exclude>
     <Threshold Condition="$(Threshold) == ''">0</Threshold>
     <CollectCoverage Condition="$(CollectCoverage) == ''">false</CollectCoverage>
 
diff --git a/src/coverlet.msbuild/coverlet.msbuild.targets b/src/coverlet.msbuild/coverlet.msbuild.targets
@@ -6,12 +6,14 @@
   <Target Name="InstrumentModulesNoBuild" BeforeTargets="VSTest">
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' == 'true' and $(CollectCoverage) == 'true'"
+      Exclude="$(Exclude)"
       Path="$(TargetPath)" />
   </Target>
 
   <Target Name="InstrumentModulesAfterBuild" AfterTargets="BuildProject">
     <Coverlet.MSbuild.Tasks.InstrumentationTask
       Condition="'$(VSTestNoBuild)' != 'true' and $(CollectCoverage) == 'true'"
+      Exclude="$(Exclude)"
       Path="$(TargetPath)" />
   </Target>
 
@@ -23,4 +25,4 @@
       Threshold="$(Threshold)" />
   </Target>
 
-</Project>
+</Project>
diff --git a/test/coverlet.core.tests/Helpers/InstrumentationHelperTests.cs b/test/coverlet.core.tests/Helpers/InstrumentationHelperTests.cs
@@ -2,12 +2,13 @@
 using System.IO;
 
 using Xunit;
-using Coverlet.Core.Helpers;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Coverlet.Core.Helpers.Tests
 {
     public class InstrumentationHelperTests
-    {
+    {            
         [Fact]
         public void TestGetDependencies()
         {
@@ -79,5 +80,63 @@ public void TestDeleteHitsFile()
             InstrumentationHelper.DeleteHitsFile(tempFile);
             Assert.False(File.Exists(tempFile));
         }
+        
+        
+        public static IEnumerable<object[]> GetExcludedFilesReturnsEmptyArgs => 
+        new[] 
+        {
+            new object[]{null},
+            new object[]{new List<string>()},
+            new object[]{new List<string>(){ Path.GetRandomFileName() }},
+            new object[]{new List<string>(){Path.GetRandomFileName(), 
+                Path.Combine(Directory.GetCurrentDirectory(), Path.GetRandomFileName())}
+            }
+        };
+        
+        [Theory]
+        [MemberData(nameof(GetExcludedFilesReturnsEmptyArgs))]
+        public void TestGetExcludedFilesReturnsEmpty(IEnumerable<string> excludedFiles) 
+        {
+            Assert.False(InstrumentationHelper.GetExcludedFiles(excludedFiles)?.Any());
+        }
+        
+        [Fact]
+        public void TestGetExcludedFilesUsingAbsFile() 
+        {
+            var file = Path.GetRandomFileName();
+            File.Create(file).Dispose();
+            var excludeFiles = InstrumentationHelper.GetExcludedFiles(
+                new List<string>() {Path.Combine(Directory.GetCurrentDirectory(), file)}
+            );
+            File.Delete(file);
+            Assert.Single(excludeFiles);
+        }
+            
+        [Fact]
+        public void TestGetExcludedFilesUsingGlobbing() 
+        {
+            var fileExtension = Path.GetRandomFileName();
+            var paths = new string[]{
+                $"{Path.GetRandomFileName()}.{fileExtension}",
+                $"{Path.GetRandomFileName()}.{fileExtension}"
+            };
+            
+            foreach (var path in paths)
+            {
+                File.Create(path).Dispose();
+            }
+            
+            var excludeFiles = InstrumentationHelper.GetExcludedFiles(
+                new List<string>(){$"*.{fileExtension}"});
+            
+            foreach (var path in paths)
+            {   
+                File.Delete(path);
+            }
+            
+            Assert.Equal(paths.Length, excludeFiles.Count());
+        }
     }
-}
+}
+
+
diff --git a/test/coverlet.core.tests/Instrumentation/InstrumenterTests.cs b/test/coverlet.core.tests/Instrumentation/InstrumenterTests.cs
@@ -21,7 +21,6 @@ public void TestInstrument()
             File.Copy(pdb, Path.Combine(directory.FullName, Path.GetFileName(pdb)), true);
 
             module = Path.Combine(directory.FullName, Path.GetFileName(module));
-
             Instrumenter instrumenter = new Instrumenter(module, identifier);
             var result = instrumenter.Instrument();
 

Original file line number	Diff line number	Diff line change
`@@ -12,21 +12,24 @@ public class Coverage`
`12`	`12`	`{`
`13`	`13`	`private string _module;`
`14`	`14`	`private string _identifier;`
	`15`	`+ private IEnumerable<string> _excludeRules;`
`15`	`16`	`private List<InstrumenterResult> _results;`
`16`	`17`
`17`		`- public Coverage(string module, string identifier)`
	`18`	`+ public Coverage(string module, string identifier, IEnumerable<string> excludeRules = null)`
`18`	`19`	`{`
`19`	`20`	`_module = module;`
`20`	`21`	`_identifier = identifier;`
	`22`	`+ _excludeRules = excludeRules;`
`21`	`23`	`_results = new List<InstrumenterResult>();`
`22`	`24`	`}`
`23`	`25`
`24`	`26`	`public void PrepareModules()`
`25`	`27`	`{`
`26`	`28`	`string[] modules = InstrumentationHelper.GetDependencies(_module);`
	`29`	`+ var excludedFiles = InstrumentationHelper.GetExcludedFiles(_excludeRules);`
`27`	`30`	`foreach (var module in modules)`
`28`	`31`	`{`
`29`		`- var instrumenter = new Instrumenter(module, _identifier);`
	`32`	`+ var instrumenter = new Instrumenter(module, _identifier, excludedFiles);`
`30`	`33`	`if (instrumenter.CanInstrument())`
`31`	`34`	`{`
`32`	`35`	`InstrumentationHelper.BackupOriginalModule(module, _identifier);`
Original file line number	Diff line number	Diff line change
`@@ -6,19 +6,22 @@`
`6`	`6`	`using Mono.Cecil;`
`7`	`7`	`using Mono.Cecil.Cil;`
`8`	`8`	`using Mono.Cecil.Rocks;`
	`9`	`+using System.Collections.Generic;`
`9`	`10`
`10`	`11`	`namespace Coverlet.Core.Instrumentation`
`11`	`12`	`{`
`12`	`13`	`internal class Instrumenter`
`13`	`14`	`{`
`14`	`15`	`private readonly string _module;`
`15`	`16`	`private readonly string _identifier;`
	`17`	`+ private IEnumerable<string> _excludedFiles;`
`16`	`18`	`private InstrumenterResult _result;`
`17`	`19`
`18`		`- public Instrumenter(string module, string identifier)`
	`20`	`+ public Instrumenter(string module, string identifier, IEnumerable<string> excludedFiles = null)`
`19`	`21`	`{`
`20`	`22`	`_module = module;`
`21`	`23`	`_identifier = identifier;`
	`24`	`+ _excludedFiles = excludedFiles ?? Enumerable.Empty<string>();`
`22`	`25`	`}`
`23`	`26`
`24`	`27`	`public bool CanInstrument() => InstrumentationHelper.HasPdb(_module);`
`@@ -59,6 +62,10 @@ private void InstrumentModule()`
`59`	`62`
`60`	`63`	`foreach (var method in type.Methods)`
`61`	`64`	`{`
	`65`	`+ var sourceFile = method.DebugInformation.SequencePoints.Select(s => s.Document.Url).FirstOrDefault();`
	`66`	`+ if (!string.IsNullOrEmpty(sourceFile) && _excludedFiles.Contains(sourceFile)) {`
	`67`	`+ continue;`
	`68`	`+ }`
`62`	`69`	`if (!method.CustomAttributes.Any(a => a.AttributeType.Name == "ExcludeFromCoverageAttribute" \|\| a.AttributeType.Name == "ExcludeFromCoverage"))`
`63`	`70`	`InstrumentMethod(method);`
`64`	`71`	`}`