async initialize

tonyhallett · tonyhallett · commit 4a4e201ce03f · 2022-03-01T16:51:36.000Z
diff --git a/FineCodeCoverageTests/Initializer_Tests.cs b/FineCodeCoverageTests/Initializer_Tests.cs
@@ -31,7 +31,7 @@ public void Should_Have_Initial_InitializeStatus_As_Initializing()
 		[Test]
 		public void Should_Log_Initializing_When_Initialize()
         {
-			initializer.Initialize();
+			initializer.InitializeAsync();
 			mocker.Verify<ILogger>(l => l.Log("Initializing"));
         }
 
@@ -40,7 +40,7 @@ private void InitializeWithException(Action<Exception> callback = null)
 			var initializeException = new Exception("initialize exception");
 			mocker.Setup<ICoverageProjectFactory>(a => a.Initialize()).Throws(initializeException);
 			
-			initializer.Initialize();
+			initializer.InitializeAsync();
 			callback?.Invoke(initializeException);
 
 		}
@@ -69,14 +69,14 @@ public void Should_Log_Failed_Initialization_With_Exception_if_Exception_When_In
 		[Test]
 		public void Should_Set_InitializeStatus_To_Initialized_When_Successfully_Completed()
 		{
-			initializer.Initialize();
+			initializer.InitializeAsync();
 			Assert.AreEqual(InitializeStatus.Initialized, initializer.InitializeStatus);
 		}
 
 		[Test]
 		public void Should_Log_Initialized_When_Successfully_Completed()
 		{
-			initializer.Initialize();
+			initializer.InitializeAsync();
 			mocker.Verify<ILogger>(l => l.Log("Initialized"));
 		}
 
@@ -93,19 +93,19 @@ public void Should_Initialize_Dependencies_In_Order()
 				callOrder.Add(2);
 			});
 
-			mocker.GetMock<IPackageInitializer>().Setup(p => p.Initialize()).Callback(() =>
+			mocker.GetMock<IPackageInitializer>().Setup(p => p.InitializeAsync()).Callback(() =>
 			{
 				callOrder.Add(3);
 			});
 
-			initializer.Initialize();
+			initializer.InitializeAsync();
 			Assert.AreEqual(new List<int> { 1, 2, 3 }, callOrder);
 		}
 
 		[Test]
 		public void Should_Pass_Itself_To_FCCEngine_For_InitializeStatus()
         {
-			initializer.Initialize();
+			initializer.InitializeAsync();
 			mocker.Verify<IFCCEngine>(engine => engine.Initialize(initializer));
         }
 
diff --git a/FineCodeCoverageTests/TestContainerDiscovery_Tests.cs b/FineCodeCoverageTests/TestContainerDiscovery_Tests.cs
@@ -68,7 +68,7 @@ public void SetUp()
         [Test]
         public void It_Should_Initialize_As_Is_The_Entrance()
         {
-            mocker.Verify<IInitializer>(i => i.Initialize());
+            mocker.Verify<IInitializer>(i => i.InitializeAsync());
         }
 
         [Test]
@@ -82,7 +82,7 @@ public void It_Should_Watch_For_Operation_State_Change_Before_Initialize()
                 order.Add(1);
             });
             var mockInitializer = mocker.GetMock<IInitializer>();
-            mockInitializer.Setup(i => i.Initialize()).Callback(() =>
+            mockInitializer.Setup(i => i.InitializeAsync()).Callback(() =>
             {
                 order.Add(2);
             });
diff --git a/SharedProject/Impl/TestContainerDiscovery/IInitializer.cs b/SharedProject/Impl/TestContainerDiscovery/IInitializer.cs
@@ -1,8 +1,10 @@
-﻿namespace FineCodeCoverage.Impl
+﻿using System.Threading.Tasks;
+
+namespace FineCodeCoverage.Impl
 {
     internal interface IInitializer : IInitializeStatusProvider
     {
-        void Initialize();
+        Task InitializeAsync();
     }
 
 }
diff --git a/SharedProject/Impl/TestContainerDiscovery/IPackageInitializer.cs b/SharedProject/Impl/TestContainerDiscovery/IPackageInitializer.cs
@@ -1,8 +1,10 @@
-﻿namespace FineCodeCoverage.Impl
+﻿using System.Threading.Tasks;
+
+namespace FineCodeCoverage.Impl
 {
     internal interface IPackageInitializer
     {
-        void Initialize();
+        Task InitializeAsync();
     }
 
 }
diff --git a/SharedProject/Impl/TestContainerDiscovery/Initializer.cs b/SharedProject/Impl/TestContainerDiscovery/Initializer.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.ComponentModel.Composition;
+using System.Threading.Tasks;
 using FineCodeCoverage.Engine;
 using FineCodeCoverage.Engine.Model;
 
@@ -29,15 +30,15 @@ IPackageInitializer packageInitializer
             this.coverageProjectFactory = coverageProjectFactory;
             this.packageInitializer = packageInitializer;
         }
-        public void Initialize()
+        public async Task InitializeAsync()
         {
             try
             {
                 logger.Log($"Initializing");
 
                 coverageProjectFactory.Initialize();
                 fccEngine.Initialize(this);
-                packageInitializer.Initialize();
+                await packageInitializer.InitializeAsync();
 
                 logger.Log($"Initialized");
             }
diff --git a/SharedProject/Impl/TestContainerDiscovery/PackageInitializer.cs b/SharedProject/Impl/TestContainerDiscovery/PackageInitializer.cs
@@ -1,11 +1,11 @@
 ﻿using System;
 using System.ComponentModel.Composition;
-using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using FineCodeCoverage.Engine;
 using FineCodeCoverage.Output;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using Task = System.Threading.Tasks.Task;
 
 namespace FineCodeCoverage.Impl
 {
@@ -25,31 +25,29 @@ public PackageInitializer(
             this.serviceProvider = serviceProvider;
         }
 
-        public void Initialize()
+        public async Task InitializeAsync()
         {
-            ThreadHelper.JoinableTaskFactory.Run(async () =>
+            await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+
+            if (serviceProvider.GetService(typeof(SVsShell)) is IVsShell shell)
             {
-                await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
+                var packageToBeLoadedGuid = new Guid(OutputToolWindowPackage.PackageGuidString);
+                shell.LoadPackage(ref packageToBeLoadedGuid, out var package);
+
+                var outputWindowInitializedFile = Path.Combine(fccEngine.AppDataFolderPath, "outputWindowInitialized");
 
-                if (serviceProvider.GetService(typeof(SVsShell)) is IVsShell shell)
+                if (File.Exists(outputWindowInitializedFile))
                 {
-                    var packageToBeLoadedGuid = new Guid(OutputToolWindowPackage.PackageGuidString);
-                    shell.LoadPackage(ref packageToBeLoadedGuid, out var package);
-
-                    var outputWindowInitializedFile = Path.Combine(fccEngine.AppDataFolderPath, "outputWindowInitialized");
-
-                    if (File.Exists(outputWindowInitializedFile))
-                    {
-                        await OutputToolWindowCommand.Instance.FindToolWindowAsync();
-                    }
-                    else
-                    {
-                        // for first time users, the window is automatically docked 
-                        await OutputToolWindowCommand.Instance.ShowToolWindowAsync();
-                        File.WriteAllText(outputWindowInitializedFile, string.Empty);
-                    }
+                    await OutputToolWindowCommand.Instance.FindToolWindowAsync();
                 }
-            });
+                else
+                {
+                    // for first time users, the window is automatically docked 
+                    await OutputToolWindowCommand.Instance.ShowToolWindowAsync();
+                    File.WriteAllText(outputWindowInitializedFile, string.Empty);
+                }
+            }
+
         }
     }
 
diff --git a/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs b/SharedProject/Impl/TestContainerDiscovery/TestContainerDiscoverer.cs
@@ -59,7 +59,7 @@ IReportGeneratorUtil reportGeneratorUtil
             initializeThread = new Thread(() =>
             {
                 operationState.StateChanged += OperationState_StateChanged;
-                initializer.Initialize();
+                _ = initializer.InitializeAsync();
             });
             initializeThread.Start();
             

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public void Should_Have_Initial_InitializeStatus_As_Initializing()`
`31`	`31`	`[Test]`
`32`	`32`	`public void Should_Log_Initializing_When_Initialize()`
`33`	`33`	`{`
`34`		`- initializer.Initialize();`
	`34`	`+ initializer.InitializeAsync();`
`35`	`35`	`mocker.Verify<ILogger>(l => l.Log("Initializing"));`
`36`	`36`	`}`
`37`	`37`
`@@ -40,7 +40,7 @@ private void InitializeWithException(Action<Exception> callback = null)`
`40`	`40`	`var initializeException = new Exception("initialize exception");`
`41`	`41`	`mocker.Setup<ICoverageProjectFactory>(a => a.Initialize()).Throws(initializeException);`
`42`	`42`
`43`		`- initializer.Initialize();`
	`43`	`+ initializer.InitializeAsync();`
`44`	`44`	`callback?.Invoke(initializeException);`
`45`	`45`
`46`	`46`	`}`
`@@ -69,14 +69,14 @@ public void Should_Log_Failed_Initialization_With_Exception_if_Exception_When_In`
`69`	`69`	`[Test]`
`70`	`70`	`public void Should_Set_InitializeStatus_To_Initialized_When_Successfully_Completed()`
`71`	`71`	`{`
`72`		`- initializer.Initialize();`
	`72`	`+ initializer.InitializeAsync();`
`73`	`73`	`Assert.AreEqual(InitializeStatus.Initialized, initializer.InitializeStatus);`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`[Test]`
`77`	`77`	`public void Should_Log_Initialized_When_Successfully_Completed()`
`78`	`78`	`{`
`79`		`- initializer.Initialize();`
	`79`	`+ initializer.InitializeAsync();`
`80`	`80`	`mocker.Verify<ILogger>(l => l.Log("Initialized"));`
`81`	`81`	`}`
`82`	`82`
`@@ -93,19 +93,19 @@ public void Should_Initialize_Dependencies_In_Order()`
`93`	`93`	`callOrder.Add(2);`
`94`	`94`	`});`
`95`	`95`
`96`		`- mocker.GetMock<IPackageInitializer>().Setup(p => p.Initialize()).Callback(() =>`
	`96`	`+ mocker.GetMock<IPackageInitializer>().Setup(p => p.InitializeAsync()).Callback(() =>`
`97`	`97`	`{`
`98`	`98`	`callOrder.Add(3);`
`99`	`99`	`});`
`100`	`100`
`101`		`- initializer.Initialize();`
	`101`	`+ initializer.InitializeAsync();`
`102`	`102`	`Assert.AreEqual(new List<int> { 1, 2, 3 }, callOrder);`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`[Test]`
`106`	`106`	`public void Should_Pass_Itself_To_FCCEngine_For_InitializeStatus()`
`107`	`107`	`{`
`108`		`- initializer.Initialize();`
	`108`	`+ initializer.InitializeAsync();`
`109`	`109`	`mocker.Verify<IFCCEngine>(engine => engine.Initialize(initializer));`
`110`	`110`	`}`
`111`	`111`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ public void SetUp()`
`68`	`68`	`[Test]`
`69`	`69`	`public void It_Should_Initialize_As_Is_The_Entrance()`
`70`	`70`	`{`
`71`		`- mocker.Verify<IInitializer>(i => i.Initialize());`
	`71`	`+ mocker.Verify<IInitializer>(i => i.InitializeAsync());`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`[Test]`
`@@ -82,7 +82,7 @@ public void It_Should_Watch_For_Operation_State_Change_Before_Initialize()`
`82`	`82`	`order.Add(1);`
`83`	`83`	`});`
`84`	`84`	`var mockInitializer = mocker.GetMock<IInitializer>();`
`85`		`- mockInitializer.Setup(i => i.Initialize()).Callback(() =>`
	`85`	`+ mockInitializer.Setup(i => i.InitializeAsync()).Callback(() =>`
`86`	`86`	`{`
`87`	`87`	`order.Add(2);`
`88`	`88`	`});`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,10 @@`
`1`		`-namespace FineCodeCoverage.Impl`
	`1`	`+using System.Threading.Tasks;`
	`2`	`+`
	`3`	`+namespace FineCodeCoverage.Impl`
`2`	`4`	`{`
`3`	`5`	`internal interface IInitializer : IInitializeStatusProvider`
`4`	`6`	`{`
`5`		`- void Initialize();`
	`7`	`+ Task InitializeAsync();`
`6`	`8`	`}`
`7`	`9`
`8`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.ComponentModel.Composition;`
	`3`	`+using System.Threading.Tasks;`
`3`	`4`	`using FineCodeCoverage.Engine;`
`4`	`5`	`using FineCodeCoverage.Engine.Model;`
`5`	`6`
`@@ -29,15 +30,15 @@ IPackageInitializer packageInitializer`
`29`	`30`	`this.coverageProjectFactory = coverageProjectFactory;`
`30`	`31`	`this.packageInitializer = packageInitializer;`
`31`	`32`	`}`
`32`		`- public void Initialize()`
	`33`	`+ public async Task InitializeAsync()`
`33`	`34`	`{`
`34`	`35`	`try`
`35`	`36`	`{`
`36`	`37`	`logger.Log($"Initializing");`
`37`	`38`
`38`	`39`	`coverageProjectFactory.Initialize();`
`39`	`40`	`fccEngine.Initialize(this);`
`40`		`- packageInitializer.Initialize();`
	`41`	`+ await packageInitializer.InitializeAsync();`
`41`	`42`
`42`	`43`	`logger.Log($"Initialized");`
`43`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ IReportGeneratorUtil reportGeneratorUtil`
`59`	`59`	`initializeThread = new Thread(() =>`
`60`	`60`	`{`
`61`	`61`	`operationState.StateChanged += OperationState_StateChanged;`
`62`		`- initializer.Initialize();`
	`62`	`+ _ = initializer.InitializeAsync();`
`63`	`63`	`});`
`64`	`64`	`initializeThread.Start();`
`65`	`65`