refactor and tests for OpenCover

Author: tonyhallett

FineCodeCoverageTests/OpenCoverExeArgumentsProvider_Tests.cs

@@ -1,8 +1,10 @@
 using FineCodeCoverage.Engine.Model;
 using FineCodeCoverage.Engine.OpenCover;
 using FineCodeCoverage.Options;
+using Microsoft.VisualStudio.Experimentation;
 using Moq;
 using NUnit.Framework;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -95,16 +97,62 @@ public void Should_Safely_Include_The_TestDLLFile_In_The_TargetArgs()
         }
 
         [Test]
-        public void Should_Include_The_Test_Assembly_In_The_Filter_When_AppOptions_IncludeTestAssembly()
+        public void Should_Include_The_Test_Assembly_In_The_Filter_When_AppOptions_IncludeTestAssembly_And_Required()
         {
             var openCoverExeArgumentsProvider = new OpenCoverExeArgumentsProvider();
             var mockCoverageProject = SafeMockCoverageProject();
             mockCoverageProject.SetupGet(coverageProject => coverageProject.Settings.IncludeTestAssembly).Returns(true);
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.Settings.Include).Returns(new string[] { "[anassembly]*"});
             mockCoverageProject.SetupGet(coverageProject => coverageProject.ProjectName).Returns("TheTestName");
 
             var arguments = openCoverExeArgumentsProvider.Provide(mockCoverageProject.Object, "");
 
-            AssertHasEscapedSetting(arguments, "-filter:+[TheTestName]*");
+            var filters = GetFilters(arguments);
+            Assert.That(filters, Is.EquivalentTo(new string[] { "+[TheTestName]*", "+[anassembly]*" }));
+        }
+
+        [Test]
+        public void Should_Not_Include_The_Test_Assembly_In_The_Filter_When_AppOptions_IncludeTestAssembly_And_No_Other_Includes()
+        {
+            var openCoverExeArgumentsProvider = new OpenCoverExeArgumentsProvider();
+            var mockCoverageProject = SafeMockCoverageProject();
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.Settings.IncludeTestAssembly).Returns(true);
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.ProjectName).Returns("TheTestName");
+
+            var arguments = openCoverExeArgumentsProvider.Provide(mockCoverageProject.Object, "");
+
+            var filters = GetFilters(arguments);
+            Assert.IsEmpty(GetFilters(arguments));
+        }
+
+        [Test]
+        public void Should_Not_Include_The_Test_Assembly_In_The_Filter_When_AppOptions_IncludeTestAssembly_And_Explicitly_Excluded()
+        {
+            var openCoverExeArgumentsProvider = new OpenCoverExeArgumentsProvider();
+            var mockCoverageProject = SafeMockCoverageProject();
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.Settings.IncludeTestAssembly).Returns(true);
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.Settings.Include).Returns(new string[] { "[anassembly]*" });
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.Settings.Exclude).Returns(new string[] { "[TheTestName]*" });
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.ProjectName).Returns("TheTestName");
+
+            var arguments = openCoverExeArgumentsProvider.Provide(mockCoverageProject.Object, "");
+            var filters = GetFilters(arguments);
+            Assert.That(filters, Is.EquivalentTo(new string[] { "+[anassembly]*", "-[TheTestName]*" }));
+        }
+
+        private IEnumerable<string> GetFilters(IEnumerable<string> arguments)
+        {
+            var filterMatch = "-filter:";
+            var filter = arguments.FirstOrDefault(arg => arg.StartsWith($@"""{filterMatch}"));
+            if (filter == null)
+            {
+                return Enumerable.Empty<string>();
+            }
+            if (!filter.EndsWith("\""))
+            {
+                throw new Exception("filter should be escaped");
+            }
+            return filter.Replace("\"", "").Substring(filterMatch.Length).Split(' ');
         }
 
         [Test]

SharedProject/Core/OpenCover/OpenCoverExeArgumentsProvider.cs

@@ -62,8 +62,6 @@ private static bool HasInclusions(IEnumerable<string> includes, List<IReferenced
             return includes.Any() || includedReferencedProjects.Any();
         }
 
-        
-
         private void AddFilter(ICoverageProject project, List<string> opencoverSettings)
         {
             var includes = SanitizeExcludesOrIncludes(project.Settings.Include);
@@ -94,28 +92,19 @@ List<string> GetExcludesOrIncludes(
                 IEnumerable<string> excludesOrIncludes,IEnumerable<string> moduleExcludesOrIncludes, bool isInclude)
             {
                 var excludeOrIncludeFilters = new List<string>();
-                var prefix = IncludeSymbol(isInclude);
-                //var sanitizedExcludesOrIncludes = SanitizeExcludesOrIncludes(excludesOrIncludes);
+                var includeExcludeSymbol = isInclude ? "+" : "-";
 
                 foreach (var value in excludesOrIncludes)
                 {
-                    excludeOrIncludeFilters.Add($@"{prefix}{value}");
+                    excludeOrIncludeFilters.Add($@"{includeExcludeSymbol}{value}");
                 }
 
                 foreach (var moduleExcludeOrInclude in moduleExcludesOrIncludes)
                 {
-                    excludeOrIncludeFilters.Add(IncludeOrExcludeModule(isInclude, moduleExcludeOrInclude));
+                    excludeOrIncludeFilters.Add($"{includeExcludeSymbol}[{moduleExcludeOrInclude}]*");
                 }
                 return excludeOrIncludeFilters.Distinct().ToList();
             }
-
-            string IncludeOrExcludeModule(bool include,string moduleFilter,string classFilter = "*")
-            {
-                var filter = IncludeSymbol(include);
-                return $"{filter}[{moduleFilter}]{classFilter}";
-            }
-
-            string IncludeSymbol(bool include) => include ? "+" : "-"; 
         }
 
         private IEnumerable<string> SanitizeExcludesOrIncludes(IEnumerable<string> excludesOrIncludes)