Skip to content

Commit 9c17622

Browse files
tonyhalletttonyhallett
committed
Move initialization into package. Record opened tool window when opened from menu.
1 parent 7d613d3 commit 9c17622

30 files changed

+551
-150
lines changed

‎FineCodeCoverageTests/FCCEngine_Tests.cs‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,16 @@
11
using System;
22
using System.Collections.Generic;
3-
using System.IO;
43
using System.Linq;
54
using System.Threading;
65
using System.Threading.Tasks;
76
using AutoMoq;
7+
using FineCodeCoverage.Core.Initialization;
88
using FineCodeCoverage.Core.Utilities;
99
using FineCodeCoverage.Engine;
1010
using FineCodeCoverage.Engine.Cobertura;
1111
using FineCodeCoverage.Engine.Model;
1212
using FineCodeCoverage.Engine.MsTestPlatform;
1313
using FineCodeCoverage.Engine.ReportGenerator;
14-
using FineCodeCoverage.Impl;
1514
using FineCodeCoverage.Options;
1615
using FineCodeCoverage.Output;
1716
using Moq;

‎FineCodeCoverageTests/FineCodeCoverageTests.csproj‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -115,6 +115,7 @@
115115
<Compile Include="AppOptionsProvider_Tests.cs" />
116116
<Compile Include="CoverageUtilManager_Tests.cs" />
117117
<Compile Include="FileLineCoverage_Tests.cs" />
118+
<Compile Include="FirstTimeToolWindowOpener_Tests.cs" />
118119
<Compile Include="MsCodeCoverage\ShimCopier_Tests.cs" />
119120
<Compile Include="MsCodeCoverage\TemplatedRunSettingsService_Tests.cs" />
120121
<Compile Include="MsCodeCoverage\CustomRunSettingsTemplateProvider_Tests.cs" />
@@ -130,6 +131,8 @@
130131
<Compile Include="MsCodeCoverage\UserRunSettingsService_AddFCCSettings_Tests.cs" />
131132
<Compile Include="MsCodeCoverage\UserRunSettingsService_Analysis_Tests.cs" />
132133
<Compile Include="MsCodeCoverage\RunSettingsTemplateReplacementsFactory_Tests.cs" />
134+
<Compile Include="PackageLoader_Tests.cs" />
135+
<Compile Include="ShownToolWindowHistory_Tests.cs" />
133136
<Compile Include="Test helpers\MefOrderAssertions.cs" />
134137
<Compile Include="Test helpers\TestThreadHelper.cs" />
135138
<Compile Include="Test helpers\XmlAssert.cs" />

‎FineCodeCoverageTests/FirstTimeToolWindowOpener_Tests.cs‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
using AutoMoq;
2+
using FineCodeCoverage.Core.Initialization;
3+
using FineCodeCoverage.Core.Utilities;
4+
using Moq;
5+
using NUnit.Framework;
6+
using System.Threading;
7+
using System.Threading.Tasks;
8+
9+
namespace FineCodeCoverageTests
10+
{
11+
internal class FirstTimeToolWindowOpener_Tests
12+
{
13+
private AutoMoqer mocker;
14+
private FirstTimeToolWindowOpener firstTimeToolWindowOpener;
15+
16+
[SetUp]
17+
public void SetUp() {
18+
mocker = new AutoMoqer();
19+
firstTimeToolWindowOpener = mocker.Create<FirstTimeToolWindowOpener>();
20+
}
21+
22+
[TestCase(true,false,true)]
23+
[TestCase(true, true, false)]
24+
[TestCase(false, false, false)]
25+
[TestCase(false, true, false)]
26+
public async Task It_Should_Open_If_Have_Never_Shown_The_ToolWindow_And_InitializedFromTestContainerDiscoverer(
27+
bool initializedFromTestContainerDiscoverer,
28+
bool hasShownToolWindow,
29+
bool expectedShown
30+
)
31+
{
32+
mocker.GetMock<IInitializedFromTestContainerDiscoverer>().Setup(x => x.InitializedFromTestContainerDiscoverer).Returns(initializedFromTestContainerDiscoverer);
33+
mocker.GetMock<IShownToolWindowHistory>().Setup(x => x.HasShownToolWindow).Returns(hasShownToolWindow);
34+
35+
await firstTimeToolWindowOpener.OpenIfFirstTimeAsync(CancellationToken.None);
36+
37+
var expectedTimes = expectedShown ? Times.Once() : Times.Never();
38+
mocker.Verify<IToolWindowOpener>(toolWindowOpener => toolWindowOpener.OpenToolWindowAsync(), expectedTimes);
39+
40+
}
41+
}
42+
}

‎FineCodeCoverageTests/Initializer_Tests.cs‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,11 @@
11
using System;
22
using System.Collections.Generic;
3-
using System.IO;
43
using System.Threading;
54
using System.Threading.Tasks;
65
using AutoMoq;
6+
using FineCodeCoverage.Core.Initialization;
77
using FineCodeCoverage.Engine;
88
using FineCodeCoverage.Engine.Model;
9-
using FineCodeCoverage.Impl;
109
using NUnit.Framework;
1110

1211
namespace Test
@@ -95,7 +94,7 @@ public async Task Should_Initialize_Dependencies_In_Order()
9594
callOrder.Add(2);
9695
});
9796

98-
mocker.GetMock<IPackageInitializer>().Setup(p => p.InitializeAsync(disposalToken)).Callback(() =>
97+
mocker.GetMock<IFirstTimeToolWindowOpener>().Setup(firstTimeToolWindowOpener => firstTimeToolWindowOpener.OpenIfFirstTimeAsync(disposalToken)).Callback(() =>
9998
{
10099
callOrder.Add(3);
101100
});

‎FineCodeCoverageTests/PackageLoader_Tests.cs‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
using AutoMoq;
2+
using FineCodeCoverage.Core.Initialization;
3+
using NUnit.Framework;
4+
using System.Threading;
5+
using System.Threading.Tasks;
6+
7+
namespace FineCodeCoverageTests
8+
{
9+
internal class PackageLoader_Tests
10+
{
11+
private AutoMoqer mocker;
12+
private PackageLoader packageLoader;
13+
14+
[SetUp]
15+
public void SetUp()
16+
{
17+
mocker = new AutoMoqer();
18+
packageLoader = mocker.Create<PackageLoader>();
19+
}
20+
21+
22+
23+
[Test]
24+
public void Should_Not_Be_InitializedFromTestContainerDiscoverer_If_LoadPackageAsync()
25+
{
26+
Assert.That(packageLoader.InitializedFromTestContainerDiscoverer, Is.False);
27+
}
28+
29+
[Test]
30+
public async Task Should_Be_InitializedFromTestContainerDiscoverer_If_LoadPackageAsync()
31+
{
32+
await packageLoader.LoadPackageAsync(CancellationToken.None);
33+
Assert.That(packageLoader.InitializedFromTestContainerDiscoverer, Is.True);
34+
}
35+
36+
[Test]
37+
public async Task It_Should_Load_The_Package_If_LoadPackageAsync()
38+
{
39+
await packageLoader.LoadPackageAsync(CancellationToken.None);
40+
41+
mocker.Verify<IShellPackageLoader>(x => x.LoadPackageAsync());
42+
}
43+
}
44+
}

‎FineCodeCoverageTests/ShownToolWindowHistory_Tests.cs‎

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,65 @@
1+
using AutoMoq;
2+
using FineCodeCoverage.Core.Utilities;
3+
using FineCodeCoverage.Engine;
4+
using Moq;
5+
using NUnit.Framework;
6+
using StructureMap.AutoMocking;
7+
using System;
8+
using System.Collections.Generic;
9+
using System.IO;
10+
using System.Linq;
11+
using System.Text;
12+
using System.Threading.Tasks;
13+
14+
namespace FineCodeCoverageTests
15+
{
16+
internal class ShownToolWindowHistory_Tests
17+
{
18+
private AutoMoqer mocker;
19+
private ShownToolWindowHistory shownToolWindowHistory;
20+
private string markerFilePath;
21+
22+
[SetUp]
23+
public void SetUp()
24+
{
25+
mocker = new AutoMoqer();
26+
shownToolWindowHistory = mocker.Create<ShownToolWindowHistory>();
27+
mocker.GetMock<IFCCEngine>().Setup(fccEngine => fccEngine.AppDataFolderPath).Returns("AppDataFolderPath");
28+
markerFilePath = Path.Combine("AppDataFolderPath", "outputWindowInitialized");
29+
}
30+
31+
[Test]
32+
public void It_Should_Write_Marker_File_When_ShowedToolWindow_First_Time()
33+
{
34+
shownToolWindowHistory.ShowedToolWindow();
35+
mocker.Verify<IFileUtil>(f => f.WriteAllText(markerFilePath, string.Empty));
36+
shownToolWindowHistory.ShowedToolWindow();
37+
mocker.Verify<IFileUtil>(f => f.WriteAllText(markerFilePath, string.Empty),Times.Once());
38+
}
39+
40+
[Test]
41+
public void It_Should_HasShownToolWindow_Without_Searching_For_Marker_File_When_ShowedToolWindow_Is_Invoked()
42+
{
43+
shownToolWindowHistory.ShowedToolWindow();
44+
mocker.Verify<IFileUtil>(f => f.Exists(It.IsAny<string>()), Times.Never());
45+
Assert.That(shownToolWindowHistory.HasShownToolWindow, Is.True);
46+
}
47+
48+
[TestCase(true)]
49+
[TestCase(false)]
50+
public void When_ShowedToolWindow_Has_Not_Been_Invoked_Should_Search_For_Marker_File_Once_When_HasShownToolWindow(bool fileExists)
51+
{
52+
mocker.GetMock<IFileUtil>().Setup(f => f.Exists(markerFilePath)).Returns(fileExists);
53+
54+
void HasShownToolWindow()
55+
{
56+
var hasShownToolWindow = shownToolWindowHistory.HasShownToolWindow;
57+
Assert.That(hasShownToolWindow, Is.EqualTo(fileExists));
58+
}
59+
HasShownToolWindow();
60+
HasShownToolWindow();
61+
62+
mocker.Verify<IFileUtil>(f => f.Exists(markerFilePath), Times.Once());
63+
}
64+
}
65+
}

‎FineCodeCoverageTests/TestContainerDiscovery_Tests.cs‎

Lines changed: 70 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33
using System.Threading;
44
using System.Threading.Tasks;
55
using AutoMoq;
6+
using FineCodeCoverage.Core.Initialization;
67
using FineCodeCoverage.Core.Utilities;
78
using FineCodeCoverage.Engine;
89
using FineCodeCoverage.Engine.Model;
@@ -15,6 +16,53 @@
1516

1617
namespace Test
1718
{
19+
20+
internal class TestOperationStateInvocationManager_Tests
21+
{
22+
private AutoMoqer mocker;
23+
private TestOperationStateInvocationManager testOperationStateInvocationManager;
24+
25+
[SetUp]
26+
public void SetUp()
27+
{
28+
mocker = new AutoMoqer();
29+
testOperationStateInvocationManager = mocker.Create<TestOperationStateInvocationManager>();
30+
}
31+
32+
[Test]
33+
public void Should_Return_True_When_Initialized_And_TestExecutionStarting()
34+
{
35+
mocker.GetMock<IInitializeStatusProvider>().Setup(initializeStatusProvider => initializeStatusProvider.InitializeStatus).Returns(InitializeStatus.Initialized);
36+
Assert.That(testOperationStateInvocationManager.CanInvoke(TestOperationStates.TestExecutionStarting), Is.True);
37+
}
38+
39+
[Test]
40+
public void Should_Return_False_When_Not_Initialized_And_TestExecutionStarting()
41+
{
42+
mocker.GetMock<IInitializeStatusProvider>().Setup(initializeStatusProvider => initializeStatusProvider.InitializeStatus).Returns(InitializeStatus.Initializing);
43+
Assert.That(testOperationStateInvocationManager.CanInvoke(TestOperationStates.TestExecutionStarting), Is.False);
44+
}
45+
46+
[TestCase(true)]
47+
[TestCase(false)]
48+
public void Should_Return_True_For_All_Other_States_If_Was_Initialized_When_TestExecutionStarting(bool initializedWhenStarting)
49+
{
50+
var startingInitializeStatus = initializedWhenStarting ? InitializeStatus.Initialized : InitializeStatus.Initializing;
51+
mocker.GetMock<IInitializeStatusProvider>().Setup(initializeStatusProvider => initializeStatusProvider.InitializeStatus).Returns(startingInitializeStatus);
52+
testOperationStateInvocationManager.CanInvoke(TestOperationStates.TestExecutionStarting);
53+
Assert.That(testOperationStateInvocationManager.CanInvoke(TestOperationStates.TestExecutionCancelAndFinished), Is.EqualTo(initializedWhenStarting));
54+
}
55+
56+
[TestCase(TestOperationStates.TestExecutionStarting)]
57+
[TestCase(TestOperationStates.TestExecutionFinished)]
58+
public void Should_Log_When_Cannot_Invoke(TestOperationStates testOperationState)
59+
{
60+
testOperationStateInvocationManager.CanInvoke(testOperationState);
61+
mocker.Verify<ILogger>(logger => logger.Log($"Skipping {testOperationState} as FCC not initialized"));
62+
}
63+
64+
}
65+
1866
internal class TestContainerDiscovery_Tests
1967
{
2068
private AutoMoqer mocker;
@@ -73,42 +121,19 @@ private void SetUpOptions(Action<Mock<IAppOptions>> setupAppOptions)
73121
public void SetUp()
74122
{
75123
mocker = new AutoMoqer();
76-
var mockDisposeAwareTaskRunner = mocker.GetMock<IDisposeAwareTaskRunner>();
77-
mockDisposeAwareTaskRunner.Setup(runner => runner.RunAsync(It.IsAny<Func<Task>>())).Callback<Func<Task>>(async taskProvider => await taskProvider());
78124
testContainerDiscoverer = mocker.Create<TestContainerDiscoverer>();
79125
testContainerDiscoverer.RunAsync = (taskProvider) =>
80126
{
81127
taskProvider().Wait();
82128
};
83-
testContainerDiscoverer.initializeTask.Wait();
84-
}
85-
86-
[Test]
87-
public void It_Should_Initialize_As_Is_The_Entrance()
88-
{
89-
mocker.Verify<IInitializer>(i => i.InitializeAsync(It.IsAny<CancellationToken>()));
129+
var mockTestOperationStateInvocationManager = mocker.GetMock<ITestOperationStateInvocationManager>();
130+
mockTestOperationStateInvocationManager.Setup(testOperationStateInvocationManager => testOperationStateInvocationManager.CanInvoke(It.IsAny<TestOperationStates>())).Returns(true);
90131
}
91132

92133
[Test]
93-
public async Task It_Should_Watch_For_Operation_State_Change_Before_Initialize()
134+
public void It_Should_Load_The_Package()
94135
{
95-
List<int> order = new List<int>();
96-
mocker = new AutoMoqer();
97-
var mockDisposeAwareTaskRunner = mocker.GetMock<IDisposeAwareTaskRunner>();
98-
mockDisposeAwareTaskRunner.Setup(runner => runner.RunAsync(It.IsAny<Func<Task>>())).Callback<Func<Task>>(async taskProvider => await taskProvider());
99-
var mockOperationState = mocker.GetMock<IOperationState>();
100-
mockOperationState.SetupAdd(o => o.StateChanged += It.IsAny<EventHandler<OperationStateChangedEventArgs>>()).Callback(() =>
101-
{
102-
order.Add(1);
103-
});
104-
var mockInitializer = mocker.GetMock<IInitializer>();
105-
mockInitializer.Setup(i => i.InitializeAsync(It.IsAny<CancellationToken>())).Callback(() =>
106-
{
107-
order.Add(2);
108-
});
109-
var testContainerDiscoverer = mocker.Create<TestContainerDiscoverer>();
110-
await testContainerDiscoverer.initializeTask;
111-
Assert.AreEqual(new List<int> { 1, 2 }, order);
136+
mocker.Verify<IPackageLoader>(packageLoader => packageLoader.LoadPackageAsync(It.IsAny<CancellationToken>()));
112137
}
113138

114139
[Test]
@@ -348,5 +373,23 @@ public void Should_Handle_Any_Exception_In_OperationState_Changed_Handler_Loggin
348373
RaiseTestExecutionCancelling();
349374
mocker.Verify<ILogger>(logger => logger.Log("Error processing unit test events", exception));
350375
}
376+
377+
[TestCase(true)]
378+
[TestCase(false)]
379+
public void Should_Not_Handle_OperationState_Changes_When_The_testOperationStateInvocationManager_Cannot_Invoke(bool canInvoke)
380+
{
381+
var invoked = false;
382+
testContainerDiscoverer.testOperationStateChangeHandlers = new Dictionary<TestOperationStates, Func<IOperation, Task>>
383+
{
384+
{TestOperationStates.TestExecutionCanceling, (_) => {invoked = true; return Task.CompletedTask; } }
385+
};
386+
var mockTestOperationStateInvocationManager = mocker.GetMock<ITestOperationStateInvocationManager>();
387+
mockTestOperationStateInvocationManager.Setup(testOperationStateInvocationManager => testOperationStateInvocationManager.CanInvoke(It.IsAny<TestOperationStates>())).Returns(canInvoke);
388+
389+
RaiseTestExecutionCancelling();
390+
Assert.That(invoked, Is.EqualTo(canInvoke));
391+
392+
393+
}
351394
}
352395
}

‎SharedProject/Core/FCCEngine.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,13 +3,13 @@
33
using System.ComponentModel.Composition;
44
using System.Linq;
55
using System.Threading;
6+
using FineCodeCoverage.Core.Initialization;
67
using FineCodeCoverage.Core.Utilities;
78
using FineCodeCoverage.Engine.Cobertura;
89
using FineCodeCoverage.Engine.Model;
910
using FineCodeCoverage.Engine.MsTestPlatform;
1011
using FineCodeCoverage.Engine.MsTestPlatform.CodeCoverage;
1112
using FineCodeCoverage.Engine.ReportGenerator;
12-
using FineCodeCoverage.Impl;
1313
using FineCodeCoverage.Options;
1414
using FineCodeCoverage.Output;
1515

‎SharedProject/Core/IFCCEngine.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
using System;
22
using System.Collections.Generic;
3+
using FineCodeCoverage.Core.Initialization;
34
using FineCodeCoverage.Engine.Model;
4-
using FineCodeCoverage.Impl;
55

66
namespace FineCodeCoverage.Engine
77
{

0 commit comments

Comments
 (0)