Merge pull request #381 from tonyhallett/consistent-tool-window-opening

Move initialization into package.  Record opened tool window when ope…

FineCodeCoverageTests/FCCEngine_Tests.cs

@@ -1,17 +1,16 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using AutoMoq;
+using FineCodeCoverage.Core.Initialization;
 using FineCodeCoverage.Core.Utilities;
 using FineCodeCoverage.Engine;
 using FineCodeCoverage.Engine.Cobertura;
 using FineCodeCoverage.Engine.Model;
 using FineCodeCoverage.Engine.MsTestPlatform;
 using FineCodeCoverage.Engine.ReportGenerator;
-using FineCodeCoverage.Impl;
 using FineCodeCoverage.Options;
 using FineCodeCoverage.Output;
 using Moq;
@@ -50,7 +49,7 @@ public void Should_Initialize_AppFolder_Then_Utils()
 
  var openCoverMock = mocker.GetMock<ICoverageUtilManager>().Setup(openCover => openCover.Initialize(appDataFolderPath, disposalToken)).Callback(() => callOrder.Add(4));
 
- fccEngine.Initialize(null,disposalToken);
+ fccEngine.Initialize(disposalToken);
 
  Assert.AreEqual(4, callOrder.Count);
  Assert.AreEqual(1, callOrder[0]);
@@ -63,7 +62,7 @@ public void Should_Set_AppDataFolderPath_From_Initialized_AppDataFolder_Director
  var appDataFolderPath = "some path";
  var mockAppDataFolder = mocker.GetMock<IAppDataFolder>();
  mockAppDataFolder.Setup(appDataFolder => appDataFolder.DirectoryPath).Returns(appDataFolderPath);
- fccEngine.Initialize(null, CancellationToken.None);
+ fccEngine.Initialize(CancellationToken.None);
  Assert.AreEqual("some path", fccEngine.AppDataFolderPath);
  }
 
@@ -102,46 +101,6 @@ public async Task Should_Log_Starting_When_Initialized()
  VerifyLogsReloadCoverageStatus(ReloadCoverageStatus.Start);
  }
 
- [Test]
- public async Task Should_Poll_For_Initialized()
- {
- var times = 5;
- var initializeWait = 1000;
- fccEngine.InitializeWait = initializeWait;
-
- var mockInitializeStatusProvider = new Mock<IInitializeStatusProvider>();
- mockInitializeStatusProvider.SetupProperty(i => i.InitializeStatus);
- var initializeStatusProvider = mockInitializeStatusProvider.Object;
-
- fccEngine.Initialize(initializeStatusProvider, CancellationToken.None);
-
- fccEngine.ReloadCoverage(() => Task.FromResult(new List<ICoverageProject>()));
- await Task.Delay(times * initializeWait).ContinueWith(_ =>
- {
- initializeStatusProvider.InitializeStatus = InitializeStatus.Initialized;
- });
- await fccEngine.reloadCoverageTask;
- mocker.Verify<ILogger>(l => l.Log(fccEngine.GetLogReloadCoverageStatusMessage(ReloadCoverageStatus.Initializing)), Times.AtLeast(times));
- }
-
- [Test]
- public async Task Should_Throw_With_initializationFailedMessagePrefix_When_Initialize_Has_Failed()
- {
- var mockInitializerStatusProvider = new Mock<IInitializeStatusProvider>();
- mockInitializerStatusProvider.Setup(i => i.InitializeStatus).Returns(InitializeStatus.Error);
- var initializeExceptionMessage = "An exception was thrown";
- mockInitializerStatusProvider.Setup(i => i.InitializeExceptionMessage).Returns(initializeExceptionMessage);
-
- fccEngine.Initialize(mockInitializerStatusProvider.Object, CancellationToken.None);
-
- fccEngine.ReloadCoverage(() => Task.FromResult(new List<ICoverageProject>()));
-
- await fccEngine.reloadCoverageTask;
-
- mocker.Verify<ILogger>(l => l.Log(fccEngine.GetLogReloadCoverageStatusMessage(ReloadCoverageStatus.Error),It.Is<Exception>(exc => (FCCEngine.initializationFailedMessagePrefix + Environment.NewLine + initializeExceptionMessage) == exc.Message)));
-
- }
-
  [Test]
  public async Task Should_Prepare_For_Coverage_Suitable_CoverageProjects()
  {
@@ -302,14 +261,6 @@ public async Task Should_Process_ReportGenerator_Output_If_Success_Raising_Event
 
  }
 
- [Test]
- public async Task Should_Log_Single_Exception_From_Aggregate_Exception()
- {
- Exception exception = null;
- await ThrowException(exc => exception = exc);
- mocker.Verify<ILogger>(l => l.Log(fccEngine.GetLogReloadCoverageStatusMessage(ReloadCoverageStatus.Error),exception));
- }
-
  [Test]
  public async Task Should_Cancel_Running_Coverage_Logging_Cancelled_When_StopCoverage()
  {
@@ -417,21 +368,6 @@ private async Task ThrowReadingReportHtml()
 
  }
 
- private async Task ThrowException(Action<Exception> exceptionCallback = null)
- {
- var exception = new Exception("an exception");
- exceptionCallback?.Invoke(exception);
- Task<List<ICoverageProject>> thrower() => Task.FromException<List<ICoverageProject>>(exception);
-
- var mockInitializeStatusProvider = new Mock<IInitializeStatusProvider>();
- mockInitializeStatusProvider.Setup(i => i.InitializeStatus).Returns(InitializeStatus.Initialized);
- fccEngine.Initialize(mockInitializeStatusProvider.Object, CancellationToken.None);
-
- fccEngine.ReloadCoverage(thrower);
-
- await fccEngine.reloadCoverageTask;
- }
-
  private async Task StopCoverage()
  {
  var mockSuitableCoverageProject = new Mock<ICoverageProject>();
@@ -461,9 +397,7 @@ private void SetUpSuccessfulRunReportGenerator()
  private async Task ReloadInitializedCoverage(params ICoverageProject[] coverageProjects)
  {
  var projectsFromTask = Task.FromResult(coverageProjects.ToList());
- var mockInitializeStatusProvider = new Mock<IInitializeStatusProvider>();
- mockInitializeStatusProvider.Setup(i => i.InitializeStatus).Returns(InitializeStatus.Initialized);
- fccEngine.Initialize(mockInitializeStatusProvider.Object, CancellationToken.None);
+ fccEngine.Initialize(CancellationToken.None);
  fccEngine.ReloadCoverage(() => projectsFromTask);
  await fccEngine.reloadCoverageTask;
  }

FineCodeCoverageTests/FineCodeCoverageTests.csproj

@@ -115,6 +115,7 @@
  <Compile Include="AppOptionsProvider_Tests.cs" />
  <Compile Include="CoverageUtilManager_Tests.cs" />
  <Compile Include="FileLineCoverage_Tests.cs" />
+ <Compile Include="FirstTimeToolWindowOpener_Tests.cs" />
  <Compile Include="MsCodeCoverage\ShimCopier_Tests.cs" />
  <Compile Include="MsCodeCoverage\TemplatedRunSettingsService_Tests.cs" />
  <Compile Include="MsCodeCoverage\CustomRunSettingsTemplateProvider_Tests.cs" />
@@ -130,6 +131,8 @@
  <Compile Include="MsCodeCoverage\UserRunSettingsService_AddFCCSettings_Tests.cs" />
  <Compile Include="MsCodeCoverage\UserRunSettingsService_Analysis_Tests.cs" />
  <Compile Include="MsCodeCoverage\RunSettingsTemplateReplacementsFactory_Tests.cs" />
+ <Compile Include="PackageLoader_Tests.cs" />
+ <Compile Include="ShownToolWindowHistory_Tests.cs" />
  <Compile Include="Test helpers\MefOrderAssertions.cs" />
  <Compile Include="Test helpers\TestThreadHelper.cs" />
  <Compile Include="Test helpers\XmlAssert.cs" />

FineCodeCoverageTests/FirstTimeToolWindowOpener_Tests.cs

@@ -0,0 +1,42 @@
+using AutoMoq;
+using FineCodeCoverage.Core.Initialization;
+using FineCodeCoverage.Core.Utilities;
+using Moq;
+using NUnit.Framework;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace FineCodeCoverageTests
+{
+ internal class FirstTimeToolWindowOpener_Tests
+ {
+ private AutoMoqer mocker;
+ private FirstTimeToolWindowOpener firstTimeToolWindowOpener;
+
+ [SetUp]
+ public void SetUp() {
+ mocker = new AutoMoqer();
+ firstTimeToolWindowOpener = mocker.Create<FirstTimeToolWindowOpener>();
+ }
+
+ [TestCase(true,false,true)]
+ [TestCase(true, true, false)]
+ [TestCase(false, false, false)]
+ [TestCase(false, true, false)]
+ public async Task It_Should_Open_If_Have_Never_Shown_The_ToolWindow_And_InitializedFromTestContainerDiscoverer(
+ bool initializedFromTestContainerDiscoverer,
+ bool hasShownToolWindow,
+ bool expectedShown
+ )
+ {
+ mocker.GetMock<IInitializedFromTestContainerDiscoverer>().Setup(x => x.InitializedFromTestContainerDiscoverer).Returns(initializedFromTestContainerDiscoverer);
+ mocker.GetMock<IShownToolWindowHistory>().Setup(x => x.HasShownToolWindow).Returns(hasShownToolWindow);
+
+ await firstTimeToolWindowOpener.OpenIfFirstTimeAsync(CancellationToken.None);
+
+ var expectedTimes = expectedShown ? Times.Once() : Times.Never();
+ mocker.Verify<IToolWindowOpener>(toolWindowOpener => toolWindowOpener.OpenToolWindowAsync(), expectedTimes);
+
+ }
+ }
+}

FineCodeCoverageTests/Initializer_Tests.cs

@@ -1,12 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using AutoMoq;
+using FineCodeCoverage.Core.Initialization;
 using FineCodeCoverage.Engine;
 using FineCodeCoverage.Engine.Model;
-using FineCodeCoverage.Impl;
 using NUnit.Framework;
 
 namespace Test
@@ -90,27 +89,18 @@ public async Task Should_Initialize_Dependencies_In_Order()
  {
  callOrder.Add(1);
  });
- mocker.GetMock<IFCCEngine>().Setup(engine => engine.Initialize(initializer, disposalToken)).Callback(() =>
+ mocker.GetMock<IFCCEngine>().Setup(engine => engine.Initialize(disposalToken)).Callback(() =>
  {
  callOrder.Add(2);
  });
 
- mocker.GetMock<IPackageInitializer>().Setup(p => p.InitializeAsync(disposalToken)).Callback(() =>
+ mocker.GetMock<IFirstTimeToolWindowOpener>().Setup(firstTimeToolWindowOpener => firstTimeToolWindowOpener.OpenIfFirstTimeAsync(disposalToken)).Callback(() =>
  {
  callOrder.Add(3);
  });
 
  await initializer.InitializeAsync(disposalToken);
  Assert.AreEqual(new List<int> { 1, 2, 3 }, callOrder);
  }
-
- [Test]
- public async Task Should_Pass_Itself_To_FCCEngine_For_InitializeStatus()
- {
- var disposalToken = CancellationToken.None;
- await initializer.InitializeAsync(disposalToken);
- mocker.Verify<IFCCEngine>(engine => engine.Initialize(initializer, disposalToken));
- }
-
  }
 }

FineCodeCoverageTests/PackageLoader_Tests.cs

@@ -0,0 +1,44 @@
+using AutoMoq;
+using FineCodeCoverage.Core.Initialization;
+using NUnit.Framework;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace FineCodeCoverageTests
+{
+ internal class PackageLoader_Tests
+ {
+ private AutoMoqer mocker;
+ private PackageLoader packageLoader;
+
+ [SetUp]
+ public void SetUp()
+ {
+ mocker = new AutoMoqer();
+ packageLoader = mocker.Create<PackageLoader>();
+ }
+
+
+
+ [Test]
+ public void Should_Not_Be_InitializedFromTestContainerDiscoverer_If_LoadPackageAsync()
+ {
+ Assert.That(packageLoader.InitializedFromTestContainerDiscoverer, Is.False);
+ }
+
+ [Test]
+ public async Task Should_Be_InitializedFromTestContainerDiscoverer_If_LoadPackageAsync()
+ {
+ await packageLoader.LoadPackageAsync(CancellationToken.None);
+ Assert.That(packageLoader.InitializedFromTestContainerDiscoverer, Is.True);
+ }
+
+ [Test]
+ public async Task It_Should_Load_The_Package_If_LoadPackageAsync()
+ {
+ await packageLoader.LoadPackageAsync(CancellationToken.None);
+
+ mocker.Verify<IShellPackageLoader>(x => x.LoadPackageAsync());
+ }
+ }
+}

FineCodeCoverageTests/ShownToolWindowHistory_Tests.cs

@@ -0,0 +1,65 @@
+using AutoMoq;
+using FineCodeCoverage.Core.Utilities;
+using FineCodeCoverage.Engine;
+using Moq;
+using NUnit.Framework;
+using StructureMap.AutoMocking;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace FineCodeCoverageTests
+{
+ internal class ShownToolWindowHistory_Tests
+ {
+ private AutoMoqer mocker;
+ private ShownToolWindowHistory shownToolWindowHistory;
+ private string markerFilePath;
+
+ [SetUp]
+ public void SetUp()
+ {
+ mocker = new AutoMoqer();
+ shownToolWindowHistory = mocker.Create<ShownToolWindowHistory>();
+ mocker.GetMock<IFCCEngine>().Setup(fccEngine => fccEngine.AppDataFolderPath).Returns("AppDataFolderPath");
+ markerFilePath = Path.Combine("AppDataFolderPath", "outputWindowInitialized");
+ }
+
+ [Test]
+ public void It_Should_Write_Marker_File_When_ShowedToolWindow_First_Time()
+ {
+ shownToolWindowHistory.ShowedToolWindow();
+ mocker.Verify<IFileUtil>(f => f.WriteAllText(markerFilePath, string.Empty));
+ shownToolWindowHistory.ShowedToolWindow();
+ mocker.Verify<IFileUtil>(f => f.WriteAllText(markerFilePath, string.Empty),Times.Once());
+ }
+
+ [Test]
+ public void It_Should_HasShownToolWindow_Without_Searching_For_Marker_File_When_ShowedToolWindow_Is_Invoked()
+ {
+ shownToolWindowHistory.ShowedToolWindow();
+ mocker.Verify<IFileUtil>(f => f.Exists(It.IsAny<string>()), Times.Never());
+ Assert.That(shownToolWindowHistory.HasShownToolWindow, Is.True);
+ }
+
+ [TestCase(true)]
+ [TestCase(false)]
+ public void When_ShowedToolWindow_Has_Not_Been_Invoked_Should_Search_For_Marker_File_Once_When_HasShownToolWindow(bool fileExists)
+ {
+ mocker.GetMock<IFileUtil>().Setup(f => f.Exists(markerFilePath)).Returns(fileExists);
+
+ void HasShownToolWindow()
+ {
+ var hasShownToolWindow = shownToolWindowHistory.HasShownToolWindow;
+ Assert.That(hasShownToolWindow, Is.EqualTo(fileExists));
+ }
+ HasShownToolWindow();
+ HasShownToolWindow();
+
+ mocker.Verify<IFileUtil>(f => f.Exists(markerFilePath), Times.Once());
+ }
+ }
+}