correction - cannot use stored coverage projects for removal

tonyhallett · tonyhallett · commit 0055dd1aeed5 · 2022-03-25T16:19:17.000Z
diff --git a/FineCodeCoverageTests/MsCodeCoverage/MsCodeCoverageRunSettingsService_Collect_Tests.cs b/FineCodeCoverageTests/MsCodeCoverage/MsCodeCoverageRunSettingsService_Collect_Tests.cs
@@ -21,7 +21,7 @@ namespace FineCodeCoverageTests.MsCodeCoverage
     internal class MsCodeCoverageRunSettingsService_Test_Execution_Not_Finished_Tests
     {
         [Test]
-        public async Task Should_Clean_Up_Templated_Coverage_Projects()
+        public async Task Should_Clean_Up_RunSettings_Coverage_Projects()
         {
             var autoMocker = new AutoMoqer();
             var msCodeCoverageRunSettingsService = autoMocker.Create<MsCodeCoverageRunSettingsService>();
@@ -30,19 +30,21 @@ public async Task Should_Clean_Up_Templated_Coverage_Projects()
 
             // is collecting
             var mockTestOperation = new Mock<ITestOperation>();
-            var templateCoverageProject = CreateCoverageProject(null);
+            var runSettingsCoverageProject = CreateCoverageProject(".runsettings");
             var coverageProjects = new List<ICoverageProject>
             {
-                templateCoverageProject,
-                CreateCoverageProject(".runsettings")
+                runSettingsCoverageProject,
+                CreateCoverageProject(null)
+                
             };
             mockTestOperation.Setup(testOperation => testOperation.GetCoverageProjectsAsync()).ReturnsAsync(coverageProjects);
+            
             await msCodeCoverageRunSettingsService.IsCollectingAsync(mockTestOperation.Object);
 
-            await msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync();
+            await msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync(mockTestOperation.Object);
 
             autoMocker.Verify<ITemplatedRunSettingsService>(
-                templatedRunSettingsService => templatedRunSettingsService.CleanUpAsync(new List<ICoverageProject> { templateCoverageProject })
+                templatedRunSettingsService => templatedRunSettingsService.CleanUpAsync(new List<ICoverageProject> { runSettingsCoverageProject })
             );
         }
 
@@ -57,7 +59,7 @@ private ICoverageProject CreateCoverageProject(string runSettingsFile)
     internal class MsCodeCoverageRunSettingsService_Collect_Tests
     {
         private AutoMoqer autoMocker;
-        private ICoverageProject templateCoverageProject;
+        private ICoverageProject runSettingsCoverageProject;
 
         [Test]
         public async Task Should_FCCEngine_RunAndProcessReport_With_CoberturaResults()
@@ -87,15 +89,14 @@ public async Task Should_Combined_Log_When_No_Cobertura_Files()
             autoMocker.Verify<IReportGeneratorUtil>(
                 reportGenerator => reportGenerator.LogCoverageProcess("No cobertura files for ms code coverage.")
             );
-
         }
 
         [Test]
-        public async Task Should_Clean_Up_Template_Coverage_Projects_From_IsCollecting()
+        public async Task Should_Clean_Up_RunSettings_Coverage_Projects_From_IsCollecting()
         {
             await RunAndProcessReportAsync(null, Array.Empty<string>());
             autoMocker.Verify<ITemplatedRunSettingsService>(
-                templatedRunSettingsService => templatedRunSettingsService.CleanUpAsync(new List<ICoverageProject> { templateCoverageProject })
+                templatedRunSettingsService => templatedRunSettingsService.CleanUpAsync(new List<ICoverageProject> { runSettingsCoverageProject })
             );
         }
 
@@ -122,18 +123,18 @@ private async Task RunAndProcessReportAsync(IEnumerable<Uri> resultsUris,string[
 
             // IsCollecting
             var mockTestOperation = new Mock<ITestOperation>();
-            templateCoverageProject = CreateCoverageProject(null);
+            runSettingsCoverageProject = CreateCoverageProject(".runsettings");
             var coverageProjects = new List<ICoverageProject>
             {
-                templateCoverageProject,
-                CreateCoverageProject(".runsettings")
+                CreateCoverageProject(null),
+                runSettingsCoverageProject
             };
             mockTestOperation.Setup(testOperation => testOperation.GetCoverageProjectsAsync()).ReturnsAsync(coverageProjects);
             var mockAppOptionsProvider = autoMocker.GetMock<IAppOptionsProvider>();
             mockAppOptionsProvider.Setup(appOptionsProvider => appOptionsProvider.Get()).Returns(new Mock<IAppOptions>().Object);
             await msCodeCoverageRunSettingsService.IsCollectingAsync(mockTestOperation.Object);
 
-            await msCodeCoverageRunSettingsService.CollectAsync(mockOperation.Object);
+            await msCodeCoverageRunSettingsService.CollectAsync(mockOperation.Object, mockTestOperation.Object);
             
             mockFccEngine.Verify(engine => engine.RunAndProcessReport(
                     It.Is<string[]>(coberturaFiles => !expectedCoberturaFiles.Except(coberturaFiles).Any() && !coberturaFiles.Except(expectedCoberturaFiles).Any()), It.IsAny<Action>()
diff --git a/FineCodeCoverageTests/TestContainerDiscovery_Tests.cs b/FineCodeCoverageTests/TestContainerDiscovery_Tests.cs
@@ -145,10 +145,18 @@ public void Should_Stop_Ms_CodeCoverage_When_TestExecutionStarting_And_Ms_Code_C
         public void Should_Notify_MsCodeCoverage_When_Test_Execution_Not_Finished_IfCollectingAsync(MsCodeCoverageCollectionStatus status, bool cancelling)
         {
             var mockMsCodeCoverageRunSettingsService = SetMsCodeCoverageCollecting(status);
-            RaiseOperationStateChanged(cancelling ? TestOperationStates.TestExecutionCanceling : TestOperationStates.TestExecutionCancelAndFinished);
+            var operation = new Mock<IOperation>().Object;
+            var mockTestOperationFactory = mocker.GetMock<ITestOperationFactory>();
+            var testOperation = new Mock<ITestOperation>().Object;
+            mockTestOperationFactory.Setup(testOperationFactory => testOperationFactory.Create(operation)).Returns(testOperation);
+
+            RaiseOperationStateChanged(
+                cancelling ? TestOperationStates.TestExecutionCanceling : TestOperationStates.TestExecutionCancelAndFinished, 
+                operation
+            );
             var times = status == MsCodeCoverageCollectionStatus.Collecting ? Times.Once() : Times.Never();
             mockMsCodeCoverageRunSettingsService.Verify(
-                msCodeCoverageRunSettingsService => msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync(), times
+                msCodeCoverageRunSettingsService => msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync(testOperation), times
             );
         }
 
@@ -220,7 +228,7 @@ public void Should_Collect_Ms_Code_Coverage_When_TestExecutionFinished_And_Ms_Co
             RaiseTestExecutionFinished(operation);
             mocker.Verify<IMsCodeCoverageRunSettingsService>(
                 msCodeCoverageRunSettingsService =>
-                msCodeCoverageRunSettingsService.CollectAsync(operation)
+                msCodeCoverageRunSettingsService.CollectAsync(operation,testOperation)
             );
         }
 
diff --git a/SharedProject/Core/MsTestPlatform/CodeCoverage/IMsCodeCoverageRunSettingsService.cs b/SharedProject/Core/MsTestPlatform/CodeCoverage/IMsCodeCoverageRunSettingsService.cs
@@ -9,8 +9,8 @@ interface IMsCodeCoverageRunSettingsService
     {
         void Initialize(string appDataFolder,IFCCEngine fccEngine, CancellationToken cancellationToken);
         Task<MsCodeCoverageCollectionStatus> IsCollectingAsync(ITestOperation testOperation);
-        Task CollectAsync(IOperation operation);
+        Task CollectAsync(IOperation operation, ITestOperation testOperation);
         void StopCoverage();
-        Task TestExecutionNotFinishedAsync();
+        Task TestExecutionNotFinishedAsync(ITestOperation testOperation);
     }    
 }
diff --git a/SharedProject/Core/MsTestPlatform/CodeCoverage/MsCodeCoverageRunSettingsService.cs b/SharedProject/Core/MsTestPlatform/CodeCoverage/MsCodeCoverageRunSettingsService.cs
@@ -160,13 +160,14 @@ private void ReportEndOfCoverageRunIfError()
             }
         }
 
-        private async Task InitializeIsCollectingAsync(ITestOperation testOperation)
+        private Task InitializeIsCollectingAsync(ITestOperation testOperation)
         {
             collectionStatus = MsCodeCoverageCollectionStatus.NotCollecting;
             useMsCodeCoverage = appOptionsProvider.Get().MsCodeCoverage;
-            coverageProjectsByType = await CoverageProjectsByType.CreateAsync(testOperation);
+            //coverageProjectsByType = await CoverageProjectsByType.CreateAsync(testOperation);
             userRunSettingsProjectDetailsLookup = null;
-            await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.RunSettings);
+            //await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.RunSettings);
+            return CleanUpAsync(testOperation);
         }
 
         private async Task<IUserRunSettingsAnalysisResult> TryAnalyseUserRunSettingsAsync()
@@ -278,9 +279,9 @@ private bool ShouldAddFCCRunSettings()
 
         #endregion
 
-        public async Task CollectAsync(IOperation operation)
+        public async Task CollectAsync(IOperation operation, ITestOperation testOperation)
         {
-            await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.Templated);
+            await CleanUpAsync(testOperation);
             var resultsUris = operation.GetRunSettingsMsDataCollectorResultUri();
             var coberturaFiles = new string[0];
             if (resultsUris != null)
@@ -328,11 +329,16 @@ private Task CombinedLogExceptionAsync(Exception ex, string reason)
 
         #endregion
 
-        public Task TestExecutionNotFinishedAsync()
+        public Task TestExecutionNotFinishedAsync(ITestOperation testOperation)
         {
-            return templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.Templated);
+            return CleanUpAsync(testOperation);
         }
 
+        private async Task CleanUpAsync(ITestOperation testOperation)
+        {
+            coverageProjectsByType = await CoverageProjectsByType.CreateAsync(testOperation);
+            await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.RunSettings);
+        }
     }
 
     public static class IRunSettingsConfigurationInfoExtensions { 
diff --git a/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs b/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs
@@ -137,7 +137,7 @@ private async Task TestExecutionFinishedAsync(IOperation operation)
             
             if (msCodeCoverageCollectionStatus == MsCodeCoverageCollectionStatus.Collecting)
             {
-                await msCodeCoverageRunSettingsService.CollectAsync(operation);
+                await msCodeCoverageRunSettingsService.CollectAsync(operation, testOperation);
             }
             else
             {
@@ -181,19 +181,20 @@ private void StopCoverage()
             }
         }
 
-        private Task CoverageCancelledAsync(string logMessage)
+        private Task CoverageCancelledAsync(string logMessage, IOperation operation)
         {
             CombinedLog(logMessage);
             reportGeneratorUtil.EndOfCoverageRun(); // not necessarily true but get desired result
             fccEngine.StopCoverage();
-            return NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync();
+            return NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync(operation);
         }
 
-        private async Task NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync()
+        private async Task NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync(IOperation operation)
         {
             if (msCodeCoverageCollectionStatus == MsCodeCoverageCollectionStatus.Collecting)
             {
-                await msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync();
+                var testOperation = testOperationFactory.Create(operation);
+                await msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync(testOperation);
             }
         }
 
@@ -206,7 +207,7 @@ private void OperationState_StateChanged(object sender, OperationStateChangedEve
                     if (e.State == TestOperationStates.TestExecutionCanceling)
                     {
                         cancelling = true;
-                        await CoverageCancelledAsync("Test execution cancelling - running coverage will be cancelled.");
+                        await CoverageCancelledAsync("Test execution cancelling - running coverage will be cancelled.",e.Operation);
                     }
 
 
@@ -223,7 +224,7 @@ private void OperationState_StateChanged(object sender, OperationStateChangedEve
 
                     if (e.State == TestOperationStates.TestExecutionCancelAndFinished && !cancelling)
                     {
-                        await CoverageCancelledAsync("There has been an issue running tests. See the Tests output window pane.");
+                        await CoverageCancelledAsync("There has been an issue running tests. See the Tests output window pane.",e.Operation);
                     }
 
                 }

Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ interface IMsCodeCoverageRunSettingsService`
`9`	`9`	`{`
`10`	`10`	`void Initialize(string appDataFolder,IFCCEngine fccEngine, CancellationToken cancellationToken);`
`11`	`11`	`Task<MsCodeCoverageCollectionStatus> IsCollectingAsync(ITestOperation testOperation);`
`12`		`- Task CollectAsync(IOperation operation);`
	`12`	`+ Task CollectAsync(IOperation operation, ITestOperation testOperation);`
`13`	`13`	`void StopCoverage();`
`14`		`- Task TestExecutionNotFinishedAsync();`
	`14`	`+ Task TestExecutionNotFinishedAsync(ITestOperation testOperation);`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -160,13 +160,14 @@ private void ReportEndOfCoverageRunIfError()`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
`163`		`- private async Task InitializeIsCollectingAsync(ITestOperation testOperation)`
	`163`	`+ private Task InitializeIsCollectingAsync(ITestOperation testOperation)`
`164`	`164`	`{`
`165`	`165`	`collectionStatus = MsCodeCoverageCollectionStatus.NotCollecting;`
`166`	`166`	`useMsCodeCoverage = appOptionsProvider.Get().MsCodeCoverage;`
`167`		`- coverageProjectsByType = await CoverageProjectsByType.CreateAsync(testOperation);`
	`167`	`+ //coverageProjectsByType = await CoverageProjectsByType.CreateAsync(testOperation);`
`168`	`168`	`userRunSettingsProjectDetailsLookup = null;`
`169`		`- await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.RunSettings);`
	`169`	`+ //await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.RunSettings);`
	`170`	`+ return CleanUpAsync(testOperation);`
`170`	`171`	`}`
`171`	`172`
`172`	`173`	`private async Task<IUserRunSettingsAnalysisResult> TryAnalyseUserRunSettingsAsync()`
`@@ -278,9 +279,9 @@ private bool ShouldAddFCCRunSettings()`
`278`	`279`
`279`	`280`	`#endregion`
`280`	`281`
`281`		`- public async Task CollectAsync(IOperation operation)`
	`282`	`+ public async Task CollectAsync(IOperation operation, ITestOperation testOperation)`
`282`	`283`	`{`
`283`		`- await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.Templated);`
	`284`	`+ await CleanUpAsync(testOperation);`
`284`	`285`	`var resultsUris = operation.GetRunSettingsMsDataCollectorResultUri();`
`285`	`286`	`var coberturaFiles = new string[0];`
`286`	`287`	`if (resultsUris != null)`
`@@ -328,11 +329,16 @@ private Task CombinedLogExceptionAsync(Exception ex, string reason)`
`328`	`329`
`329`	`330`	`#endregion`
`330`	`331`
`331`		`- public Task TestExecutionNotFinishedAsync()`
	`332`	`+ public Task TestExecutionNotFinishedAsync(ITestOperation testOperation)`
`332`	`333`	`{`
`333`		`- return templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.Templated);`
	`334`	`+ return CleanUpAsync(testOperation);`
`334`	`335`	`}`
`335`	`336`
	`337`	`+ private async Task CleanUpAsync(ITestOperation testOperation)`
	`338`	`+ {`
	`339`	`+ coverageProjectsByType = await CoverageProjectsByType.CreateAsync(testOperation);`
	`340`	`+ await templatedRunSettingsService.CleanUpAsync(coverageProjectsByType.RunSettings);`
	`341`	`+ }`
`336`	`342`	`}`
`337`	`343`
`338`	`344`	`public static class IRunSettingsConfigurationInfoExtensions {`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ private async Task TestExecutionFinishedAsync(IOperation operation)`
`137`	`137`
`138`	`138`	`if (msCodeCoverageCollectionStatus == MsCodeCoverageCollectionStatus.Collecting)`
`139`	`139`	`{`
`140`		`- await msCodeCoverageRunSettingsService.CollectAsync(operation);`
	`140`	`+ await msCodeCoverageRunSettingsService.CollectAsync(operation, testOperation);`
`141`	`141`	`}`
`142`	`142`	`else`
`143`	`143`	`{`
`@@ -181,19 +181,20 @@ private void StopCoverage()`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`
`184`		`- private Task CoverageCancelledAsync(string logMessage)`
	`184`	`+ private Task CoverageCancelledAsync(string logMessage, IOperation operation)`
`185`	`185`	`{`
`186`	`186`	`CombinedLog(logMessage);`
`187`	`187`	`reportGeneratorUtil.EndOfCoverageRun(); // not necessarily true but get desired result`
`188`	`188`	`fccEngine.StopCoverage();`
`189`		`- return NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync();`
	`189`	`+ return NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync(operation);`
`190`	`190`	`}`
`191`	`191`
`192`		`- private async Task NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync()`
	`192`	`+ private async Task NotifyMsCodeCoverageTestExecutionNotFinishedIfCollectingAsync(IOperation operation)`
`193`	`193`	`{`
`194`	`194`	`if (msCodeCoverageCollectionStatus == MsCodeCoverageCollectionStatus.Collecting)`
`195`	`195`	`{`
`196`		`- await msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync();`
	`196`	`+ var testOperation = testOperationFactory.Create(operation);`
	`197`	`+ await msCodeCoverageRunSettingsService.TestExecutionNotFinishedAsync(testOperation);`
`197`	`198`	`}`
`198`	`199`	`}`
`199`	`200`
`@@ -206,7 +207,7 @@ private void OperationState_StateChanged(object sender, OperationStateChangedEve`
`206`	`207`	`if (e.State == TestOperationStates.TestExecutionCanceling)`
`207`	`208`	`{`
`208`	`209`	`cancelling = true;`
`209`		`- await CoverageCancelledAsync("Test execution cancelling - running coverage will be cancelled.");`
	`210`	`+ await CoverageCancelledAsync("Test execution cancelling - running coverage will be cancelled.",e.Operation);`
`210`	`211`	`}`
`211`	`212`
`212`	`213`
`@@ -223,7 +224,7 @@ private void OperationState_StateChanged(object sender, OperationStateChangedEve`
`223`	`224`
`224`	`225`	`if (e.State == TestOperationStates.TestExecutionCancelAndFinished && !cancelling)`
`225`	`226`	`{`
`226`		`- await CoverageCancelledAsync("There has been an issue running tests. See the Tests output window pane.");`
	`227`	`+ await CoverageCancelledAsync("There has been an issue running tests. See the Tests output window pane.",e.Operation);`
`227`	`228`	`}`
`228`	`229`
`229`	`230`	`}`