refactor

Author: tonyhallett

SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs

@@ -31,9 +31,11 @@ internal class TestContainerDiscoverer : ITestContainerDiscoverer
         private readonly IAppOptionsProvider appOptionsProvider;
         private readonly IReportGeneratorUtil reportGeneratorUtil;
         private readonly IMsCodeCoverageRunSettingsService msCodeCoverageRunSettingsService;
+        private readonly Dictionary<TestOperationStates, Func<IOperation, Task>> testOperationStateChangeHandlers;
         private bool cancelling;
         private MsCodeCoverageCollectionStatus msCodeCoverageCollectionStatus;
         private bool runningInParallel;
+        private IAppOptions settings;
         internal Task initializeTask;
 
         [ExcludeFromCodeCoverage]
@@ -65,6 +67,13 @@ IMsCodeCoverageRunSettingsService msCodeCoverageRunSettingsService
             this.fccEngine = fccEngine;
             this.testOperationFactory = testOperationFactory;
             this.logger = logger;
+            testOperationStateChangeHandlers = new Dictionary<TestOperationStates, Func<IOperation, Task>>
+            {
+                { TestOperationStates.TestExecutionCanceling, TestExecutionCancellingAsync},
+                { TestOperationStates.TestExecutionStarting, TestExecutionStartingAsync},
+                { TestOperationStates.TestExecutionFinished, TestExecutionFinishedAsync},
+                { TestOperationStates.TestExecutionCancelAndFinished, TestExecutionCancelAndFinishedAsync},
+            };
 
             disposeAwareTaskRunner.RunAsync(() =>
             {
@@ -84,6 +93,7 @@ IMsCodeCoverageRunSettingsService msCodeCoverageRunSettingsService
 
         private async Task TestExecutionStartingAsync(IOperation operation)
         {
+            cancelling = false;
             runningInParallel = false;
             StopCoverage();
 
@@ -122,19 +132,35 @@ private void CombinedLog(string message)
 
         private async Task TestExecutionFinishedAsync(IOperation operation)
         {
-            var settings = appOptionsProvider.Get();
-            if (!settings.Enabled || runningInParallel || MsCodeCoverageErrored)
-            {
-                return;
+            var (should, testOperation) = ShouldConditionallyCollectWhenTestExecutionFinished(operation);
+            if (should) {
+                await TestExecutionFinishedCollectionAsync(operation, testOperation);
             }
+            
+        }
 
-            var testOperation = testOperationFactory.Create(operation);
-
-            if (!CoverageConditionsMet(testOperation, settings))
+        private (bool should, ITestOperation testOperation) ShouldConditionallyCollectWhenTestExecutionFinished(IOperation operation)
+        {
+            if (ShouldNotCollectWhenTestExecutionFinished())
             {
-                return;
+                return (false, null);
             }
 
+            var testOperation = testOperationFactory.Create(operation);
+            
+            var shouldCollect = CoverageConditionsMet(testOperation);
+            return (shouldCollect, testOperation);
+        }
+
+        private bool ShouldNotCollectWhenTestExecutionFinished()
+        {
+            settings = appOptionsProvider.Get();
+            return !settings.Enabled || runningInParallel || MsCodeCoverageErrored;
+            
+        }
+
+        private async Task TestExecutionFinishedCollectionAsync(IOperation operation, ITestOperation testOperation)
+        {
             if (msCodeCoverageCollectionStatus == MsCodeCoverageCollectionStatus.Collecting)
             {
                 await msCodeCoverageRunSettingsService.CollectAsync(operation, testOperation);
@@ -145,7 +171,7 @@ private async Task TestExecutionFinishedAsync(IOperation operation)
             }
         }
 
-        private bool CoverageConditionsMet(ITestOperation testOperation, IAppOptions settings)
+        private bool CoverageConditionsMet(ITestOperation testOperation)
         {
             if (!settings.RunWhenTestsFail && testOperation.FailedTests > 0)
             {
@@ -206,29 +232,24 @@ private void OperationState_StateChanged(object sender, OperationStateChangedEve
             });
         }
 
-        private async Task OperationState_StateChangedAsync(OperationStateChangedEventArgs e)
+        private async Task TestExecutionCancellingAsync(IOperation operation)
         {
-            if (e.State == TestOperationStates.TestExecutionCanceling)
-            {
-                cancelling = true;
-                await CoverageCancelledAsync("Test execution cancelling - running coverage will be cancelled.", e.Operation);
-            }
-
-
-            if (e.State == TestOperationStates.TestExecutionStarting)
-            {
-                await TestExecutionStartingAsync(e.Operation);
-                cancelling = false;
-            }
+            cancelling = true;
+            await CoverageCancelledAsync("Test execution cancelling - running coverage will be cancelled.", operation);
+        }
 
-            if (e.State == TestOperationStates.TestExecutionFinished)
+        private async Task TestExecutionCancelAndFinishedAsync(IOperation operation)
+        {
+            if (!cancelling)
             {
-                await TestExecutionFinishedAsync(e.Operation);
+                await CoverageCancelledAsync("There has been an issue running tests. See the Tests output window pane.", operation);
             }
+        }
 
-            if (e.State == TestOperationStates.TestExecutionCancelAndFinished && !cancelling)
-            {
-                await CoverageCancelledAsync("There has been an issue running tests. See the Tests output window pane.", e.Operation);
+        private async Task OperationState_StateChangedAsync(OperationStateChangedEventArgs e)
+        {
+            if (testOperationStateChangeHandlers.TryGetValue(e.State, out var handler)) {
+                await handler(e.Operation);
             }
         }