handle parsing error and log when cannot use chosen option

FineCodeCoverage/Core/Coverlet/Console/CoverletConsoleDotnetToolsGlobalExecutor.cs

@@ -13,11 +13,13 @@ internal interface ICoverletConsoleDotnetToolsGlobalExecutor : ICoverletConsoleE
     internal class CoverletConsoleDotnetToolsGlobalExecutor : ICoverletConsoleDotnetToolsGlobalExecutor
     {
         private readonly IDotNetToolListCoverlet dotNetToolListCoverlet;
+        private readonly ILogger logger;
 
         [ImportingConstructor]
-		public CoverletConsoleDotnetToolsGlobalExecutor(IDotNetToolListCoverlet dotNetToolListCoverlet)
+		public CoverletConsoleDotnetToolsGlobalExecutor(IDotNetToolListCoverlet dotNetToolListCoverlet, ILogger logger)
         {
             this.dotNetToolListCoverlet = dotNetToolListCoverlet;
+            this.logger = logger;
         }
 		public ExecuteRequest GetRequest(ICoverageProject coverageProject, string coverletSettings)
         {
@@ -26,6 +28,7 @@ public ExecuteRequest GetRequest(ICoverageProject coverageProject, string coverl
 				var details = dotNetToolListCoverlet.Global();
 				if(details == null)
                 {
+                    logger.Log("Unable to use Coverlet console global tool");
 					return null;
                 }
 				return new ExecuteRequest

FineCodeCoverage/Core/Coverlet/Console/CoverletConsoleDotnetToolsLocalExecutor.cs

@@ -11,12 +11,14 @@ internal class CoverletConsoleDotnetToolsLocalExecutor : ICoverletConsoleDotnetT
     {
         private readonly IDotNetToolListCoverlet dotnetToolListCoverlet;
         private readonly IDotNetConfigFinder dotNetConfigFinder;
+        private readonly ILogger logger;
 
         [ImportingConstructor]
-        public CoverletConsoleDotnetToolsLocalExecutor(IDotNetToolListCoverlet dotnetToolListCoverlet, IDotNetConfigFinder dotNetConfigFinder)
+        public CoverletConsoleDotnetToolsLocalExecutor(IDotNetToolListCoverlet dotnetToolListCoverlet, IDotNetConfigFinder dotNetConfigFinder, ILogger logger)
         {
             this.dotnetToolListCoverlet = dotnetToolListCoverlet;
             this.dotNetConfigFinder = dotNetConfigFinder;
+            this.logger = logger;
         }
         public ExecuteRequest GetRequest(ICoverageProject coverageProject, string coverletSettings)
         {
@@ -35,6 +37,8 @@ public ExecuteRequest GetRequest(ICoverageProject coverageProject, string coverl
                         };
                     }
                 }
+
+                this.logger.Log("Unable to use Coverlet console local tool");
 
                 return null;
             }

FineCodeCoverage/Core/Coverlet/Console/DotNetToolListCoverlet.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.Linq;
 using FineCodeCoverage.Core.Utilities;
@@ -30,8 +31,18 @@ private CoverletToolDetails ExecuteAndParse(Func<IDotNetToolListExecutor,DotNetT
 				logger.Log($"{title} Error", result.Output);
 				return null;
 			}
-
-			var tools = parser.Parse(result.Output);
+			List<DotNetTool> tools = null;
+            try
+            {
+				tools = parser.Parse(result.Output);
+			}
+			catch (Exception)
+            {
+				var title = $"Dotnet tool list Coverlet";
+				logger.Log($"{title} Error parsing", result.Output);
+				return null;
+			}
+
 			var coverletConsoleTool = tools.FirstOrDefault(tool => tool.PackageId == CoverletPackageId);
 			if(coverletConsoleTool == null)
             {

FineCodeCoverageTests/CoverletConsole_Tests.cs

@@ -127,6 +127,19 @@ public void Should_Return_Null_If_Enabled_But_Not_Installed()
             dotNetToolListCoverlet.VerifyAll();
         }
 
+        [Test]
+        public void Should_Log_When_Enabled_And_Unsuccessful()
+        {
+            var mockCoverageProject = new Mock<ICoverageProject>();
+            mockCoverageProject.Setup(cp => cp.Settings.CoverletConsoleGlobal).Returns(true);
+            var dotNetToolListCoverlet = mocker.GetMock<IDotNetToolListCoverlet>();
+            dotNetToolListCoverlet.Setup(dotnet => dotnet.Global()).Returns((CoverletToolDetails)null);
+
+            globalExeProvider.GetRequest(mockCoverageProject.Object, null);
+            mocker.Verify<ILogger>(l => l.Log("Unable to use Coverlet console global tool"));
+
+        }
+
         private ExecuteRequest GetRequest_For_Globally_Installed_Coverlet_Console()
         {
             var mockCoverageProject = new Mock<ICoverageProject>();
@@ -300,6 +313,24 @@ public void Should_Return_Null_If_None_Of_The_DotNetConfig_Containing_Directorie
 
         }
 
+        [Test]
+        public void Shoul_Log_If_None_Of_The_DotNetConfig_Containing_Directories_Are_Local_Tool()
+        {
+            var projectOutputFolder = "projectoutputfolder";
+            var mockCoverageProject = new Mock<ICoverageProject>();
+            mockCoverageProject.Setup(cp => cp.Settings.CoverletConsoleLocal).Returns(true);
+            mockCoverageProject.Setup(cp => cp.ProjectOutputFolder).Returns(projectOutputFolder);
+
+            var mockDotNetConfigFinder = mocker.GetMock<IDotNetConfigFinder>();
+            mockDotNetConfigFinder.Setup(f => f.GetConfigDirectories(projectOutputFolder)).Returns(new List<string> { "ConfigDirectory1", "ConfigDirectory2" });
+
+            var mockDotNetToolListCoverlet = mocker.GetMock<IDotNetToolListCoverlet>();
+            mockDotNetToolListCoverlet.Setup(dotnet => dotnet.Local("ConfigDirectory1")).Returns((CoverletToolDetails)null);
+            mockDotNetToolListCoverlet.Setup(dotnet => dotnet.Local("ConfigDirectory2")).Returns((CoverletToolDetails)null);
+            localExecutor.GetRequest(mockCoverageProject.Object, null);
+            mocker.Verify<ILogger>(l => l.Log("Unable to use Coverlet console local tool"));
+        }
+
         private ExecuteRequest Get_Request_For_Local_Install(bool firstConfigDirectoryLocalInstall, bool secondConfigDirectoryLocalInstall)
         {
             var projectOutputFolder = "projectoutputfolder";

FineCodeCoverageTests/DotNetToolList_Tests.cs

@@ -85,6 +85,19 @@ public void Should_Execute_And_Parse_Global_Not_Installed()
             Assert.IsNull(coverletToolDetails);
         }
 
+        [Test]
+        public void Should_Log_Output_And_Return_Null_When_Parsing_Error()
+        {
+            var parsing = "this will be parsed";
+            var mockExecutor = mocker.GetMock<IDotNetToolListExecutor>();
+            mockExecutor.Setup(executor => executor.Global()).Returns(new DotNetToolListExecutionResult { ExitCode = 0, Output = parsing });
+            var mockParser = mocker.GetMock<IDotNetToolListParser>();
+            mockParser.Setup(parser => parser.Parse(parsing)).Throws(new System.Exception());
+            var coverletToolDetails = dotNetToolListCoverlet.Global();
+            Assert.IsNull(coverletToolDetails);
+            mocker.Verify<ILogger>(l => l.Log("Dotnet tool list Coverlet Error parsing", parsing));
+        }
+
         [Test]
         public void Should_Log_Output_When_Executor_Error()
         {