Skip to content

Commit e150811

Browse files
tonyhalletttonyhallett
committed
backup
1 parent e787be9 commit e150811

File tree

13 files changed

+230
-43
lines changed

13 files changed

+230
-43
lines changed

‎FineCodeCoverageTests/AppOptionsProvider_Tests.cs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -349,7 +349,8 @@ internal void Should_Use_Deseralized_String_From_Store_For_AppOption_Property(Fu
349349
{nameof(IAppOptions.ShowLineNewHighlighting),true },
350350
{nameof(IAppOptions.ShowLineNotIncludedHighlighting),true },
351351
{nameof(IAppOptions.UseEnterpriseFontsAndColors),true },
352-
{nameof(IAppOptions.EditorCoverageColouringMode), EditorCoverageColouringMode.UseRoslynWhenTextChanges }
352+
{nameof(IAppOptions.EditorCoverageColouringMode), EditorCoverageColouringMode.UseRoslynWhenTextChanges },
353+
{nameof(IAppOptions.BlazorCoverageLinesFromGeneratedSource), true }
353354
};
354355
var mockJsonConvertService = autoMocker.GetMock<IJsonConvertService>();
355356
mockJsonConvertService.Setup(

‎FineCodeCoverageTests/Editor/DynamicCoverage/BlazorCoverageContentType_Tests.cs‎

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
using FineCodeCoverage.Editor.DynamicCoverage.ContentTypes.Blazor;
2+
using FineCodeCoverage.Options;
23
using Moq;
34
using NUnit.Framework;
45

@@ -11,60 +12,63 @@ internal class BlazorCoverageContentType_Tests
1112
[TestCase("path.vbhtml", true)]
1213
public void Should_Include_Razor_Component_Files(string filePath, bool expectedExclude)
1314
{
14-
Assert.That(new BlazorCoverageContentType(null).Exclude(filePath), Is.EqualTo(expectedExclude));
15+
Assert.That(new BlazorCoverageContentType(null, null).Exclude(filePath), Is.EqualTo(expectedExclude));
1516
}
1617

1718
[Test]
1819
public void Should_Line_Exclude_HtmlTags()
1920
{
20-
var lineExcluder = new BlazorCoverageContentType(null).LineExcluder;
21+
var lineExcluder = new BlazorCoverageContentType(null, null).LineExcluder;
2122
Assert.True(lineExcluder.ExcludeIfNotCode("<"));
2223
}
2324

2425
[Test]
2526
public void Should_Line_Exclude_Directives()
2627
{
27-
var lineExcluder = new BlazorCoverageContentType(null).LineExcluder;
28+
var lineExcluder = new BlazorCoverageContentType(null, null).LineExcluder;
2829
Assert.True(lineExcluder.ExcludeIfNotCode("@"));
2930
}
3031

3132
[Test]
3233
public void Should_Line_Exclude_Comments()
3334
{
34-
var lineExcluder = new BlazorCoverageContentType(null).LineExcluder;
35+
var lineExcluder = new BlazorCoverageContentType(null, null).LineExcluder;
3536
Assert.True(lineExcluder.ExcludeIfNotCode("//"));
3637
}
3738

3839
[Test]
3940
public void Should_Line_Exclude_Compiler_Directives()
4041
{
41-
var lineExcluder = new BlazorCoverageContentType(null).LineExcluder;
42+
var lineExcluder = new BlazorCoverageContentType(null, null).LineExcluder;
4243
Assert.True(lineExcluder.ExcludeIfNotCode("#"));
4344
}
4445

4546
[Test]
4647
public void Should_Not_UseFileCodeSpanRangeServiceForChanges()
4748
{
48-
Assert.False(new BlazorCoverageContentType(null).UseFileCodeSpanRangeServiceForChanges);
49+
Assert.False(new BlazorCoverageContentType(null, null).UseFileCodeSpanRangeServiceForChanges);
4950
}
5051

51-
[Test]
52-
public void Should_CoverageFromFileCodeSpanRangeService_And_Additional_Lines()
52+
[TestCase(true)]
53+
[TestCase(false)]
54+
public void Should_CoverageFromFileCodeSpanRangeService_From_AppOptions(bool blazorCoverageLinesFromGeneratedSource)
5355
{
54-
Assert.False(new BlazorCoverageContentType(null).CoverageOnlyFromFileCodeSpanRangeService);
56+
var mockAppOptionsProvider = new Mock<IAppOptionsProvider>();
57+
mockAppOptionsProvider.Setup(a => a.Get()).Returns(new AppOptions { BlazorCoverageLinesFromGeneratedSource = blazorCoverageLinesFromGeneratedSource });
58+
Assert.That(new BlazorCoverageContentType(null, mockAppOptionsProvider.Object).CoverageOnlyFromFileCodeSpanRangeService, Is.EqualTo(blazorCoverageLinesFromGeneratedSource));
5559
}
5660

5761
[Test]
5862
public void Should_Use_BlazorFileCodeSpanRangeService()
5963
{
6064
var blazorFileCodeSpanRangeService = new Mock<IBlazorFileCodeSpanRangeService>().Object;
61-
Assert.That(blazorFileCodeSpanRangeService, Is.SameAs(new BlazorCoverageContentType(blazorFileCodeSpanRangeService).FileCodeSpanRangeService));
65+
Assert.That(blazorFileCodeSpanRangeService, Is.SameAs(new BlazorCoverageContentType(blazorFileCodeSpanRangeService, null).FileCodeSpanRangeService));
6266
}
6367

6468
[Test]
6569
public void Should_Be_For_The_Razor_ContentType()
6670
{
67-
Assert.That("Razor", Is.EqualTo(new BlazorCoverageContentType(null).ContentTypeName));
71+
Assert.That("Razor", Is.EqualTo(new BlazorCoverageContentType(null, null).ContentTypeName));
6872
}
6973

7074
}

‎FineCodeCoverageTests/Editor/DynamicCoverage/BufferLineCoverage_Tests.cs‎

Lines changed: 98 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@
1111
using NUnit.Framework;
1212
using System;
1313
using System.Collections.Generic;
14-
using System.Diagnostics;
1514
using System.Linq;
1615
using System.Threading;
1716

@@ -77,6 +76,27 @@ public void Should_Create_Tracked_Lines_From_Existing_Coverage()
7776
autoMoqer.Verify<ITrackedLinesFactory>(trackedLinesFactory => trackedLinesFactory.Create(lines, textSnapshot, "filepath"));
7877
}
7978

79+
[Test]
80+
public void Should_Log_If_Exception_Creating_Tracked_Lines()
81+
{
82+
var exception = new Exception("exception");
83+
84+
SimpleTextInfoSetUp(false, "CSharp");
85+
86+
var mockTrackedLinesFactory = autoMoqer.GetMock<ITrackedLinesFactory>();
87+
mockTrackedLinesFactory.Setup(
88+
trackedLinesFactory => trackedLinesFactory.Create(
89+
It.IsAny<List<ILine>>(),
90+
It.IsAny<ITextSnapshot>(),
91+
It.IsAny<string>())
92+
).Throws(exception);
93+
94+
var bufferLineCoverage = autoMoqer.Create<BufferLineCoverage>();
95+
96+
autoMoqer.Verify<ILogger>(logger => logger.Log("Error creating tracked lines for filepath", exception));
97+
98+
}
99+
80100
[Test]
81101
public void Should_Not_Create_TrackedLines_If_EditorCoverageColouringMode_Is_Off()
82102
{
@@ -167,12 +187,63 @@ void RaiseTestExecutionStartingMessage()
167187
Times.Exactly(expectCoverageChangedMessage ? 1 : 0));
168188
}
169189

190+
[Test]
191+
public void Should_Log_When_Text_Changed_Since_TestExecutionStartingMessage()
192+
{
193+
var autoMoqer = new AutoMoqer();
194+
var mockTextView = new Mock<ITextView>();
195+
var mockTextBuffer = new Mock<ITextBuffer2>();
196+
var textSnapshot = new Mock<ITextSnapshot>().Object;
197+
mockTextBuffer.Setup(textBuffer => textBuffer.CurrentSnapshot).Returns(textSnapshot);
198+
var mockTextInfo = new Mock<ITextInfo>();
199+
mockTextInfo.SetupGet(textInfo => textInfo.TextBuffer).Returns(mockTextBuffer.Object);
200+
mockTextInfo.SetupGet(textInfo => textInfo.TextView).Returns(mockTextView.Object);
201+
mockTextInfo.SetupGet(textInfo => textInfo.FilePath).Returns("filepath");
202+
autoMoqer.SetInstance(mockTextInfo.Object);
203+
204+
var mockAppOptionsProvider = autoMoqer.GetMock<IAppOptionsProvider>();
205+
var firstMockAppOptions = new Mock<IAppOptions>();
206+
firstMockAppOptions.SetupGet(appOptions => appOptions.EditorCoverageColouringMode).Returns(EditorCoverageColouringMode.Off);
207+
var secondAppOptions = new Mock<IAppOptions>();
208+
secondAppOptions.SetupGet(appOptions => appOptions.EditorCoverageColouringMode).Returns(EditorCoverageColouringMode.UseRoslynWhenTextChanges);
209+
mockAppOptionsProvider.SetupSequence(appOptionsProvider => appOptionsProvider.Get())
210+
.Returns(firstMockAppOptions.Object).Returns(secondAppOptions.Object);
211+
212+
var mockTrackedLinesFactory = autoMoqer.GetMock<ITrackedLinesFactory>();
213+
var mockTrackedLines = new Mock<ITrackedLines>();
214+
mockTrackedLines.Setup(trackedLines => trackedLines.GetLines(0, 10)).Returns(new List<IDynamicLine> { new Mock<IDynamicLine>().Object });
215+
mockTrackedLinesFactory.Setup(trackedLinesFactory => trackedLinesFactory.Create(It.IsAny<List<ILine>>(), textSnapshot, "filepath"))
216+
.Returns(mockTrackedLines.Object);
217+
218+
219+
var bufferLineCoverage = autoMoqer.Create<BufferLineCoverage>();
220+
void RaiseChangedOnBackground()
221+
{
222+
mockTextBuffer.Raise(textBuffer => textBuffer.ChangedOnBackground += null, new TextContentChangedEventArgs(new Mock<ITextSnapshot>().Object, new Mock<ITextSnapshot>().Object, new EditOptions(), null));
223+
}
224+
void RaiseTestExecutionStartingMessage()
225+
{
226+
(bufferLineCoverage as IListener<TestExecutionStartingMessage>).Handle(new TestExecutionStartingMessage());
227+
}
228+
229+
230+
231+
RaiseTestExecutionStartingMessage();
232+
Thread.Sleep(1);
233+
RaiseChangedOnBackground();
234+
235+
bufferLineCoverage.Handle(new NewCoverageLinesMessage { CoverageLines = new Mock<IFileLineCoverage>().Object });
236+
237+
autoMoqer.Verify<ILogger>(ILogger => ILogger.Log("Not creating editor marks for filepath as it was changed after test execution started"));
238+
239+
}
240+
170241
[Test]
171242
public void Should_Not_Throw_If_No_Initial_Coverage()
172243
{
173244
SimpleTextInfoSetUp();
174245

175-
new BufferLineCoverage(null, textInfo, new Mock<IEventAggregator>().Object, null, null,new Mock<IAppOptionsProvider>().Object);
246+
new BufferLineCoverage(null, textInfo, new Mock<IEventAggregator>().Object, null, null,new Mock<IAppOptionsProvider>().Object,null);
176247
}
177248

178249
[Test]
@@ -330,6 +401,31 @@ public void Should_Update_TrackedLines_When_Text_Buffer_ChangedOnBackground(bool
330401

331402
}
332403

404+
[Test]
405+
public void Should_Log_When_Exception_Updating_TrackedLines_When_Text_Buffer_ChangedOnBackground()
406+
{
407+
SimpleTextInfoSetUp();
408+
409+
var mockAfterSnapshot = new Mock<ITextSnapshot>();
410+
mockAfterSnapshot.SetupGet(textSnapshot => textSnapshot.LineCount).Returns(100);
411+
412+
var newSpan = new Span(1, 2);
413+
var mockTrackedLines = new Mock<ITrackedLines>();
414+
var changedLineNumbers = new List<int> { 11, 12 };
415+
var exception = new Exception("message");
416+
mockTrackedLines.Setup(trackedLines => trackedLines.GetChangedLineNumbers(mockAfterSnapshot.Object, new List<Span> { newSpan }))
417+
.Throws(exception);
418+
autoMoqer.Setup<ITrackedLinesFactory, ITrackedLines>(trackedLinesFactory => trackedLinesFactory.Create(It.IsAny<List<ILine>>(), It.IsAny<ITextSnapshot>(), It.IsAny<string>()))
419+
.Returns(mockTrackedLines.Object);
420+
421+
422+
var bufferLineCoverage = autoMoqer.Create<BufferLineCoverage>();
423+
424+
mockTextBuffer.Raise(textBuffer => textBuffer.ChangedOnBackground += null, CreateTextContentChangedEventArgs(mockAfterSnapshot.Object, newSpan));
425+
426+
autoMoqer.Verify<ILogger>(logger => logger.Log("Error updating tracked lines for filepath", exception));
427+
}
428+
333429
[Test]
334430
public void Should_Not_Throw_When_Text_Buffer_Changed_And_No_Coverage()
335431
{

‎FineCodeCoverageTests/Editor/DynamicCoverage/ContainingCodeTrackedLinesBuilder_Tests.cs‎

Lines changed: 45 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -121,9 +121,7 @@ public void Should_Use_CoverageContentType_FileCodeSpanRangeService_When_UseFile
121121
mockContainingCodeTrackedLinesFactory.VerifyAll();
122122
}
123123

124-
[TestCase(true)]
125-
[TestCase(false)]
126-
public void Should_Create_Null_TrackedLines__When_Coverage_Lines_Not_Within_TextSnapshot(bool inSnapshot)
124+
private ITrackedLines CoverageLinesNotWithinSnapshot(bool inSnapshot,string filePath = "", Action<AutoMoqer> additionalSetup = null)
127125
{
128126
var line1 = new Line(1);
129127
var line2 = new Line(inSnapshot ? 2 : 100);
@@ -132,7 +130,7 @@ public void Should_Create_Null_TrackedLines__When_Coverage_Lines_Not_Within_Text
132130
mockTextSnapshot.SetupGet(textSnapshot => textSnapshot.ContentType.TypeName).Returns("contenttypename");
133131
mockTextSnapshot.SetupGet(textSnapshot => textSnapshot.LineCount).Returns(5);
134132
var autoMoqer = new AutoMoqer();
135-
133+
additionalSetup?.Invoke(autoMoqer);
136134
var trackedLinesFromFactory = new Mock<IContainingCodeTrackerTrackedLines>().Object;
137135

138136
var mockCoverageContentType = new Mock<ICoverageContentType>();
@@ -141,8 +139,15 @@ public void Should_Create_Null_TrackedLines__When_Coverage_Lines_Not_Within_Text
141139

142140
var containingCodeTrackedLinesBuilder = autoMoqer.Create<ContainingCodeTrackedLinesBuilder>();
143141

144-
var trackedLines = containingCodeTrackedLinesBuilder.Create(new List<ILine> { line1, line2 }, mockTextSnapshot.Object,"");
142+
return containingCodeTrackedLinesBuilder.Create(new List<ILine> { line1, line2 }, mockTextSnapshot.Object, filePath);
145143

144+
}
145+
146+
[TestCase(true)]
147+
[TestCase(false)]
148+
public void Should_Create_Null_TrackedLines__When_Coverage_Lines_Not_Within_TextSnapshot(bool inSnapshot)
149+
{
150+
var trackedLines = CoverageLinesNotWithinSnapshot(inSnapshot);
146151
if (inSnapshot)
147152
{
148153
Assert.IsNotNull(trackedLines);
@@ -153,6 +158,16 @@ public void Should_Create_Null_TrackedLines__When_Coverage_Lines_Not_Within_Text
153158
}
154159
}
155160

161+
[Test]
162+
public void Should_Log_When_Coverage_Lines_Not_Within_TextSnapshot()
163+
{
164+
var mockLogger = new Mock<ILogger>();
165+
166+
_ = CoverageLinesNotWithinSnapshot(false, "filepath", autoMoqer => autoMoqer.SetInstance(mockLogger.Object));
167+
168+
mockLogger.Verify(logger => logger.Log("Not creating editor marks for filepath as some coverage lines are outside the text snapshot"));
169+
}
170+
156171
[TestCase(ContainingCodeTrackerType.CoverageLines, 1, DynamicCoverageType.Covered, true, true)]
157172
[TestCase(ContainingCodeTrackerType.NotIncluded, 1, DynamicCoverageType.NotIncluded, false, false)]
158173
public void Should_Serialize_State_From_TrackedLines_ContainingCodeTrackers(
@@ -216,12 +231,10 @@ bool newLines
216231
Assert.That(serializedEditorDynamicCoverage.UsedFileCodeSpanRangeService, Is.EqualTo(usedFileCodeSpanRangeService));
217232
}
218233

219-
[TestCase(true)]
220-
[TestCase(false)]
221-
public void Should_Deserialize_AsNull_TrackedLines_If_Text_Has_Changed_Outside_Editor(bool textChanged)
234+
private ITrackedLines ChangedOutsideEditor(bool textChanged,string filePath = "", Action<AutoMoqer> additionalSetup = null)
222235
{
223236
var autoMoqer = new AutoMoqer();
224-
237+
additionalSetup?.Invoke(autoMoqer);
225238
var mockTextSnaphot = new Mock<ITextSnapshot>();
226239
mockTextSnaphot.SetupGet(textSnapshot => textSnapshot.ContentType.TypeName)
227240
.Returns("contenttypename");
@@ -234,15 +247,23 @@ public void Should_Deserialize_AsNull_TrackedLines_If_Text_Has_Changed_Outside_E
234247

235248
var mockJsonConvertService = autoMoqer.GetMock<IJsonConvertService>();
236249
mockJsonConvertService.Setup(jsonConvertService => jsonConvertService.DeserializeObject<SerializedEditorDynamicCoverage>("serializedState"))
237-
.Returns(new SerializedEditorDynamicCoverage {
238-
Text = "text",
239-
SerializedContainingCodeTrackers = new List<SerializedContainingCodeTracker>()
250+
.Returns(new SerializedEditorDynamicCoverage
251+
{
252+
Text = "text",
253+
SerializedContainingCodeTrackers = new List<SerializedContainingCodeTracker>()
240254
});
241255

242256
var containingCodeTrackedLinesBuilder = autoMoqer.Create<ContainingCodeTrackedLinesBuilder>();
243257

244-
var deserializedTrackedLines = containingCodeTrackedLinesBuilder.Create(
245-
"serializedState", mockTextSnaphot.Object,"");
258+
return containingCodeTrackedLinesBuilder.Create(
259+
"serializedState", mockTextSnaphot.Object, filePath);
260+
}
261+
262+
[TestCase(true)]
263+
[TestCase(false)]
264+
public void Should_Deserialize_AsNull_TrackedLines_If_Text_Has_Changed_Outside_Editor(bool textChanged)
265+
{
266+
var deserializedTrackedLines = ChangedOutsideEditor(textChanged);
246267

247268
if (textChanged)
248269
{
@@ -254,6 +275,16 @@ public void Should_Deserialize_AsNull_TrackedLines_If_Text_Has_Changed_Outside_E
254275
}
255276

256277
}
278+
279+
[Test]
280+
public void Should_Log_When_Text_Changed_Outside_Editor()
281+
{
282+
var mockLogger = new Mock<ILogger>();
283+
284+
_ = ChangedOutsideEditor(true, "filepath", autoMoqer => autoMoqer.SetInstance(mockLogger.Object));
285+
286+
mockLogger.Verify(logger => logger.Log("Not creating editor marks for filepath as text has changed"));
287+
}
257288
}
258289

259290
internal class ContainingCodeTrackedLinesBuilder_ContentType_FileLineCoverageService_Tests

‎FineCodeCoverageTests/MsCodeCoverage/RunSettingsTemplateReplacementsFactory_Tests.cs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -731,5 +731,6 @@ internal class TestCoverageProjectOptions : IAppOptions
731731
public bool ShowNotIncludedInOverviewMargin { get; set; }
732732
public bool ShowNotIncludedInGlyphMargin { get; set; }
733733
public bool ShowLineNotIncludedHighlighting { get; set; }
734+
public bool BlazorCoverageLinesFromGeneratedSource { get; set; }
734735
}
735736
}

‎README.md‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,13 @@ You can turn off editor colouring by setting the visual studio option EditorCove
8181
You can also set the option to DoNotUseRoslynWhenTextChanges if there is a performance issue. By doing so new lines colouring will not be as good.
8282
If you switch to one of the EditorCoverageColouringMode options then you will need to re-run coverage.
8383

84+
For Blazor components with @code blocks coverage lines can be generated outside these regions.
85+
When the Roslyn syntax tree is available to FCC you can set the option BlazorCoverageLinesFromGeneratedSource to true to limit coverage lines in .razor file to those in generated source.
86+
87+
FCC tracks the visual studio editor and saves this information when a file is closed. If upon re-opening a file the text has changed there will be no coverage marks for this file.
88+
89+
There will also be no editor marks if you edit a file whilst FCC is collecting coverage.
90+
8491
## Why use MS Code Coverage ?
8592

8693
With the old coverage FCC needed to copy your test dll and dependencies and run OpenCover or Coverlet on those files. This is not necessary with ms code coverage.
@@ -284,6 +291,7 @@ If you are using option 1) then project and global options will only be used whe
284291
|--|---|
285292
|**Common**||
286293
|EditorCoverageColouringMode|Set to Off, or Set to DoNotUseRoslynWhenTextChanges if there is a performance issue|
294+
|BlazorCoverageLinesFromGeneratedSource|Set to true to limit coverage lines in .razor file to those in generated source ( when available)|
287295
|ShowEditorCoverage|Set to false to disable all editor coverage indicators|
288296
|ShowCoverageInGlyphMargin|Set to false to prevent coverage marks in the glyph margin|
289297
|ShowCoveredInGlyphMargin|Set to false to prevent covered marks in the glyph margin|

0 commit comments

Comments
 (0)