Merge pull request #384 from tonyhallett/fix-excludebyattribute-coverlet-unqualified-only

Fix excludebyattribute coverlet unqualified only

Author: tonyhallett

FineCodeCoverageTests/CoverletConsole_Tests.cs

@@ -1,36 +1,70 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using AutoMoq;
 using FineCodeCoverage.Core.Utilities;
 using FineCodeCoverage.Engine.Coverlet;
 using FineCodeCoverage.Engine.Model;
+using FineCodeCoverage.Engine.OpenCover;
 using FineCodeCoverage.Options;
 using Moq;
 using NUnit.Framework;
 
 namespace Test
 {
-    public class CoverletConsoleUtil_Tests
+
+    public class CoverletExeArgumentsProvider_Tests
     {
-        private AutoMoqer mocker;
-        private CoverletConsoleUtil coverletConsoleUtil;
+        [Test]
+        public void Should_Have_ExcludeByAttribute_Setting_For_Each_ExcludeByAttribute()
+        {
+            var mockCoverageProject = SafeMockCoverageProject();
+            mockCoverageProject.SetupGet(cp => cp.Settings.ExcludeByAttribute).Returns(new[] { "ExcludeByAttribute1", "ExcludeByAttribute2" });
 
-        [SetUp]
-        public void SetUp()
+            var coverletExeArgumentsProvider = new CoverletExeArgumentsProvider();
+            var coverletSettings = coverletExeArgumentsProvider.GetArguments(mockCoverageProject.Object);
+
+            AssertHasSetting(coverletSettings, "--exclude-by-attribute ExcludeByAttribute1");
+            AssertHasSetting(coverletSettings, "--exclude-by-attribute ExcludeByAttribute2");
+        }
+
+        [Test] //https://github.com/coverlet-coverage/coverlet/issues/1589
+        public void Should_Unqualified_Qualified_ExcludeByAttribute()
         {
-            mocker = new AutoMoqer();
-            coverletConsoleUtil = mocker.Create<CoverletConsoleUtil>();
+            var mockCoverageProject = SafeMockCoverageProject();
+            mockCoverageProject.SetupGet(cp => cp.Settings.ExcludeByAttribute).Returns(new[] { "Namespace.ExcludeByAttribute1"});
+
+            var coverletExeArgumentsProvider = new CoverletExeArgumentsProvider();
+            var coverletSettings = coverletExeArgumentsProvider.GetArguments(mockCoverageProject.Object);
+
+            AssertHasSetting(coverletSettings, "--exclude-by-attribute ExcludeByAttribute1");
         }
-        [Test]
-        public void Should_Initilize_IFCCCoverletConsoleExeProvider()
+
+        private Mock<ICoverageProject> SafeMockCoverageProject()
         {
-            var ct = CancellationToken.None;
-            coverletConsoleUtil.Initialize("appDataFolder", ct);
-            mocker.Verify<IFCCCoverletConsoleExecutor>(fccExeProvider => fccExeProvider.Initialize("appDataFolder", ct));
+            var mockCoverageProject = new Mock<ICoverageProject>();
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.IncludedReferencedProjects).Returns(new List<string>());
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.ExcludedReferencedProjects).Returns(new List<string>());
+            mockCoverageProject.SetupGet(coverageProject => coverageProject.Settings).Returns(new Mock<IAppOptions>().Object);
+            return mockCoverageProject;
         }
 
+        private void AssertHasSetting(List<string> coverletSettings, string setting)
+        {
+            Assert.IsTrue(coverletSettings.Any(coverletSetting => coverletSetting == setting));
+        }
+
+        private void AssertHasEscapedSetting(List<string> coverletSettings, string setting)
+        {
+            AssertHasSetting(coverletSettings, CommandLineArguments.AddQuotes(setting));
+        }
+    }
+
+    public class CoverletConsoleExecuteRequestProvider_Tests
+    {
         [TestCase(0)]
         [TestCase(1)]
         [TestCase(2)]
@@ -50,7 +84,7 @@ public void Should_GetCoverletExePath_From_First_That_Returns_Non_Null(int provi
 
             ExecuteRequest GetExecuteRequest(int order)
             {
-                if(order != providingExeProvider)
+                if (order != providingExeProvider)
                 {
                     return null;
                 }
@@ -74,13 +108,13 @@ ExecuteRequest GetExecuteRequest(int order)
             {
                 var order = i;
                 var mockExeProvider = mockExecutors[i];
-                mockExeProvider.Setup(p => p.GetRequest(coverageProject, coverletSettings)).Returns(GetExecuteRequest(i)).Callback<ICoverageProject,string>((_,__) =>
+                mockExeProvider.Setup(p => p.GetRequest(coverageProject, coverletSettings)).Returns(GetExecuteRequest(i)).Callback<ICoverageProject, string>((_, __) =>
                 {
                     callOrder.Add(order);
                 });
             }
 
-            var coverletConsoleUtil = new CoverletConsoleUtil(null, null, mockGlobalExecutor.Object, mockCustomPathExecutor.Object, mockLocalExecutor.Object, mockFCCCoverletConsoleExecutor.Object);
+            var coverletConsoleUtil = new CoverletConsoleExecuteRequestProvider(mockGlobalExecutor.Object, mockCustomPathExecutor.Object, mockLocalExecutor.Object, mockFCCCoverletConsoleExecutor.Object);
 
             var executeRequest = coverletConsoleUtil.GetExecuteRequest(coverageProject, coverletSettings);
 
@@ -94,6 +128,123 @@ ExecuteRequest GetExecuteRequest(int order)
             }
 
         }
+    }
+
+    public class CoverletConsoleUtil_Tests
+    {
+        private AutoMoqer mocker;
+        private CoverletConsoleUtil coverletConsoleUtil;
+        private bool executed;
+        private readonly List<string> coverletSettings = new List<string> { "setting1", "setting2" };
+        private readonly ExecuteResponse successfulExecuteResponse =  new ExecuteResponse { ExitCode = 3, Output = "Successful output" };
+
+        [SetUp]
+        public void SetUp()
+        {
+            executed = false;
+            mocker = new AutoMoqer();
+            coverletConsoleUtil = mocker.Create<CoverletConsoleUtil>();
+        }
+        [Test]
+        public void Should_Initilize_IFCCCoverletConsoleExeProvider()
+        {
+            var ct = CancellationToken.None;
+            coverletConsoleUtil.Initialize("appDataFolder", ct);
+            mocker.Verify<IFCCCoverletConsoleExecutor>(fccExeProvider => fccExeProvider.Initialize("appDataFolder", ct));
+        }
+
+        [Test]
+        public async Task Should_Execute_The_Request_From_The_Execute_Request_Provider_With_Space_Delimited_Settings()
+        {
+            await RunSuccessfullyAsync();
+
+            mocker.GetMock<IProcessUtil>().Verify();
+        }
+
+        [Test]
+        public async Task Should_Log_Settings_Before_Executing()
+        {
+            var mockLogger = mocker.GetMock<ILogger>();
+            mockLogger.Setup(logger => logger.Log(It.IsAny<IEnumerable<string>>())).Callback<IEnumerable<string>>(messages =>
+            {
+                var msgList = messages as List<string>;
+                Assert.Multiple(() =>
+                {
+                    Assert.That(msgList[0], Is.EqualTo("Coverlet Run (TheProjectName) - Arguments"));
+                    Assert.That(msgList.Skip(1), Is.EqualTo(coverletSettings));
+                    Assert.That(executed, Is.False);
+                });
+            });
+
+            await RunSuccessfullyAsync();
+
+            mockLogger.Verify();
+        }
+
+        [Test]
+        public void Should_Throw_With_ExecuteResponse_Output_When_ExitCode_Is_Greater_Than_3()
+        {
+            var failureExecuteResponse = new ExecuteResponse { ExitCode = 4, Output = "failure message" };
+            var exception = Assert.ThrowsAsync<Exception>(async() => await RunAsync(failureExecuteResponse));
+
+            Assert.That(exception.Message, Is.EqualTo("Error. Exit code: 4"));
+        }
+
+        [Test]
+        public void Should_Log_With_ExecuteResponse_ExitCode_And_Output_When_ExitCode_Is_Greater_Than_3()
+        {
+            var failureExecuteResponse = new ExecuteResponse { ExitCode = 4, Output = "failure message" };
+            
+            Assert.ThrowsAsync<Exception>(() => RunAsync(failureExecuteResponse));
+
+            var mockLogger = mocker.GetMock<ILogger>();
+            mockLogger.Verify(logger => logger.Log("Coverlet Run (TheProjectName) Error. Exit code: 4", "failure message"));
+        }
+
+        [Test]
+        public async Task Should_Log_The_ExecuteResponse_Output_On_Success()
+        {
+            var mockLogger = mocker.GetMock<ILogger>();
+            mockLogger.Setup(logger => logger.Log(It.IsAny<string[]>())).Callback<string[]>(messages =>
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(messages, Is.EqualTo(new string[] { "Coverlet Run (TheProjectName) - Output", successfulExecuteResponse.Output }));
+                    Assert.That(executed, Is.True);
+                });
+
+            });
+
+            await RunSuccessfullyAsync();
+
+            mockLogger.Verify();
+        }
+        
+        private async Task RunSuccessfullyAsync()
+        {
+            await RunAsync(successfulExecuteResponse);
+        }
+
+        private async Task RunAsync(ExecuteResponse executeResponse)
+        {
+            var mockCoverageProject = new Mock<ICoverageProject>();
+            mockCoverageProject.SetupGet(cp => cp.ProjectName).Returns("TheProjectName");
+            var coverageProject = mockCoverageProject.Object;
+            var requestSettings = string.Join(" ", coverletSettings);
+            var executeRequest = new ExecuteRequest { FilePath = "TheFilePath", Arguments = "TheArguments" };
+            var cancellationToken = CancellationToken.None;
+
+            mocker.Setup<ICoverletExeArgumentsProvider, List<string>>(coverletExeArgumentsProvider => coverletExeArgumentsProvider.GetArguments(coverageProject)).Returns(coverletSettings);
+            mocker.Setup<ICoverletConsoleExecuteRequestProvider, ExecuteRequest>(
+                coverletConsoleExecuteRequestProvider => coverletConsoleExecuteRequestProvider.GetExecuteRequest(coverageProject, requestSettings)
+            ).Returns(executeRequest);
+            var mockProcessUtil = mocker.GetMock<IProcessUtil>();
+            mockProcessUtil.Setup(processUtil => processUtil.ExecuteAsync(executeRequest, cancellationToken))
+                .Callback(() => executed = true)
+               .ReturnsAsync(executeResponse);
+            
+            await coverletConsoleUtil.RunAsync(coverageProject, cancellationToken);
+        }
 
     }
 

FineCodeCoverageTests/CoverletDataCollectorUtil_RunAsync_Tests.cs

@@ -139,16 +139,18 @@ public async Task Should_Get_Settings_With_IncludeTestAssembly_From_CoverageProj
             mockDataCollectorSettingsBuilder.Verify(b => b.WithIncludeTestAssembly(projectIncludeTestAssembly, runSettingsIncludeTestAssembly));
         }
 
-        [Test]
-        public async Task Should_Initialize_With_Options_And_Run_Settings_First()
+        [TestCase(true)]
+        [TestCase(false)]
+        public async Task Should_Initialize_With_Options_And_Run_Settings_First(bool runSettingsOnly)
         {
-            var settings = new Mock<IAppOptions>().Object;
             mockCoverageProject.Setup(cp => cp.RunSettingsFile).Returns(".runsettings");
             mockCoverageProject.Setup(cp => cp.CoverageOutputFolder).Returns("output");
-            mockCoverageProject.Setup(cp => cp.Settings).Returns(settings);
+            var mockSettings = new Mock<IAppOptions>();
+            mockSettings.SetupGet(appOptions => appOptions.RunSettingsOnly).Returns(runSettingsOnly);
+            mockCoverageProject.Setup(cp => cp.Settings).Returns(mockSettings.Object);
 
             await coverletDataCollectorUtil.RunAsync(CancellationToken.None);
-            mockDataCollectorSettingsBuilder.Verify(b => b.Initialize(settings, ".runsettings",Path.Combine("output","FCC.runsettings")));
+            mockDataCollectorSettingsBuilder.Verify(b => b.Initialize(runSettingsOnly, ".runsettings",Path.Combine("output","FCC.runsettings")));
 
             var invocations = mockDataCollectorSettingsBuilder.Invocations.GetEnumerator().ToIEnumerable().ToList();
             Assert.AreEqual(invocations.First().Method.Name, nameof(IDataCollectorSettingsBuilder.Initialize));

FineCodeCoverageTests/DataCollectorSettingsBuilder_Tests.cs

@@ -36,9 +36,7 @@ public void DeleteRunSettings()
 
         private void Initialize(bool runSettingsOnly = false)
         {
-            var mockCoverageProjectSettings = new Mock<IAppOptions>();
-            mockCoverageProjectSettings.Setup(o => o.RunSettingsOnly).Returns(runSettingsOnly);
-            dataCollectorSettingsBuilder.Initialize(mockCoverageProjectSettings.Object, existingRunSettingsPath, generatedRunSettingsPath);
+            dataCollectorSettingsBuilder.Initialize(runSettingsOnly, existingRunSettingsPath, generatedRunSettingsPath);
         }
 
         #region arguments
@@ -88,7 +86,7 @@ public void Should_Set_ProjectDll_Quoted_When_WithProjectDll()
         [Test]
         public void Should_Set_RunSettings_As_Quoted_GeneratedRunSettings_When_Initialize()
         {
-            dataCollectorSettingsBuilder.Initialize(null,".runsettings","generated.runsettings");
+            dataCollectorSettingsBuilder.Initialize(false,".runsettings","generated.runsettings");
             Assert.AreEqual(dataCollectorSettingsBuilder.RunSettings,$"--settings {dataCollectorSettingsBuilder.Quote("generated.runsettings")}");
         }
 
@@ -138,21 +136,22 @@ public void Should_Not_Fallback_To_Options_For_Exclude_If_RunSettingsOnly()
             Assert.IsNull(dataCollectorSettingsBuilder.Exclude);
         }
 
-        [Test]
-        public void Should_Use_RunSettings_ExcludeByAttribute_If_Present()
+        [Test] // https://github.com/coverlet-coverage/coverlet/issues/1589
+        public void Should_Use_RunSettings_ExcludeByAttribute_If_Present_Unqualified()
         {
             Initialize();
-            dataCollectorSettingsBuilder.WithExcludeByAttribute(new string[] { "from project" }, "from run settings");
-            Assert.AreEqual("from run settings", dataCollectorSettingsBuilder.ExcludeByAttribute);
+            dataCollectorSettingsBuilder.WithExcludeByAttribute(new string[] { "from project" }, "namespace.first,second");
+            Assert.AreEqual("first,second", dataCollectorSettingsBuilder.ExcludeByAttribute);
         }
 
         [Test]
-        public void Should_Use_Project_ExcludeByAttribute_If_No_RunSettings()
+        public void Should_Use_Project_ExcludeByAttribute_If_No_RunSettings_Unqualified()
         {
-            dataCollectorSettingsBuilder.WithExcludeByAttribute(new string[] { "first", "second" }, null);
+            dataCollectorSettingsBuilder.WithExcludeByAttribute(new string[] { "namespace.first", "second" }, null);
             Assert.AreEqual(dataCollectorSettingsBuilder.ExcludeByAttribute, "first,second");
         }
 
+
         [Test]
         public void Should_Use_Project_ExcludeByAttribute_If_No_RunSettings_Null()
         {
@@ -303,7 +302,7 @@ public void Should_Set_Corresponding_Property_For_RunSettings_Only_Elements()
         [TestCaseSource(nameof(BuildReturnsSettingsSource))]
         public void Should_Return_Dotnet_Test_Settings_When_Build(Action<DataCollectorSettingsBuilder> setUp, string expectedSettings)
         {
-            dataCollectorSettingsBuilder.Initialize(new Mock<IAppOptions>().Object,null, generatedRunSettingsPath);
+            dataCollectorSettingsBuilder.Initialize(false,null, generatedRunSettingsPath);
             setUp(dataCollectorSettingsBuilder);
             Assert.AreEqual(dataCollectorSettingsBuilder.Build(), expectedSettings);
         }
@@ -336,7 +335,7 @@ public void Should_Generate_RunSettings_When_Builds(Action<DataCollectorSettings
                 XDocument.Parse(existingRunSettings).Save(existingRunSettingsPath);
             }
 
-            dataCollectorSettingsBuilder.Initialize(null,existingRunSettings == null ? null : existingRunSettingsPath, generatedRunSettingsPath);
+            dataCollectorSettingsBuilder.Initialize(false,existingRunSettings == null ? null : existingRunSettingsPath, generatedRunSettingsPath);
             dataCollectorSettingsBuilder.Build();