more tests

Author: tonyhallett

FineCodeCoverageTests/MsCodeCoverage/MsCodeCoverageRunSettingsService_Collect_Tests.cs

@@ -12,12 +12,13 @@
 using System.Threading.Tasks;
 using FineCodeCoverage.Engine.MsTestPlatform.CodeCoverage;
 using FineCodeCoverageTests.Test_helpers;
+using FineCodeCoverage.Engine.ReportGenerator;
 
 namespace FineCodeCoverageTests.MsCodeCoverage
 {
     internal class MsCodeCoverageRunSettingsService_Collect_Tests
     {
-        // todo if logic stays the same - log when no cobertura / clean up
+        private AutoMoqer autoMocker;
 
         [Test]
         public async Task Should_FCCEngine_RunAndProcessReport_With_CoberturaResults()
@@ -39,11 +40,27 @@ public async Task Should_Not_Throw_If_No_Results()
             await RunAndProcessReportAsync(null, Array.Empty<string>());
         }
 
+        [Test]
+        public async Task Should_Combined_Log_When_No_Cobertura_Files()
+        {
+            await RunAndProcessReportAsync(null, Array.Empty<string>());
+            autoMocker.Verify<ILogger>(logger => logger.Log("No cobertura files for ms code coverage."));
+            autoMocker.Verify<IReportGeneratorUtil>(
+                reportGenerator => reportGenerator.LogCoverageProcess("No cobertura files for ms code coverage.")
+            );
+
+        }
+
         private async Task RunAndProcessReportAsync(IEnumerable<Uri> resultsUris,string[] expectedCoberturaFiles)
         {
-            var autoMocker = new AutoMoqer();
+            autoMocker = new AutoMoqer();
             var mockToolFolder = autoMocker.GetMock<IToolFolder>();
-            mockToolFolder.Setup(tf => tf.EnsureUnzipped(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<ZipDetails>(), It.IsAny<CancellationToken>())).Returns("ZipDestination");
+            mockToolFolder.Setup(tf => tf.EnsureUnzipped(
+                It.IsAny<string>(), 
+                It.IsAny<string>(), 
+                It.IsAny<ZipDetails>(), 
+                It.IsAny<CancellationToken>()
+            )).Returns("ZipDestination");
 
             var msCodeCoverageRunSettingsService = autoMocker.Create<MsCodeCoverageRunSettingsService>();
             msCodeCoverageRunSettingsService.threadHelper = new TestThreadHelper();
@@ -55,6 +72,7 @@ private async Task RunAndProcessReportAsync(IEnumerable<Uri> resultsUris,string[
             mockOperation.Setup(operation => operation.GetRunSettingsDataCollectorResultUri(new Uri(RunSettingsHelper.MsDataCollectorUri))).Returns(resultsUris);
 
             await msCodeCoverageRunSettingsService.CollectAsync(mockOperation.Object, new Mock<ITestOperation>().Object);
+            
             mockFccEngine.Verify(engine => engine.RunAndProcessReport(
                     It.Is<string[]>(coberturaFiles => !expectedCoberturaFiles.Except(coberturaFiles).Any() && !coberturaFiles.Except(expectedCoberturaFiles).Any()), It.IsAny<Action>()
                 )

FineCodeCoverageTests/MsCodeCoverage/MsCodeCoverageRunSettingsService_IsCollecting_Tests.cs

@@ -124,6 +124,14 @@ public async Task Should_Have_Status_Error_When_Exception_From_UserRunSettingsSe
             Assert.AreEqual(MsCodeCoverageCollectionStatus.Error, status);
         }
 
+        [Test]
+        public async Task Should_Report_End_Of_CoverageRun_If_Error()
+        {
+            var exception = new Exception("Msg");
+            await Throw_Exception_From_UserRunSettingsService_Analyse(exception);
+            autoMocker.Verify<IReportGeneratorUtil>(reportGeneratorUtil => reportGeneratorUtil.EndOfCoverageRun());
+        }
+
         private Task<MsCodeCoverageCollectionStatus> Throw_Exception_From_UserRunSettingsService_Analyse(Exception exception)
         {
             SetupIUserRunSettingsServiceAnalyseAny().Throws(exception);

FineCodeCoverageTests/TestContainerDiscovery_Tests.cs

@@ -7,6 +7,7 @@
 using FineCodeCoverage.Engine;
 using FineCodeCoverage.Engine.Model;
 using FineCodeCoverage.Engine.MsTestPlatform;
+using FineCodeCoverage.Engine.MsTestPlatform.CodeCoverage;
 using FineCodeCoverage.Impl;
 using FineCodeCoverage.Options;
 using Microsoft.VisualStudio.TestWindow.Extensibility;
@@ -18,11 +19,14 @@ namespace Test
     public class TestContainerDiscovery_Tests
     {
         private AutoMoqer mocker;
+        private TestContainerDiscoverer testContainerDiscoverer;
+
         private void RaiseOperationStateChanged(TestOperationStates testOperationStates,IOperation operation = null)
         {
             var args = operation == null ? new OperationStateChangedEventArgs(testOperationStates) : new OperationStateChangedEventArgs(operation, (RequestStates)testOperationStates);
             mocker.GetMock<IOperationState>().Raise(s => s.StateChanged += null, args);
         }
+        
         private void RaiseTestExecutionStarting(IOperation operation = null)
         {
             RaiseOperationStateChanged(TestOperationStates.TestExecutionStarting,operation);
@@ -42,6 +46,7 @@ private void AssertShouldNotReloadCoverage()
         {
             mocker.Verify<IFCCEngine>(engine => engine.ReloadCoverage(It.IsAny<Func<Task<List<ICoverageProject>>>>()), Times.Never());
         }
+
         private void SetUpOptions(Action<Mock<IAppOptions>> setupAppOptions)
         {
             var mockAppOptions = new Mock<IAppOptions>();
@@ -66,7 +71,7 @@ public void SetUp()
             mocker = new AutoMoqer();
             var mockDisposeAwareTaskRunner = mocker.GetMock<IDisposeAwareTaskRunner>();
             mockDisposeAwareTaskRunner.Setup(runner => runner.RunAsync(It.IsAny<Func<Task>>())).Callback<Func<Task>>(async taskProvider => await taskProvider());
-            var testContainerDiscoverer = mocker.Create<TestContainerDiscoverer>();
+            testContainerDiscoverer = mocker.Create<TestContainerDiscoverer>();
             testContainerDiscoverer.RunAsync = (taskProvider) =>
             {
                 taskProvider().Wait();
@@ -116,6 +121,36 @@ public void Should_StopCoverage_When_TestExecutionStarting()
             mocker.Verify<IFCCEngine>(engine => engine.StopCoverage());
         }
 
+        [Test]
+        public void Should_Stop_Ms_CodeCoverage_When_TestExecutionStarting_And_Ms_Code_Coverage_Collecting()
+        {
+            var mockMsCodeCoverageRunSettingsService = SetMsCodeCoverageCollecting();
+            mockMsCodeCoverageRunSettingsService.Verify(
+                msCodeCoverageRunSettingsService => msCodeCoverageRunSettingsService.StopCoverage(),
+                Times.Never
+            );
+
+            RaiseTestExecutionStarting();
+
+            mockMsCodeCoverageRunSettingsService.Verify(
+                msCodeCoverageRunSettingsService => msCodeCoverageRunSettingsService.StopCoverage()
+            );
+        }
+
+        private Mock<IMsCodeCoverageRunSettingsService> SetMsCodeCoverageCollecting()
+        {
+            var mockMsCodeCoverageRunSettingsService = mocker.GetMock<IMsCodeCoverageRunSettingsService>();
+            mockMsCodeCoverageRunSettingsService.Setup(
+                msCodeCoverageRunSettingsService =>
+                msCodeCoverageRunSettingsService.IsCollectingAsync(It.IsAny<ITestOperation>())
+            ).ReturnsAsync(MsCodeCoverageCollectionStatus.Collecting);
+
+            SetUpOptions(mockOptions => mockOptions.Setup(options => options.Enabled).Returns(true));
+            RaiseTestExecutionStarting();
+            return mockMsCodeCoverageRunSettingsService;
+        }
+
+
         [Test]
         public void Should_Not_ReloadCoverage_When_TestExecutionStarting_And_Settings_RunInParallel_Is_False()
         {
@@ -157,6 +192,23 @@ public void Should_ReloadCoverage_When_TestExecutionFinished_If_RunInParallel_An
             mocker.Verify<IFCCEngine>(engine => engine.ReloadCoverage(It.IsAny<Func<Task<List<ICoverageProject>>>>()));
         }
 
+        [Test]
+        public void Should_Collect_Ms_Code_Coverage_When_TestExecutionFinished_And_Ms_Code_Coverage_Collecting()
+        {
+            SetMsCodeCoverageCollecting();
+
+            var operation = new Mock<IOperation>().Object;
+            var testOperation = new Mock<ITestOperation>().Object;
+            var mockTestOperationFactory = mocker.GetMock<ITestOperationFactory>();
+            mockTestOperationFactory.Setup(testOperationFactory => testOperationFactory.Create(operation)).Returns(testOperation);
+
+            RaiseTestExecutionFinished(operation);
+            mocker.Verify<IMsCodeCoverageRunSettingsService>(
+                msCodeCoverageRunSettingsService =>
+                msCodeCoverageRunSettingsService.CollectAsync(operation, testOperation)
+            );
+        }
+
         [Test]
         public async Task Should_ReloadCoverage_When_TestExecutionStarting_And_Settings_RunInParallel_Is_True()
         {

SharedProject/Core/MsTestPlatform/CodeCoverage/MsCodeCoverageRunSettingsService.cs

@@ -123,33 +123,43 @@ public async Task<MsCodeCoverageCollectionStatus> IsCollectingAsync(ITestOperati
             await InitializeIsCollectingAsync(testOperation);
 
             IUserRunSettingsAnalysisResult analysisResult = await TryAnalyseUserRunSettingsAsync();
-            if (analysisResult == null) return MsCodeCoverageCollectionStatus.Error;
-
-            var coverageProjectsForShim = analysisResult.ProjectsWithFCCMsTestAdapter;
-
-            if (analysisResult.Suitable)
+            if (analysisResult != null)
             {
-                await PrepareCoverageProjectsAsync();
-                SetUserRunSettingsProjectDetails();
-                if (coverageProjectsByType.HasTemplated())
-                {
-                    await GenerateTemplatedAsync(
-                        analysisResult.SpecifiedMsCodeCoverage, 
-                        coverageProjectsForShim, 
-                        testOperation.SolutionDirectory
-                    );
-                }
-                else
+                var coverageProjectsForShim = analysisResult.ProjectsWithFCCMsTestAdapter;
+
+                if (analysisResult.Suitable)
                 {
-                    await CollectingUserRunSettingsAsync();
+                    await PrepareCoverageProjectsAsync();
+                    SetUserRunSettingsProjectDetails();
+                    if (coverageProjectsByType.HasTemplated())
+                    {
+                        await GenerateTemplatedAsync(
+                            analysisResult.SpecifiedMsCodeCoverage,
+                            coverageProjectsForShim,
+                            testOperation.SolutionDirectory
+                        );
+                    }
+                    else
+                    {
+                        await CollectingUserRunSettingsAsync();
+                    }
                 }
-            }
-
-            CopyShimWhenCollecting(coverageProjectsForShim);
 
+                CopyShimWhenCollecting(coverageProjectsForShim);
+            }
+            
+            ReportEndOfCoverageRunIfError();
             return collectionStatus;
         }
 
+        private void ReportEndOfCoverageRunIfError()
+        {
+            if (collectionStatus == MsCodeCoverageCollectionStatus.Error)
+            {
+                reportGeneratorUtil.EndOfCoverageRun();
+            }
+        }
+
         private async Task InitializeIsCollectingAsync(ITestOperation testOperation)
         {
             collectionStatus = MsCodeCoverageCollectionStatus.NotCollecting;
@@ -171,6 +181,7 @@ private async Task<IUserRunSettingsAnalysisResult> TryAnalyseUserRunSettingsAsyn
             }
             catch (Exception exc)
             {
+                collectionStatus = MsCodeCoverageCollectionStatus.Error;
                 await CombinedLogExceptionAsync(exc, "Exception analysing runsettings files");
             }
             return analysisResult;