Merge pull request mmanela#407 from stogle/master

adds /coverageIgnore option to exclude files from code coverage results

Chutzpah/Coverage/BlanketJsCoverageEngine.cs

@@ -25,6 +25,7 @@ public class BlanketJsCoverageEngine : ICoverageEngine
 
         private List<string> includePatterns { get; set; }
         private List<string> excludePatterns { get; set; }
+        private List<string> ignorePatterns { get; set; }
 
         public BlanketJsCoverageEngine(IJsonSerializer jsonSerializer, IFileSystemWrapper fileSystem, ILineCoverageMapper lineCoverageMapper)
         {
@@ -34,6 +35,7 @@ public BlanketJsCoverageEngine(IJsonSerializer jsonSerializer, IFileSystemWrappe
 
             includePatterns = new List<string>();
             excludePatterns = new List<string>();
+            ignorePatterns = new List<string>();
         }
 
         public IEnumerable<string> GetFileDependencies(IFrameworkDefinition definition, ChutzpahTestSettingsFile testSettingsFile)
@@ -166,7 +168,9 @@ public CoverageData DeserializeCoverageObject(string json, TestContext testConte
                     }
                 }
 
-                if (IsFileEligibleForInstrumentation(newKey) && fileSystem.FileExists(filePath))
+                if (IsFileEligibleForInstrumentation(newKey) &&
+                    !(testContext.CoverageEngine != null && testContext.CoverageEngine.IsIgnored(newKey)) &&
+                    fileSystem.FileExists(filePath))
                 {
                     string[] sourceLines = fileSystem.GetLines(filePath);
                     int?[] lineExecutionCounts = entry.Value;
@@ -191,6 +195,7 @@ public void ClearPatterns()
         {
             includePatterns.Clear();
             excludePatterns.Clear();
+            ignorePatterns.Clear();
         }
 
         public void AddIncludePatterns(IEnumerable<string> patterns)
@@ -209,6 +214,14 @@ public void AddExcludePatterns(IEnumerable<string> patterns)
             }
         }
 
+        public void AddIgnorePatterns(IEnumerable<string> patterns)
+        {
+            foreach (var pattern in patterns)
+            {
+                ignorePatterns.Add(pattern);
+            }
+        }
+
         private bool IsFileEligibleForInstrumentation(string filePath)
         {
             // If no include patterns are given then include all files. Otherwise include only the ones that match an include pattern
@@ -226,6 +239,17 @@ private bool IsFileEligibleForInstrumentation(string filePath)
             return true;
         }
 
+        public bool IsIgnored(string filePath)
+        {
+            // If no ignore pattern is given then include all files. Otherwise ignore the ones that match an ignore pattern
+            if (ignorePatterns.Any() && ignorePatterns.Any(ignorePattern => NativeImports.PathMatchSpec(filePath, FileProbe.NormalizeFilePath(ignorePattern))))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
         private string GetBlanketScriptName(IFrameworkDefinition def, ChutzpahTestSettingsFile settingsFile)
         {
             return def.GetBlanketScriptName(settingsFile);

Chutzpah/Coverage/ICoverageEngine.cs

@@ -45,6 +45,19 @@ public interface ICoverageEngine
         /// is done with the <c>PathMatchSpec</c> Windows function.
         void AddExcludePatterns(IEnumerable<string> excludePatterns);
 
+        /// <summary>
+        /// Add file name pattern that, if set, a file must NOT match to be included in results. Pattern matching
+        /// is done with the <c>PathMatchSpec</c> Windows function.
+        /// </summary>
+        void AddIgnorePatterns(IEnumerable<string> ignorePatterns);
+
+        /// <summary>
+        /// Returns true if the path should not be included in results, false otherwise.
+        /// </summary>
+        /// <param name="filePath">The path to test.</param>
+        /// <returns></returns>
+        bool IsIgnored(string filePath);
+
         /// <summary>
         /// Reset patterns between runs, this is to prevent caching old configurations
         /// </summary>

Chutzpah/CoverageOptions.cs

@@ -12,6 +12,7 @@ public CoverageOptions()
         {
             IncludePatterns = new List<string>();
             ExcludePatterns = new List<string>();
+            IgnorePatterns = new List<string>();
         }
 
         /// <summary>
@@ -29,6 +30,11 @@ public CoverageOptions()
         /// </summary>
         public ICollection<string> ExcludePatterns { get; set; }
 
+        /// <summary>
+        /// If specified, pattern of files to exclude from the results phase.
+        /// </summary>
+        public ICollection<string> IgnorePatterns { get; set; }
+
         public bool ShouldRunCoverage(CodeCoverageExecutionMode? coverageExecutionModeSetting)
         {
             // If not set or set to manual honor the passed in value from the user

Chutzpah/Models/ChutzpahTestSettingsFile.cs

@@ -56,6 +56,7 @@ public ChutzpahTestSettingsFile()
         {
             CodeCoverageIncludes = new List<string>();
             CodeCoverageExcludes = new List<string>();
+            CodeCoverageIgnores = new List<string>();
             References = new List<SettingsFileReference>();
             Tests = new List<SettingsFileTestPath>();
             Transforms = new List<TransformConfig>();
@@ -209,6 +210,11 @@ private ChutzpahTestSettingsFile(bool isDefaultSetings) : this()
         /// </summary>
         public ICollection<string> CodeCoverageExcludes { get; set; }
 
+        /// <summary>
+        /// The collection code coverage file patterns to ignore in coverage. These are in glob format. If you specify none no files are excluded.
+        /// </summary>
+        public ICollection<string> CodeCoverageIgnores { get; set; }
+
         /// <summary>
         /// The collection of test files. These can list individual tests or folders scanned recursively. This setting can work in two ways:
         /// 1. If you run tests normally by specifying folders/files then this settings will filter the sets of those files.
@@ -341,6 +347,7 @@ public ChutzpahTestSettingsFile InheritFrom(ChutzpahTestSettingsFile parent)
             this.References = parent.References.Concat(this.References).ToList();
             this.CodeCoverageIncludes = parent.CodeCoverageIncludes.Concat(this.CodeCoverageIncludes).ToList();
             this.CodeCoverageExcludes = parent.CodeCoverageExcludes.Concat(this.CodeCoverageExcludes).ToList();
+            this.CodeCoverageIgnores = parent.CodeCoverageIgnores.Concat(this.CodeCoverageIgnores).ToList();
             this.Transforms = parent.Transforms.Concat(this.Transforms).ToList();
 
             if (this.Compile == null)

Chutzpah/TestContextBuilder.cs

@@ -417,6 +417,7 @@ private ICoverageEngine GetConfiguredCoverageEngine(TestOptions options, Chutzpa
             coverageEngine.ClearPatterns();
             coverageEngine.AddIncludePatterns(chutzpahTestSettings.CodeCoverageIncludes.Concat(options.CoverageOptions.IncludePatterns));
             coverageEngine.AddExcludePatterns(chutzpahTestSettings.CodeCoverageExcludes.Concat(options.CoverageOptions.ExcludePatterns));
+            coverageEngine.AddIgnorePatterns(chutzpahTestSettings.CodeCoverageIgnores.Concat(options.CoverageOptions.IgnorePatterns));
             return coverageEngine;
         }
 

ConsoleRunner/CommandLine.cs

@@ -58,9 +58,11 @@ protected CommandLine(string[] args)
         public bool Coverage { get; protected set; }
 
         public string CoverageIncludePatterns { get; protected set; }
-        
+
         public string CoverageExcludePatterns { get; protected set; }
 
+        public string CoverageIgnorePatterns { get; protected set; }
+
         public string BrowserName { get; protected set; }
 
         private static void GuardNoOptionValue(KeyValuePair<string, string> option)
@@ -165,6 +167,10 @@ protected void Parse()
                 {
                     AddCoverageExcludeOption(option.Value);
                 }
+                else if (optionName == "/coverageignores")
+                {
+                    AddCoverageIgnoreOption(option.Value);
+                }
                 else if (optionName == "/showfailurereport")
                 {
                     GuardNoOptionValue(option);
@@ -207,6 +213,16 @@ private void AddCoverageExcludeOption(string value)
             CoverageExcludePatterns = value;
         }
 
+        private void AddCoverageIgnoreOption(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+            {
+                throw new ArgumentException(
+                    "invalid or missing argument for /coverageIgnores.  Expecting a list of comma separated file name patterns");
+            }
+            CoverageIgnorePatterns = value;
+        }
+
         private void AddParallelismOption(string value)
         {
             int parallelism;

ConsoleRunner/Program.cs

@@ -148,7 +148,8 @@ static int RunTests(CommandLine commandLine)
                                               {
                                                   Enabled = commandLine.Coverage,
                                                   IncludePatterns = (commandLine.CoverageIncludePatterns ?? "").Split(new[]{','},StringSplitOptions.RemoveEmptyEntries),
-                                                  ExcludePatterns = (commandLine.CoverageExcludePatterns ?? "").Split(new[]{','},StringSplitOptions.RemoveEmptyEntries)
+                                                  ExcludePatterns = (commandLine.CoverageExcludePatterns ?? "").Split(new[]{','},StringSplitOptions.RemoveEmptyEntries),
+                                                  IgnorePatterns = (commandLine.CoverageIgnorePatterns ?? "").Split(new[]{','},StringSplitOptions.RemoveEmptyEntries)
                                               }
                     };
 

Facts.Integration/Coverage.cs

@@ -438,6 +438,21 @@ public void Will_exclude_given_file_patterns(string scriptPath)
                                    });
         }
 
+        [Theory]
+        [PropertyData("AmdTestScriptWithForcedRequire")]
+        public void Will_ignore_only_given_file_patterns(string scriptPath)
+        {
+            var testRunner = TestRunner.Create();
+
+            var result = testRunner.RunTests(scriptPath, WithCoverage(co => { co.IncludePatterns = new[] { "*\\ui\\*", "*core.js" }; co.IgnorePatterns = new[] { "tests\\*" }; }), new ExceptionThrowingRunnerCallback());
+
+            ExpectKeysMatching(result.TestFileSummaries.Single().CoverageObject,
+                               new[]
+                                   {
+                                      "\\base\\core.js", "ui\\screen.js"
+                                   });
+        }
+
         [Theory]
         [PropertyData("AmdTestScriptWithForcedRequire")]
         public void Will_resolve_requirejs_required_files_correctly(string scriptPath)

Facts/ConsoleRunner/CommandLineFacts.cs

@@ -590,6 +590,16 @@ public void CoverageExclude_Option_Not_Passed_CoverageExcludePattern_Null()
                 Assert.Null(commandLine.CoverageExcludePatterns);
             }
 
+            [Fact]
+            public void CoverageExclude_Option_Not_Passed_CoverageIgnorePattern_Null()
+            {
+                var arguments = new[] { "test.html" };
+
+                var commandLine = TestableCommandLine.Create(arguments);
+
+                Assert.Null(commandLine.CoverageIgnorePatterns);
+            }
+
             [Fact]
             public void CoverageInclude_Option_With_Value_CoverageIncludePattern_Set()
             {
@@ -610,6 +620,16 @@ public void CoverageExclude_Option_With_Value_CoverageExcludePattern_Set()
                 Assert.Equal("*.coffee", commandLine.CoverageExcludePatterns);
             }
 
+            [Fact]
+            public void CoverageExclude_Option_With_Value_CoverageIgnorePattern_Set()
+            {
+                var arguments = new[] { "test.html", "/coverageIgnores", "*.ts" };
+
+                var commandLine = TestableCommandLine.Create(arguments);
+
+                Assert.Equal("*.ts", commandLine.CoverageIgnorePatterns);
+            }
+
             [Fact]
             public void Will_throw_if_no_arg_given_to_CoverageInclude()
             {

Facts/Library/Models/ChutzpahTestSettingsServiceFacts.cs

@@ -241,7 +241,8 @@ public void Will_inherit_all_parent_settings_when_none_set_on_child()
                 References = new List<SettingsFileReference> { new SettingsFileReference { Path = "parentReferencePath" } },
                 Transforms = new List<TransformConfig>{ new TransformConfig{ Path = "parentTransformPath"}},
                 CodeCoverageExcludes = new List<string>{"parentCodeCoverageExcludePath"},
-                CodeCoverageIncludes = new List<string>{"parentCodeCoverageIncludePath"},
+                CodeCoverageIncludes = new List<string> { "parentCodeCoverageIncludePath" },
+                CodeCoverageIgnores = new List<string> { "parentCodeCoverageIgnorePath" },
                 Compile = new BatchCompileConfiguration{ Mode = BatchCompileMode.External},
 
                 AMDBasePath = "parentAmdBasePath",
@@ -277,6 +278,7 @@ public void Will_inherit_all_parent_settings_when_none_set_on_child()
             Assert.Equal(1, childSettings.Transforms.Count);
             Assert.Equal(1, childSettings.CodeCoverageIncludes.Count);
             Assert.Equal(1, childSettings.CodeCoverageExcludes.Count);
+            Assert.Equal(1, childSettings.CodeCoverageIgnores.Count);
 
             Assert.Equal(parentSettings.Compile, childSettings.Compile);
             Assert.Equal(@"C:\settingsDir", childSettings.SettingsFileDirectory);
@@ -305,7 +307,8 @@ public void Will_merge_list_settings_and_set_settings_dir_property_for_applicabl
                 References = new List<SettingsFileReference> { new SettingsFileReference { Path = "parentReferencePath" } },
                 Transforms = new List<TransformConfig> { new TransformConfig { Path = "parentTransformPath" } },
                 CodeCoverageExcludes = new List<string> { "parentCodeCoverageExcludePath" },
-                CodeCoverageIncludes = new List<string> { "parentCodeCoverageIncludePath" }
+                CodeCoverageIncludes = new List<string> { "parentCodeCoverageIncludePath" },
+                CodeCoverageIgnores = new List<string> { "parentCodeCoverageIgnorePath" }
             };
 
             var childSettings = new ChutzpahTestSettingsFile
@@ -315,7 +318,8 @@ public void Will_merge_list_settings_and_set_settings_dir_property_for_applicabl
                 References = new List<SettingsFileReference> { new SettingsFileReference { Path = "childReferencePath" } },
                 Transforms = new List<TransformConfig> { new TransformConfig { Path = "childTransformPath" } },
                 CodeCoverageExcludes = new List<string> { "childCodeCoverageExcludePath" },
-                CodeCoverageIncludes = new List<string> { "childCodeCoverageIncludePath" }
+                CodeCoverageIncludes = new List<string> { "childCodeCoverageIncludePath" },
+                CodeCoverageIgnores = new List<string> { "childCodeCoverageIgnorePath" }
             };
 
             service.Mock<IFileProbe>().Setup(x => x.FindTestSettingsFile(@"C:\settingsDir")).Returns(@"C:\settingsDir\settingsFile.json");
@@ -348,6 +352,9 @@ public void Will_merge_list_settings_and_set_settings_dir_property_for_applicabl
             Assert.Equal(2, childSettings.CodeCoverageExcludes.Count);
             Assert.Equal("parentCodeCoverageExcludePath", childSettings.CodeCoverageExcludes.ElementAt(0));
             Assert.Equal("childCodeCoverageExcludePath", childSettings.CodeCoverageExcludes.ElementAt(1));
+            Assert.Equal(2, childSettings.CodeCoverageIgnores.Count);
+            Assert.Equal("parentCodeCoverageIgnorePath", childSettings.CodeCoverageIgnores.ElementAt(0));
+            Assert.Equal("childCodeCoverageIgnorePath", childSettings.CodeCoverageIgnores.ElementAt(1));
         }
 
         [Fact]