move getting MsCodeCoverageRunSettingsService solution directory path to MsCodeCoverageRunSettingsService

tonyhallett · tonyhallett · commit 5186c1c5eed5 · 2022-03-07T15:38:20.000Z
diff --git a/SharedProject/Core/FCCEngine.cs b/SharedProject/Core/FCCEngine.cs
@@ -28,8 +28,6 @@ internal class FCCEngine : IFCCEngine,IDisposable
         public string AppDataFolderPath { get; private set; }
         public List<CoverageLine> CoverageLines { get; internal set; }
         private bool IsVsShutdown => disposeAwareTaskRunner.DisposalToken.IsCancellationRequested;
-        public string SolutionPath { get; set; }
-
 
         private readonly ICoverageUtilManager coverageUtilManager;
         private readonly ICoberturaUtil coberturaUtil;        
@@ -372,12 +370,6 @@ protected virtual void Dispose(bool disposing)
                 disposed = true;
             }
         }
-
-        public void PrepareTestRun(ITestOperation testOperation)
-        {
-            msCodeCoverageRunSettingsService.PrepareRunSettings(SolutionPath, testOperation);
-        }
-
     }
 
 }
diff --git a/SharedProject/Core/IFCCEngine.cs b/SharedProject/Core/IFCCEngine.cs
@@ -15,9 +15,6 @@ internal interface IFCCEngine
 
         void ClearUI();
         List<CoverageLine> CoverageLines { get; }
-        string SolutionPath { get; set; }
-
-        void PrepareTestRun(ITestOperation testOperation);     
     }
 
 }
diff --git a/SharedProject/Core/MsTestPlatform/IMsCodeCoverageRunSettingsService.cs b/SharedProject/Core/MsTestPlatform/IMsCodeCoverageRunSettingsService.cs
@@ -8,7 +8,7 @@ namespace FineCodeCoverage.Engine.MsTestPlatform
 {
     interface IMsCodeCoverageRunSettingsService
     {
-        void PrepareRunSettings(string solutionPath, ITestOperation testOperation);
+        void PrepareRunSettings(ITestOperation testOperation);
         IList<String> GetCoverageFilesFromLastRun();        
         void Initialize(string appDataFolder, CancellationToken cancellationToken);
     }    
diff --git a/SharedProject/Core/MsTestPlatform/MsCodeCoverageRunSettingsService.cs b/SharedProject/Core/MsTestPlatform/MsCodeCoverageRunSettingsService.cs
@@ -1,6 +1,9 @@
-﻿using FineCodeCoverage.Core.Utilities;
+﻿using EnvDTE;
+using EnvDTE80;
+using FineCodeCoverage.Core.Utilities;
 using FineCodeCoverage.Engine.Model;
 using FineCodeCoverage.Impl;
+using Microsoft;
 using Microsoft.VisualStudio.Shell;
 using System;
 using System.Collections.Generic;
@@ -10,6 +13,7 @@
 using System.Reflection;
 using System.Text;
 using System.Threading;
+using Task = System.Threading.Tasks.Task;
 
 namespace FineCodeCoverage.Engine.MsTestPlatform
 {
@@ -28,15 +32,40 @@ internal class MsCodeCoverageRunSettingsService : IMsCodeCoverageRunSettingsServ
         private const string fccSettingsTemplate = "fineCodeCoverageSettings.xml";
         private const string fccSolutionFolder = ".fcc";
         private string testResultsDirectory;
+        private string solutionDirectoryPath;
+        private DTE2 dte;
 
         [ImportingConstructor]
-        public MsCodeCoverageRunSettingsService(IToolFolder toolFolder, IToolZipProvider toolZipProvider)
+        public MsCodeCoverageRunSettingsService(
+            IToolFolder toolFolder, 
+            IToolZipProvider toolZipProvider, 
+            ISolutionEvents solutionEvents,
+            [Import(typeof(SVsServiceProvider))]
+            IServiceProvider serviceProvider
+            )
         {
             this.toolFolder = toolFolder;
             this.toolZipProvider = toolZipProvider;
             var extensionDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
             var runSettingsPath = Path.Combine(extensionDirectory, fccSettingsTemplate);
             runSettings = File.ReadAllText(runSettingsPath);
+            solutionEvents.AfterOpen += SolutionEvents_AfterOpen;
+            dte = (DTE2)serviceProvider.GetService(typeof(DTE));
+            Assumes.Present(dte);
+        }
+
+        private void SolutionEvents_AfterOpen(object sender, EventArgs e)
+        {
+            ThreadHelper.JoinableTaskFactory.Run(async () =>
+            {
+                await SetSolutionDirectoryPathAsync();
+            });
+        }
+
+        private async Task SetSolutionDirectoryPathAsync()
+        {
+            await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+            solutionDirectoryPath =  Path.GetDirectoryName(dte.Solution.FileName);
         }
 
         public void Initialize(string appDataFolder, CancellationToken cancellationToken)
@@ -64,9 +93,9 @@ private void CopyShimForNetFrameworkProjects(List<ICoverageProject> coverageProj
             }
         }
 
-        private void CreateCleanResultsDirectory(string solutionPath)
+        private void CreateCleanResultsDirectory()
         {
-            testResultsDirectory = Path.Combine(solutionPath, fccSolutionFolder, "TestResults");
+            testResultsDirectory = Path.Combine(solutionDirectoryPath, fccSolutionFolder, "TestResults");
             if (Directory.Exists(testResultsDirectory))
             {
                 Directory.Delete(testResultsDirectory, true);
@@ -94,17 +123,26 @@ private string CreateRunSettings(List<ICoverageProject> coverageProjects)
 
         }
 
-        public void PrepareRunSettings(string solutionPath, ITestOperation testOperation)
+        private async Task EnsureSolutionDirectoryPathAsync()
+        {
+            if (solutionDirectoryPath == null)
+            {
+                await SetSolutionDirectoryPathAsync();
+            }
+        }
+
+        public void PrepareRunSettings(ITestOperation testOperation)
         {
             ThreadHelper.JoinableTaskFactory.Run(async () =>
             {
-                var uiThread = ThreadHelper.CheckAccess();
+                await EnsureSolutionDirectoryPathAsync();
                 List<ICoverageProject> coverageProjects = await testOperation.GetCoverageProjectsAsync();
 
                 CopyShimForNetFrameworkProjects(coverageProjects);
-                CreateCleanResultsDirectory(solutionPath);
 
-                var runsettingsFile = Path.Combine(solutionPath, fccSolutionFolder, "fcc.runsettings");
+                CreateCleanResultsDirectory();
+
+                var runsettingsFile = Path.Combine(solutionDirectoryPath, fccSolutionFolder, "fcc.runsettings");
                 File.WriteAllText(runsettingsFile, CreateRunSettings(coverageProjects));
                 testOperation.SetRunSettings(runsettingsFile);
             });
diff --git a/SharedProject/Core/Utilities/ISolutionEvents.cs b/SharedProject/Core/Utilities/ISolutionEvents.cs
@@ -5,5 +5,6 @@ namespace FineCodeCoverage.Core.Utilities
     interface ISolutionEvents
     {
         event EventHandler AfterClosing;
+        event EventHandler AfterOpen;
     }
 }
diff --git a/SharedProject/Core/Utilities/SolutionEvents.cs b/SharedProject/Core/Utilities/SolutionEvents.cs
@@ -11,6 +11,7 @@ namespace FineCodeCoverage.Core.Utilities
     public class SolutionEvents : ISolutionEvents, IVsSolutionEvents
     {
         public event EventHandler AfterClosing;
+        public event EventHandler AfterOpen;
 
         [ImportingConstructor]
         public SolutionEvents(
@@ -56,6 +57,7 @@ public int OnBeforeUnloadProject(IVsHierarchy pRealHierarchy, IVsHierarchy pStub
 
         public int OnAfterOpenSolution(object pUnkReserved, int fNewSolution)
         {
+            AfterOpen?.Invoke(this, EventArgs.Empty);
             return VSConstants.S_OK;
         }
 
@@ -71,7 +73,7 @@ public int OnBeforeCloseSolution(object pUnkReserved)
 
         public int OnAfterCloseSolution(object pUnkReserved)
         {
-            AfterClosing?.Invoke(this, new EventArgs());
+            AfterClosing?.Invoke(this, EventArgs.Empty);
             return VSConstants.S_OK;
         }
     }
diff --git a/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs b/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs
@@ -13,6 +13,7 @@
 using Microsoft.VisualStudio.TestWindow.Extensibility;
 using Task = System.Threading.Tasks.Task;
 using Microsoft.VisualStudio.Utilities;
+using FineCodeCoverage.Engine.MsTestPlatform;
 
 namespace FineCodeCoverage.Impl
 {
@@ -30,6 +31,7 @@ internal class TestContainerDiscoverer : ITestContainerDiscoverer
         private readonly ILogger logger;
         private readonly IAppOptionsProvider appOptionsProvider;
         private readonly IReportGeneratorUtil reportGeneratorUtil;
+        private readonly IMsCodeCoverageRunSettingsService msCodeCoverageRunSettingsService;
         private bool cancelling;
         internal Task initializeTask;
 
@@ -51,12 +53,14 @@ public TestContainerDiscoverer
             ILogger logger,
             IAppOptionsProvider appOptionsProvider,
             IReportGeneratorUtil reportGeneratorUtil,
-            IDisposeAwareTaskRunner disposeAwareTaskRunner 
+            IDisposeAwareTaskRunner disposeAwareTaskRunner,
+            IMsCodeCoverageRunSettingsService msCodeCoverageRunSettingsService
 
         )
         {
             this.appOptionsProvider = appOptionsProvider;
             this.reportGeneratorUtil = reportGeneratorUtil;
+            this.msCodeCoverageRunSettingsService = msCodeCoverageRunSettingsService;
             this.fccEngine = fccEngine;
             this.testOperationFactory = testOperationFactory;
             this.logger = logger;
@@ -91,7 +95,7 @@ private void TestExecutionStarting(IOperation operation)
             if (settings.MsCodeCoverage)
             {
                 var testOperation = testOperationFactory.Create(operation);
-                fccEngine.PrepareTestRun(testOperation);
+                msCodeCoverageRunSettingsService.PrepareRunSettings(testOperation);
             }
             else if (settings.RunInParallel)
             {
diff --git a/SharedProject/Output/OutputToolWindowPackage.cs b/SharedProject/Output/OutputToolWindowPackage.cs
@@ -3,7 +3,6 @@
 using FineCodeCoverage.Options;
 using Microsoft.VisualStudio.Shell;
 using System.Runtime.InteropServices;
-using System.Diagnostics.CodeAnalysis;
 using System.ComponentModel.Composition;
 using System.Threading.Tasks;
 using Task = System.Threading.Tasks.Task;
@@ -12,8 +11,6 @@
 using FineCodeCoverage.Engine;
 using EnvDTE80;
 using Microsoft.VisualStudio;
-using Microsoft.VisualStudio.Shell.Events;
-using System.Threading.Tasks;
 using System.IO;
 using FineCodeCoverage.Core.Utilities;
 
@@ -44,7 +41,6 @@ namespace FineCodeCoverage.Output
 	[ProvideOptionPage(typeof(AppOptions), Vsix.Name, "General", 0, 0, true)]
 	[PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
 	[ProvideToolWindow(typeof(OutputToolWindow), Style = VsDockStyle.Tabbed, DockedHeight = 300, Window = EnvDTE.Constants.vsWindowKindOutput)]
-	[ProvideAutoLoad(VSConstants.UICONTEXT.SolutionOpening_string, PackageAutoLoadFlags.BackgroundLoad)]
 	public sealed class OutputToolWindowPackage : AsyncPackage
 	{
 		private static Microsoft.VisualStudio.ComponentModelHost.IComponentModel componentModel;
@@ -99,42 +95,8 @@ protected override async Task InitializeAsync(CancellationToken cancellationToke
 
 			await OutputToolWindowCommand.InitializeAsync(this, componentModel.GetService<ILogger>());
 			await ClearUICommand.InitializeAsync(this, fccEngine);
-
-			bool isSolutionLoaded = await IsSolutionLoadedAsync();
-			if (isSolutionLoaded)
-			{
-				HandleOpenSolution();
-			}
-            Microsoft.VisualStudio.Shell.Events.SolutionEvents.OnAfterBackgroundSolutionLoadComplete += HandleOpenSolution;
-			
 		}
 		
-		private void HandleOpenSolution()
-        {			
-			ThreadHelper.JoinableTaskFactory.Run(async () =>
-			{
-				await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
-				var _dte2 = (DTE2)GetGlobalService(typeof(SDTE));
-				var solPath = Path.GetDirectoryName(_dte2.Solution.FileName);
-				fccEngine.SolutionPath = solPath;				
-			});
-		}
-
-        private void HandleOpenSolution(object sender, EventArgs e)
-        {
-			HandleOpenSolution();			
-		}
-
-		private async Task<bool> IsSolutionLoadedAsync()
-		{
-			await JoinableTaskFactory.SwitchToMainThreadAsync();
-			var solService = await GetServiceAsync(typeof(SVsSolution)) as IVsSolution;
-
-			ErrorHandler.ThrowOnFailure(solService.GetProperty((int)__VSPROPID.VSPROPID_IsSolutionOpen, out object value));
-
-			return value is bool isSolOpen && isSolOpen;
-		}
-
         protected override Task<object> InitializeToolWindowAsync(Type toolWindowType, int id, CancellationToken cancellationToken)
         {
 			return Task.FromResult<object>(GetOutputToolWindowContext());

Original file line number	Diff line number	Diff line change
`@@ -28,8 +28,6 @@ internal class FCCEngine : IFCCEngine,IDisposable`
`28`	`28`	`public string AppDataFolderPath { get; private set; }`
`29`	`29`	`public List<CoverageLine> CoverageLines { get; internal set; }`
`30`	`30`	`private bool IsVsShutdown => disposeAwareTaskRunner.DisposalToken.IsCancellationRequested;`
`31`		`- public string SolutionPath { get; set; }`
`32`		`-`
`33`	`31`
`34`	`32`	`private readonly ICoverageUtilManager coverageUtilManager;`
`35`	`33`	`private readonly ICoberturaUtil coberturaUtil;`
`@@ -372,12 +370,6 @@ protected virtual void Dispose(bool disposing)`
`372`	`370`	`disposed = true;`
`373`	`371`	`}`
`374`	`372`	`}`
`375`		`-`
`376`		`- public void PrepareTestRun(ITestOperation testOperation)`
`377`		`- {`
`378`		`- msCodeCoverageRunSettingsService.PrepareRunSettings(SolutionPath, testOperation);`
`379`		`- }`
`380`		`-`
`381`	`373`	`}`
`382`	`374`
`383`	`375`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,9 +15,6 @@ internal interface IFCCEngine`
`15`	`15`
`16`	`16`	`void ClearUI();`
`17`	`17`	`List<CoverageLine> CoverageLines { get; }`
`18`		`- string SolutionPath { get; set; }`
`19`		`-`
`20`		`- void PrepareTestRun(ITestOperation testOperation);`
`21`	`18`	`}`
`22`	`19`
`23`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace FineCodeCoverage.Engine.MsTestPlatform`
`8`	`8`	`{`
`9`	`9`	`interface IMsCodeCoverageRunSettingsService`
`10`	`10`	`{`
`11`		`- void PrepareRunSettings(string solutionPath, ITestOperation testOperation);`
	`11`	`+ void PrepareRunSettings(ITestOperation testOperation);`
`12`	`12`	`IList<String> GetCoverageFilesFromLastRun();`
`13`	`13`	`void Initialize(string appDataFolder, CancellationToken cancellationToken);`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,5 +5,6 @@ namespace FineCodeCoverage.Core.Utilities`
`5`	`5`	`interface ISolutionEvents`
`6`	`6`	`{`
`7`	`7`	`event EventHandler AfterClosing;`
	`8`	`+ event EventHandler AfterOpen;`
`8`	`9`	`}`
`9`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ namespace FineCodeCoverage.Core.Utilities`
`11`	`11`	`public class SolutionEvents : ISolutionEvents, IVsSolutionEvents`
`12`	`12`	`{`
`13`	`13`	`public event EventHandler AfterClosing;`
	`14`	`+ public event EventHandler AfterOpen;`
`14`	`15`
`15`	`16`	`[ImportingConstructor]`
`16`	`17`	`public SolutionEvents(`
`@@ -56,6 +57,7 @@ public int OnBeforeUnloadProject(IVsHierarchy pRealHierarchy, IVsHierarchy pStub`
`56`	`57`
`57`	`58`	`public int OnAfterOpenSolution(object pUnkReserved, int fNewSolution)`
`58`	`59`	`{`
	`60`	`+ AfterOpen?.Invoke(this, EventArgs.Empty);`
`59`	`61`	`return VSConstants.S_OK;`
`60`	`62`	`}`
`61`	`63`
`@@ -71,7 +73,7 @@ public int OnBeforeCloseSolution(object pUnkReserved)`
`71`	`73`
`72`	`74`	`public int OnAfterCloseSolution(object pUnkReserved)`
`73`	`75`	`{`
`74`		`- AfterClosing?.Invoke(this, new EventArgs());`
	`76`	`+ AfterClosing?.Invoke(this, EventArgs.Empty);`
`75`	`77`	`return VSConstants.S_OK;`
`76`	`78`	`}`
`77`	`79`	`}`