add test Execute_StateUnderTest_WithInstrumentationState_Fake

Author: Bertk

Directory.Packages.props

@@ -57,7 +57,7 @@
     <PackageVersion Include="xunit.assemblyfixture" Version="2.2.0" />
     <PackageVersion Include="xunit.assert" Version="2.5.0" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="2.5.0"/>
-
+    <!--<PackageVersion Include="envdte" Version="17.7.37355" />-->
 
   </ItemGroup>
 </Project>

src/coverlet.msbuild.tasks/BaseTask.cs

@@ -8,6 +8,6 @@ namespace Coverlet.MSbuild.Tasks
 {
     public abstract class BaseTask : Task
     {
-        public static IServiceProvider ServiceProvider { get; set; }
+        public static IServiceProvider ServiceProvider { get; protected internal set; }
     }
 }

src/coverlet.msbuild.tasks/MSBuildLogger.cs

@@ -4,27 +4,26 @@
 using System;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
-using ILogger = Coverlet.Core.Abstractions.ILogger;
 
 namespace Coverlet.MSbuild.Tasks
 {
-    class MSBuildLogger : ILogger
-    {
-        private const string LogPrefix = "[coverlet] ";
+  class MSBuildLogger : Coverlet.Core.Abstractions.ILogger
+  {
+    private const string LogPrefix = "[coverlet] ";
 
-        private readonly TaskLoggingHelper _log;
+    private readonly TaskLoggingHelper _log;
 
-        public MSBuildLogger(TaskLoggingHelper log) => _log = log;
+    public MSBuildLogger(TaskLoggingHelper log) => _log = log;
 
-        public void LogVerbose(string message) => _log.LogMessage(MessageImportance.Low, $"{LogPrefix}{message}");
+    public void LogVerbose(string message) => _log.LogMessage(MessageImportance.Low, $"{LogPrefix}{message}");
 
-        // We use `MessageImportance.High` because with `MessageImportance.Normal` doesn't show anything
-        public void LogInformation(string message, bool important = false) => _log.LogMessage(MessageImportance.High, $"{LogPrefix}{message}");
+    // We use `MessageImportance.High` because with `MessageImportance.Normal` doesn't show anything
+    public void LogInformation(string message, bool important = false) => _log.LogMessage(MessageImportance.High, $"{LogPrefix}{message}");
 
-        public void LogWarning(string message) => _log.LogWarning($"{LogPrefix}{message}");
+    public void LogWarning(string message) => _log.LogWarning($"{LogPrefix}{message}");
 
-        public void LogError(string message) => _log.LogError($"{LogPrefix}{message}");
+    public void LogError(string message) => _log.LogError($"{LogPrefix}{message}");
 
-        public void LogError(Exception exception) => _log.LogErrorFromException(exception, true);
-    }
+    public void LogError(Exception exception) => _log.LogErrorFromException(exception, true);
+  }
 }

test/coverlet.core.tests/coverlet.core.tests.csproj

@@ -4,13 +4,14 @@
   <PropertyGroup>
     <TargetFramework>net6.0</TargetFramework>
     <IsPackable>false</IsPackable>
-    <NoWarn>$(NoWarn);CS8002;NU1008</NoWarn>
-    <MSBuildWarningsAsMessages>NU1702</MSBuildWarningsAsMessages>
+    <NoWarn>$(NoWarn);CS8002</NoWarn>
+    <MSBuildWarningsAsMessages>NU1702;NU1504;NU1008</MSBuildWarningsAsMessages>
     <!--For test TestInstrument_NetstandardAwareAssemblyResolver_PreserveCompilationContext-->
     <PreserveCompilationContext>true</PreserveCompilationContext>
   </PropertyGroup>
 
   <ItemGroup>
+    <!--<PackageReference Include="envdte" />-->
     <PackageReference Include="LinqKit.Microsoft.EntityFrameworkCore" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />

test/coverlet.msbuild.tasks.tests/CoverageResultTaskTests.cs

@@ -7,6 +7,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Locator;
+using Microsoft.Build.Utilities;
 using Moq;
 using Xunit;
 
@@ -24,11 +25,14 @@ public class CoverageResultTaskTests : IAssemblyFixture<MSBuildFixture>
   {
     private readonly Mock<IBuildEngine> _buildEngine;
     private readonly List<BuildErrorEventArgs> _errors;
+    private readonly Mock<IAssemblyAdapter> _mockAssemblyAdapter;
 
     public CoverageResultTaskTests()
     {
       _buildEngine = new Mock<IBuildEngine>();
       _errors = new List<BuildErrorEventArgs>();
+      _mockAssemblyAdapter = new Mock<IAssemblyAdapter>();
+      _mockAssemblyAdapter.Setup(x => x.GetAssemblyName(It.IsAny<string>())).Returns("abc");
     }
 
     [Fact]
@@ -43,13 +47,14 @@ public void Execute_StateUnderTest_MissingInstrumentationState()
 
       _buildEngine.Setup(x => x.LogErrorEvent(It.IsAny<BuildErrorEventArgs>())).Callback<BuildErrorEventArgs>(e => _errors.Add(e));
 
-      var coverageResultTask = new CoverageResultTask {
-                OutputFormat = "opencover",
-                Output = "coverageDir",
-                Threshold = "50",
-                ThresholdType = "total",
-                ThresholdStat = "total",
-                InstrumenterState = null
+      var coverageResultTask = new CoverageResultTask
+      {
+        OutputFormat = "opencover",
+        Output = "coverageDir",
+        Threshold = "50",
+        ThresholdType = "total",
+        ThresholdStat = "total",
+        InstrumenterState = null
       };
       coverageResultTask.BuildEngine = _buildEngine.Object;
 
@@ -59,8 +64,76 @@ public void Execute_StateUnderTest_MissingInstrumentationState()
       // Assert
       Assert.False(success);
       Assert.True(coverageResultTask.Log.HasLoggedErrors);
-      // check error message "Result of instrumentation task not found" 
+      // check error message "Result of instrumentation task not found"
     }
 
+    [Fact]
+    public void Execute_StateUnderTest_WithInstrumentationState_Fake()
+    {
+      // Arrange
+      var mockFileSystem = new Mock<IFileSystem>();
+      mockFileSystem.Setup(x => x.Exists(It.IsAny<string>())).Returns(true);
+      mockFileSystem.Setup(x => x.Copy(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()));
+      var log = new TaskLoggingHelper(_buildEngine.Object, "CoverageResultTask");
+
+      IServiceCollection serviceCollection = new ServiceCollection();
+      serviceCollection.AddTransient<IFileSystem, FileSystem>();
+      serviceCollection.AddTransient<IProcessExitHandler, ProcessExitHandler>();
+      serviceCollection.AddTransient<Coverlet.Core.Abstractions.ILogger, MSBuildLogger>(_ => new MSBuildLogger(log));
+      serviceCollection.AddTransient<IRetryHelper, RetryHelper>();
+      serviceCollection.AddTransient<IConsole, SystemConsole>();
+      serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelperForDebugging>();
+      serviceCollection.AddSingleton<ISourceRootTranslator, SourceRootTranslator>(serviceProvider => new SourceRootTranslator("empty", serviceProvider.GetRequiredService<Coverlet.Core.Abstractions.ILogger>(), mockFileSystem.Object, _mockAssemblyAdapter.Object));
+      ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();
+      BaseTask.ServiceProvider = serviceProvider;
+      _buildEngine.Setup(x => x.LogErrorEvent(It.IsAny<BuildErrorEventArgs>())).Callback<BuildErrorEventArgs>(e => _errors.Add(e));
+
+#pragma warning disable CS8604 // Possible null reference argument for parameter..
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+      var InstrumenterState = new TaskItem(Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, "TestAssets\\InstrumenterState.ItemSpec.data1.xml")) ;
+#pragma warning restore CS8602 // Dereference of a possibly null reference.
+#pragma warning restore C8S604 // Possible null reference argument for parameter.
+
+      var coverageResultTask = new CoverageResultTask
+      {
+        OutputFormat = "opencover",
+        Output = "coverageDir",
+        Threshold = "50",
+        ThresholdType = "total",
+        ThresholdStat = "total",
+        InstrumenterState = InstrumenterState
+      };
+      coverageResultTask.BuildEngine = _buildEngine.Object;
+
+      // Act
+      bool success = coverageResultTask.Execute();
+
+      // Assert
+      Assert.True(success);
+      Assert.False(coverageResultTask.Log.HasLoggedErrors);
+
+      Assert.Contains("coverageDir.opencover.xml", coverageResultTask.ReportItems[0].ItemSpec);
+      Assert.Equal(16, coverageResultTask.ReportItems[0].MetadataCount);
+
+    }
+
+  }
+  class InstrumentationHelperForDebugging : InstrumentationHelper
+  {
+    public InstrumentationHelperForDebugging(IProcessExitHandler processExitHandler, IRetryHelper retryHelper, IFileSystem fileSystem, Coverlet.Core.Abstractions.ILogger logger, ISourceRootTranslator sourceTranslator)
+        : base(processExitHandler, retryHelper, fileSystem, logger, sourceTranslator)
+    {
+
+    }
+
+    public override void RestoreOriginalModule(string module, string identifier)
+    {
+      // DO NOT RESTORE
+    }
+
+    public override void RestoreOriginalModules()
+    {
+      // DO NOT RESTORE
+    }
   }
 }