Logging concept

src/coverlet.core/Coverage.cs

@@ -30,14 +30,14 @@ public void PrepareModules()
         {
             string[] modules = InstrumentationHelper.GetCoverableModules(_module);
             string[] excludedFiles =  InstrumentationHelper.GetExcludedFiles(_rules);
-            _filters = _filters?.Where(f => InstrumentationHelper.IsValidFilterExpression(f)).ToArray();
+            _filters = _filters?.Where(InstrumentationHelper.IsValidFilterExpression).ToArray();
 
             foreach (var module in modules)
             {
                 if (InstrumentationHelper.IsModuleExcluded(module, _filters))
                     continue;
 
-                var instrumenter = new Instrumenter(module, _identifier, _filters, excludedFiles);
+                var instrumenter = InstrumenterFactory.Create(module, _identifier, _filters, excludedFiles);
                 if (instrumenter.CanInstrument())
                 {
                     InstrumentationHelper.BackupOriginalModule(module, _identifier);

src/coverlet.core/Instrumentation/IInstrumenter.cs

@@ -0,0 +1,9 @@
+namespace Coverlet.Core.Instrumentation
+{
+    internal interface IInstrumenter
+    {
+        bool CanInstrument();
+
+        InstrumenterResult Instrument();
+    }
+}

src/coverlet.core/Instrumentation/Instrumenter.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -14,7 +13,7 @@
 
 namespace Coverlet.Core.Instrumentation
 {
-    internal class Instrumenter
+    internal class Instrumenter  : IInstrumenter
     {
         private readonly string _module;
         private readonly string _identifier;
@@ -116,7 +115,7 @@ private void InstrumentIL(MethodDefinition method)
                 var instruction = processor.Body.Instructions[index];
                 var sequencePoint = method.DebugInformation.GetSequencePoint(instruction);
                 var targetedBranchPoints = branchPoints.Where(p => p.EndOffset == instruction.Offset);
-                
+
                 if (sequencePoint != null && !sequencePoint.IsHidden)
                 {
                     var target = AddInstrumentationCode(method, processor, instruction, sequencePoint);
@@ -139,7 +138,7 @@ private void InstrumentIL(MethodDefinition method)
                         */
                     if (_branchTarget.StartLine == -1 || _branchTarget.Document == null)
                         continue;
-                    
+
                     var target = AddInstrumentationCode(method, processor, instruction, _branchTarget);
                     foreach (var _instruction in processor.Body.Instructions)
                         ReplaceInstructionTarget(_instruction, instruction, target);

src/coverlet.core/Instrumentation/InstrumenterFactory.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+namespace Coverlet.Core.Instrumentation
+{
+    internal static class InstrumenterFactory
+    {
+        private static readonly List<Func<IInstrumenter, IInstrumenter>>  DecoratorFunctions = new List<Func<IInstrumenter, IInstrumenter>>();
+
+        public static IInstrumenter Create(string module, string identifier, string[] filters, string[] excludedFiles)
+        {
+            IInstrumenter result = new Instrumenter(module, identifier, filters, excludedFiles);
+
+            // Decorate the real Instrumenter instance
+            foreach (var decoratorFunc in DecoratorFunctions)
+                result = decoratorFunc.Invoke(result);
+
+            return result;
+        }
+
+        public static void RegisterDecorator(Func<IInstrumenter, IInstrumenter> decoratingFunc)
+        {
+            if (decoratingFunc == null)
+                throw new ArgumentNullException(nameof(decoratingFunc));
+
+            DecoratorFunctions.Add(decoratingFunc);
+        }
+    }
+}

src/coverlet.core/Logging/ConsoleLogger.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Coverlet.Core.Logging
+{
+    public class ConsoleLogger : ILogger
+    {
+        private ConsoleLogger()
+        {
+        }
+
+        public static ILogger Instance { get; } = new ConsoleLogger();
+
+        public void Log(string text)
+        {
+            if (text == null)
+                return;
+
+            Console.WriteLine(text);
+        }
+    }
+}

src/coverlet.core/Logging/Decorators/InstrumenterLoggerDecorator.cs

@@ -0,0 +1,29 @@
+using Coverlet.Core.Instrumentation;
+using Coverlet.Core.Logging;
+
+namespace coverlet.core.Logging.Decorators
+{
+    internal class InstrumenterLoggerDecorator : IInstrumenter
+    {
+        private readonly IInstrumenter _decoratee;
+        private readonly ILogger _logger;
+
+        public InstrumenterLoggerDecorator(IInstrumenter decoratee, ILogger logger)
+        {
+            _decoratee = decoratee;
+            _logger = logger;
+        }
+
+        public bool CanInstrument()
+        {
+            return _decoratee.CanInstrument();
+        }
+
+        public InstrumenterResult Instrument()
+        {
+            var result = _decoratee.Instrument();
+            _logger.Log($"Module {result.Module} was instrumented.");
+            return result;
+        }
+    }
+}

src/coverlet.core/Logging/EnableLogging.cs

@@ -0,0 +1,15 @@
+using coverlet.core.Logging.Decorators;
+using Coverlet.Core.Instrumentation;
+using Coverlet.Core.Logging;
+
+namespace coverlet.core.Logging
+{
+    public static class EnableLogging
+    {
+        public static void Execute()
+        {
+            LoggerFactory.GetLogger().Log("Logging enabled.");
+            InstrumenterFactory.RegisterDecorator(instrumenter => new InstrumenterLoggerDecorator(instrumenter, LoggerFactory.GetLogger()));
+        }
+    }
+}

src/coverlet.core/Logging/ILogger.cs

@@ -0,0 +1,7 @@
+namespace Coverlet.Core.Logging
+{
+    public interface ILogger
+    {
+        void Log(string text);
+    }
+}

src/coverlet.core/Logging/LoggerFactory.cs

@@ -0,0 +1,10 @@
+namespace Coverlet.Core.Logging
+{
+    public static class LoggerFactory
+    {
+        public static ILogger GetLogger()
+        {
+            return ConsoleLogger.Instance;
+        }
+    }
+}

src/coverlet.msbuild.tasks/InstrumentationTask.cs

@@ -1,4 +1,5 @@
 using System;
+using coverlet.core.Logging;
 using Coverlet.Core;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
@@ -23,7 +24,7 @@ public string Path
             get { return _path; }
             set { _path = value; }
         }
-        
+
         public string Exclude
         {
             get { return _exclude; }
@@ -36,13 +37,18 @@ public string ExcludeByFile
             set { _excludeByFile = value; }
         }
 
+        public bool Verbose { get; set; }
+
         public override bool Execute()
         {
             try
             {
                 var rules = _excludeByFile?.Split(',');
                 var filters = _exclude?.Split(',');
 
+                if (Verbose)
+                    EnableLogging.Execute();
+
                 _coverage = new Coverage(_path, Guid.NewGuid().ToString(), filters, rules);
                 _coverage.PrepareModules();
             }

test/coverlet.core.tests/Logging/ConsoleLoggerTests.cs

@@ -0,0 +1,45 @@
+using System;
+using System.IO;
+using Coverlet.Core.Logging;
+using Xunit;
+
+namespace Coverlet.Core.Tests.Logging
+{
+    public class ConsoleLoggerTests
+    {
+        private readonly TextWriter _textWriter;
+
+        public ConsoleLoggerTests()
+        {
+            _textWriter = new StringWriter();
+            Console.SetOut(_textWriter);
+        }
+
+        [Fact]
+        public void TestConsoleLoggerLogShouldWriteMessageToConsole()
+        {
+            // arrange
+            const string message = "this is a test message";
+
+            // act
+            ConsoleLogger.Instance.Log(message);
+
+            // assert
+            _textWriter.Flush();
+            Assert.Equal($"{message}{Environment.NewLine}" , _textWriter.ToString());
+        }
+
+        [Fact]
+        public void TestConsoleLoggerLogShouldWriteNothingWhenMessageIsNull()
+        {
+            // arrange
+
+            // act
+            ConsoleLogger.Instance.Log(null);
+
+            // assert
+            _textWriter.Flush();
+            Assert.Empty(_textWriter.ToString());
+        }
+    }
+}

test/coverlet.core.tests/Logging/Decorators/InstrumenterLoggerDecoratorTests.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Text;
+using coverlet.core.Logging.Decorators;
+using Coverlet.Core.Instrumentation;
+using Coverlet.Core.Logging;
+using Xunit;
+
+namespace Coverlet.Core.Tests.Logging.Decorators
+{
+    public class InstrumenterLoggerDecoratorTests
+    {
+        private readonly FakeInstumenter _decoratee;
+        private readonly FakeLogger _logger;
+        private readonly InstrumenterLoggerDecorator _sut;
+
+        public InstrumenterLoggerDecoratorTests()
+        {
+            _decoratee = new FakeInstumenter();
+            _logger = new FakeLogger();
+            _sut = new InstrumenterLoggerDecorator(_decoratee, _logger);
+        }
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void TestCanInstrumentIsForwardedToDecoratee(bool setupCanInstrument)
+        {
+            // arrange
+            var canInstrumentCalled = false;
+            _decoratee.SetCanInstrument(() =>
+            {
+                canInstrumentCalled = true;
+                return setupCanInstrument;
+            });
+
+            // act
+            var result = _sut.CanInstrument();
+
+            // assert
+            Assert.True(canInstrumentCalled);
+            Assert.Equal(setupCanInstrument, result);
+        }
+
+
+        [Fact]
+        public void TestInstrumentIsForwardedToDecorateeAndLoggedInLogger()
+        {
+            // arrange
+            var setupResult = new InstrumenterResult { Module = "m0dule"};
+            var instrumentCalled = false;
+            _decoratee.SetInstrument(() =>
+            {
+                instrumentCalled = true;
+                return setupResult;
+            });
+
+            // act
+            var result = _sut.Instrument();
+
+            // assert
+            Assert.True(instrumentCalled);
+            Assert.Equal(setupResult, result);
+            Assert.Equal($"Module {result.Module} was instrumented.{Environment.NewLine}", _logger.ToString());
+        }
+    }
+
+    public class FakeLogger : ILogger
+    {
+        private readonly StringBuilder _sb;
+
+        public FakeLogger()
+        {
+            _sb = new StringBuilder();
+        }
+
+        public void Log(string text)
+        {
+            _sb.AppendLine(text);
+        }
+
+        public override string ToString()
+        {
+            return _sb.ToString();
+        }
+    }
+
+    internal class FakeInstumenter : IInstrumenter
+    {
+        private Func<bool> _canInstrument = () => throw new NotImplementedException();
+        private Func<InstrumenterResult> _instrumenterResult = () => throw new NotImplementedException();
+
+        public void SetCanInstrument(Func<bool> func)
+        {
+            _canInstrument = func ?? throw new ArgumentNullException(nameof(func));
+        }
+
+        public bool CanInstrument()
+        {
+            return _canInstrument.Invoke();
+        }
+
+        public void SetInstrument(Func<InstrumenterResult> instrumenterResult)
+        {
+            _instrumenterResult = instrumenterResult ?? throw new ArgumentNullException(nameof(instrumenterResult));
+        }
+
+        public InstrumenterResult Instrument()
+        {
+            return _instrumenterResult.Invoke();
+        }
+
+    }
+}