Merge pull request #68 from sjp/extra-coverage

tonerdo · web-flow · commit 9435f73261ce · 2018-05-01T21:49:21.000+01:00
Additional coverage reporting for properties and nested types
diff --git a/src/coverlet.core/Attributes/ExcludeFromCoverage.cs b/src/coverlet.core/Attributes/ExcludeFromCoverage.cs
@@ -2,6 +2,6 @@
 
 namespace Coverlet.Core.Attributes
 {
-    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor)]
-    public class ExcludeFromCoverageAttribute : Attribute { }
+    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Method | AttributeTargets.Constructor)]
+    public sealed class ExcludeFromCoverageAttribute : Attribute { }
 }
diff --git a/src/coverlet.core/Helpers/InstrumentationHelper.cs b/src/coverlet.core/Helpers/InstrumentationHelper.cs
@@ -2,10 +2,10 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Reflection.PortableExecutable;
-using Microsoft.Extensions.FileSystemGlobbing;
 
-using Coverlet.Core.Instrumentation;
+using Microsoft.Extensions.FileSystemGlobbing;
 using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
 
 namespace Coverlet.Core.Helpers
@@ -15,7 +15,7 @@ internal static class InstrumentationHelper
         public static string[] GetDependencies(string module)
         {
             IEnumerable<string> modules = Directory.GetFiles(Path.GetDirectoryName(module), "*.dll");
-            modules = modules.Where(a => Path.GetFileName(a) != Path.GetFileName(module));
+            modules = modules.Where(a => IsAssembly(a) && Path.GetFileName(a) != Path.GetFileName(module));
             return modules.ToArray();
         }
 
@@ -41,39 +41,29 @@ public static bool HasPdb(string module)
         public static void CopyCoverletDependency(string module)
         {
             var directory = Path.GetDirectoryName(module);
-            if (Path.GetFileNameWithoutExtension(module) == "coverlet.core")
-                return;
+            var moduleFileName = Path.GetFileName(module);
 
             var assembly = typeof(Coverage).Assembly;
             string name = Path.GetFileName(assembly.Location);
+            if (name == moduleFileName)
+                return;
+
             File.Copy(assembly.Location, Path.Combine(directory, name), true);
         }
 
         public static void BackupOriginalModule(string module, string identifier)
         {
-            var backupPath = Path.Combine(
-                Path.GetTempPath(),
-                Path.GetFileNameWithoutExtension(module) + "_" + identifier + ".dll"
-            );
-
+            var backupPath = GetBackupPath(module, identifier);
             File.Copy(module, backupPath);
         }
 
         public static void RestoreOriginalModule(string module, string identifier)
         {
-            var backupPath = Path.Combine(
-                Path.GetTempPath(),
-                Path.GetFileNameWithoutExtension(module) + "_" + identifier + ".dll"
-            );
+            var backupPath = GetBackupPath(module, identifier);
 
             // Restore the original module - retry up to 10 times, since the destination file could be locked
             // See: https://github.com/tonerdo/coverlet/issues/25
-            var currentSleep = 6;
-            Func<TimeSpan> retryStrategy = () => {
-                var sleep = TimeSpan.FromMilliseconds(currentSleep);
-                currentSleep *= 2;
-                return sleep;
-            };
+            var retryStrategy = CreateRetryStrategy();
 
             RetryHelper.Retry(() => {
                 File.Copy(backupPath, module, true);
@@ -85,13 +75,7 @@ public static IEnumerable<string> ReadHitsFile(string path)
         {
             // Retry hitting the hits file - retry up to 10 times, since the file could be locked
             // See: https://github.com/tonerdo/coverlet/issues/25
-            var currentSleep = 6;
-            Func<TimeSpan> retryStrategy = () =>
-            {
-                var sleep = TimeSpan.FromMilliseconds(currentSleep);
-                currentSleep *= 2;
-                return sleep;
-            };
+            var retryStrategy = CreateRetryStrategy();
 
             return RetryHelper.Do(() => File.ReadLines(path), retryStrategy, 10);
         }
@@ -100,39 +84,33 @@ public static void DeleteHitsFile(string path)
         {
             // Retry hitting the hits file - retry up to 10 times, since the file could be locked
             // See: https://github.com/tonerdo/coverlet/issues/25
-            var currentSleep = 6;
-            Func<TimeSpan> retryStrategy = () => {
-                var sleep = TimeSpan.FromMilliseconds(currentSleep);
-                currentSleep *= 2;
-                return sleep;
-            };
+            var retryStrategy = CreateRetryStrategy();
 
             RetryHelper.Retry(() => File.Delete(path), retryStrategy, 10);
         }
-        
-        public static IEnumerable<string> GetExcludedFiles(IEnumerable<string> excludeRules, 
-                                                           string parentDir = null) 
+
+        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)
             {
@@ -144,9 +122,42 @@ public static IEnumerable<string> GetExcludedFiles(IEnumerable<string> excludeRu
                     .Select(f => Path.GetFullPath(Path.Combine(directoryInfo.ToString(), f.Path)));
                 files.AddRange(currentFiles);
             }
-            
+
             return files.Distinct();
         }
+
+        private static bool IsAssembly(string filePath)
+        {
+            try
+            {
+                AssemblyName.GetAssemblyName(filePath);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        private static string GetBackupPath(string module, string identifier)
+        {
+            return Path.Combine(
+                Path.GetTempPath(),
+                Path.GetFileNameWithoutExtension(module) + "_" + identifier + ".dll"
+            );
+        }
+
+        private static Func<TimeSpan> CreateRetryStrategy(int initialSleepSeconds = 6)
+        {
+            TimeSpan retryStrategy()
+            {
+                var sleep = TimeSpan.FromMilliseconds(initialSleepSeconds);
+                initialSleepSeconds *= 2;
+                return sleep;
+            }
+
+            return retryStrategy;
+        }
     }
 }
 
diff --git a/src/coverlet.core/Helpers/RetryHelper.cs b/src/coverlet.core/Helpers/RetryHelper.cs
@@ -2,56 +2,60 @@
 using System.Collections.Generic;
 using System.Threading;
 
-// A slightly amended version of the code found here: https://stackoverflow.com/a/1563234/186184
-// This code allows for varying backoff strategies through the use of Func<TimeSpan>.
-public static class RetryHelper
+namespace Coverlet.Core
 {
-    /// <summary>
-    /// Retry a void method.
-    /// </summary>
-    /// <param name="action">The action to perform</param>
-    /// <param name="backoffStrategy">A function returning a Timespan defining the backoff strategy to use.</param>
-    /// <param name="maxAttemptCount">The maximum number of retries before bailing out. Defaults to 3.</param>
-    public static void Retry(
-        Action action,
-        Func<TimeSpan> backoffStrategy,
-        int maxAttemptCount = 3)
+    // A slightly amended version of the code found here: https://stackoverflow.com/a/1563234/186184
+    // This code allows for varying backoff strategies through the use of Func<TimeSpan>.
+    public static class RetryHelper
     {
-        Do<object>(() =>
+        /// <summary>
+        /// Retry a void method.
+        /// </summary>
+        /// <param name="action">The action to perform</param>
+        /// <param name="backoffStrategy">A function returning a Timespan defining the backoff strategy to use.</param>
+        /// <param name="maxAttemptCount">The maximum number of retries before bailing out. Defaults to 3.</param>
+        public static void Retry(
+            Action action,
+            Func<TimeSpan> backoffStrategy,
+            int maxAttemptCount = 3)
         {
-            action();
-            return null;
-        }, backoffStrategy, maxAttemptCount);
-    }
-
-    /// <summary>
-    /// Retry a method returning type T.
-    /// </summary>
-    /// <param name="action">The action to perform</param>
-    /// <param name="backoffStrategy">A function returning a Timespan defining the backoff strategy to use.</param>
-    /// <param name="maxAttemptCount">The maximum number of retries before bailing out. Defaults to 3.</param>
-    public static T Do<T>(
-        Func<T> action,
-        Func<TimeSpan> backoffStrategy,
-        int maxAttemptCount = 3)
-    {
-        var exceptions = new List<Exception>();
+            Do<object>(() =>
+            {
+                action();
+                return null;
+            }, backoffStrategy, maxAttemptCount);
+        }
 
-        for (int attempted = 0; attempted < maxAttemptCount; attempted++)
+        /// <summary>
+        /// Retry a method returning type T.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to return</typeparam>
+        /// <param name="action">The action to perform</param>
+        /// <param name="backoffStrategy">A function returning a Timespan defining the backoff strategy to use.</param>
+        /// <param name="maxAttemptCount">The maximum number of retries before bailing out. Defaults to 3.</param>
+        public static T Do<T>(
+            Func<T> action,
+            Func<TimeSpan> backoffStrategy,
+            int maxAttemptCount = 3)
         {
-            try
+            var exceptions = new List<Exception>();
+
+            for (int attempted = 0; attempted < maxAttemptCount; attempted++)
             {
-                if (attempted > 0)
+                try
                 {
-                    Thread.Sleep(backoffStrategy());
+                    if (attempted > 0)
+                    {
+                        Thread.Sleep(backoffStrategy());
+                    }
+                    return action();
+                }
+                catch (Exception ex)
+                {
+                    exceptions.Add(ex);
                 }
-                return action();
-            }
-            catch (Exception ex)
-            {
-                exceptions.Add(ex);
             }
+            throw new AggregateException(exceptions);
         }
-        throw new AggregateException(exceptions);
     }
 }
diff --git a/src/coverlet.core/Instrumentation/Instrumenter.cs b/src/coverlet.core/Instrumentation/Instrumenter.cs

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@`
`2`	`2`
`3`	`3`	`namespace Coverlet.Core.Attributes`
`4`	`4`	`{`
`5`		`- [AttributeUsage(AttributeTargets.Method \| AttributeTargets.Constructor)]`
`6`		`- public class ExcludeFromCoverageAttribute : Attribute { }`
	`5`	`+ [AttributeUsage(AttributeTargets.Property \| AttributeTargets.Method \| AttributeTargets.Constructor)]`
	`6`	`+ public sealed class ExcludeFromCoverageAttribute : Attribute { }`
`7`	`7`	`}`