improving code coverage

Author: Gurpreet Singh

coverage-report.ps1

@@ -0,0 +1,10 @@
+dotnet test ./src `
+    --collect:"XPlat Code Coverage" `
+    --results-directory ./TestResults
+
+reportgenerator `
+    -reports:./TestResults/**/coverage.cobertura.xml `
+    -targetdir:./CoverageReport `
+    -reporttypes:Html
+
+Remove-Item -Recurse -Force ./TestResults

src/TestStack.BDDfy.Tests/Configuration/BatchProcessorsTests.cs

@@ -1,17 +1,21 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using Shouldly;
 using TestStack.BDDfy.Configuration;
+using TestStack.BDDfy.Reporters.Diagnostics;
 using TestStack.BDDfy.Reporters.Html;
 using TestStack.BDDfy.Reporters.MarkDown;
+using TestStack.BDDfy.Tests.Concurrency;
 using Xunit;
 
 namespace TestStack.BDDfy.Tests.Configuration
 {
+    [Collection(TestCollectionName.ModifiesConfigurator)]
     public class BatchProcessorsTests
     {
         static bool MetroReportProcessorIsActive(IBatchProcessor batchProcessor)
         {
-            return batchProcessor is HtmlReporter && ((HtmlReporter)batchProcessor).ReportBuilder is MetroReportBuilder;
+            return batchProcessor is HtmlReporter reporter && reporter.ReportBuilder is MetroReportBuilder;
         }
 
         [Fact]
@@ -67,5 +71,35 @@ public void ReturnsHtmlMetroReporterWhenItIsActivated()
 
             Configurator.BatchProcessors.HtmlMetroReport.Disable();
         }
+
+        [Fact]
+        public void ReturnsDianosticsReporterWhenItIsActivated()
+        {
+            Configurator.BatchProcessors.DiagnosticsReport.Enable();
+
+            var processors = Configurator.BatchProcessors.GetProcessors().ToList();
+
+            processors.ShouldContain(p=> p is DiagnosticsReporter, 1);
+
+            Configurator.BatchProcessors.DiagnosticsReport.Disable();
+        }
+
+        [Fact]
+        public void ReturnsAdditionalBatchProcessorsWhenAdded()
+        {
+            Configurator.BatchProcessors.Add(new FooBatchProcessor());
+
+            var processors = Configurator.BatchProcessors.GetProcessors().ToList();
+
+            processors.ShouldContain(p => p is FooBatchProcessor, 1);
+        }
+
+        private class FooBatchProcessor : IBatchProcessor
+        {
+            public void Process(IEnumerable<Story> stories)
+            {
+                throw new System.NotImplementedException();
+            }
+        }
     }
 }

src/TestStack.BDDfy.Tests/Configuration/ProcessorPipelineTests.cs

@@ -3,11 +3,12 @@
 using TestStack.BDDfy.Configuration;
 using TestStack.BDDfy.Processors;
 using TestStack.BDDfy.Reporters;
+using TestStack.BDDfy.Tests.Concurrency;
 using Xunit;
 
 namespace TestStack.BDDfy.Tests.Configuration
 {
-    [Collection("ExclusiveAccessToConfigurator")]
+    [Collection(TestCollectionName.ModifiesConfigurator)]
     public class ProcessorPipelineTests
     {
         [Fact]

src/TestStack.BDDfy.Tests/Configuration/StepExecutorTests.cs

@@ -1,11 +1,12 @@
 using System.Text;
 using Shouldly;
 using TestStack.BDDfy.Configuration;
+using TestStack.BDDfy.Tests.Concurrency;
 using Xunit;
 
 namespace TestStack.BDDfy.Tests.Configuration
 {
-    [Collection("ExclusiveAccessToConfigurator")]
+    [Collection(TestCollectionName.ModifiesConfigurator)]
     public class StepExecutorTests
     {
         private class TestStepExecutor : StepExecutor

src/TestStack.BDDfy.Tests/ExclusiveAccessToConfiguratorFixture.cs

@@ -0,0 +1,10 @@
+using TestStack.BDDfy.Tests.Concurrency;
+using Xunit;
+
+namespace TestStack.BDDfy.Tests
+{
+    [CollectionDefinition(TestCollectionName.ModifiesConfigurator, DisableParallelization = true)]
+    public class ModifiesConfiguratorFixture
+    {
+    }
+}

src/TestStack.BDDfy.Tests/ModifiesConfiguratorFixture.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Linq;
 using Shouldly;
+using TestStack.BDDfy.Tests.Concurrency;
 using TestStack.BDDfy.Tests.Configuration;
 using Xunit;
 
 namespace TestStack.BDDfy.Tests.Scanner.FluentScanner
 {
-    [Collection("ExclusiveAccessToConfigurator")]
+    [Collection(TestCollectionName.ModifiesConfigurator)]
     public class ComplexStepsTests
     {
         private int count;

src/TestStack.BDDfy.Tests/Scanner/FluentScanner/ComplexStepsTests.cs

@@ -0,0 +1,48 @@
+using Shouldly;
+using System.Linq;
+using TestStack.BDDfy.Configuration;
+using Xunit;
+
+namespace TestStack.BDDfy.Tests.Scanner.ReflectiveScanner
+{
+    public class AnyExecutableAttributeWhichIsEmptyOrWhitespaceWillResultInMethodName
+    {
+        private class TypeWithDecoratedMethods
+        {
+            public TypeWithDecoratedMethods()
+            {
+                this.WithExamples(new ExampleTable("Example")
+                {
+                    {1},
+                    {2}
+                });
+            }
+
+            [Given("")]
+            public void GivenWithEmptyString() { }
+            [When("   ")]
+            public void WhenWithWhitespace() { }
+            [Then(null)]
+            public void ThenWithNull() { }
+
+            [AndThen("Then with title should work too")]
+            public void AndThenWithTitle() { }
+        }
+
+        [Fact]
+        public void WhenUsingReflectiveScanner_MethodNamesAreUsedAsStepTitles_When_StepTitlesAreWhiteSpace()
+        {
+            var testObject = new TypeWithDecoratedMethods();
+
+            var stepScanners = Configurator.Scanners.GetStepScanners(testObject).ToArray();
+            var scanner = new ReflectiveScenarioScanner(stepScanners);
+            var scenario = scanner.Scan(TestContext.GetContext(testObject)).First();
+            var steps = scenario.Steps;
+
+            steps[0].Title.ShouldBe("Given with empty string");
+            steps[1].Title.ShouldBe("When with whitespace");
+            steps[2].Title.ShouldBe("Then with null");
+            steps[3].Title.ShouldBe("Then with title should work too");
+        }
+    }
+}

src/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/AnyExecutableAttributeWhichIsEmptyOrWhitespaceWillResultInMethodName.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using TestStack.BDDfy.Processors;
 using TestStack.BDDfy.Reporters.Diagnostics;
 using TestStack.BDDfy.Reporters.Html;
@@ -9,7 +8,9 @@ namespace TestStack.BDDfy.Configuration
 {
     public class BatchProcessors
     {
-        IEnumerable<IBatchProcessor> _GetProcessors()
+        readonly List<IBatchProcessor> _addedProcessors = [];
+
+        private IEnumerable<IBatchProcessor> YieldProcessors()
         {
             var htmlReporter = HtmlReport.ConstructFor(StoryCache.Stories);
             if (htmlReporter != null)
@@ -33,19 +34,14 @@ IEnumerable<IBatchProcessor> _GetProcessors()
             }
         }
 
-        private readonly BatchProcessorFactory _htmlReportFactory = new(() => new HtmlReporter(new DefaultHtmlReportConfiguration()));
-        public BatchProcessorFactory HtmlReport { get { return _htmlReportFactory; } }
-
-        private readonly BatchProcessorFactory _htmlMetroReportFactory = new(() => new HtmlReporter(new DefaultHtmlReportConfiguration(), new MetroReportBuilder()), false);
-        public BatchProcessorFactory HtmlMetroReport { get { return _htmlMetroReportFactory; } }
+        public BatchProcessorFactory HtmlReport { get; } = new(() => new HtmlReporter(new DefaultHtmlReportConfiguration()));
 
-        private readonly BatchProcessorFactory _markDownFactory = new(() => new MarkDownReporter(), false);
-        public BatchProcessorFactory MarkDownReport { get { return _markDownFactory; } }
+        public BatchProcessorFactory HtmlMetroReport { get; } = new(() 
+            => new HtmlReporter(new DefaultHtmlReportConfiguration(), new MetroReportBuilder()), false);
 
-        private readonly BatchProcessorFactory _diagnosticsFactory = new(() => new DiagnosticsReporter(), false);
-        public BatchProcessorFactory DiagnosticsReport { get { return _diagnosticsFactory; } }
+        public BatchProcessorFactory MarkDownReport { get; } = new(() => new MarkDownReporter(), false);
 
-        readonly List<IBatchProcessor> _addedProcessors = new();
+        public BatchProcessorFactory DiagnosticsReport { get; } = new(() => new DiagnosticsReporter(), false);
 
         public BatchProcessors Add(IBatchProcessor processor)
         {
@@ -55,7 +51,7 @@ public BatchProcessors Add(IBatchProcessor processor)
 
         public IEnumerable<IBatchProcessor> GetProcessors()
         {
-            return _GetProcessors().ToList();
+            return [.. YieldProcessors()];
         }
     }
 }

src/TestStack.BDDfy/Configuration/BatchProcessors.cs

@@ -2,15 +2,13 @@
 
 namespace TestStack.BDDfy.Configuration
 {
-    public class ComponentFactory<TComponent, TMaterial> where TComponent : class 
+    public abstract class ComponentFactory<TComponent, TMaterial> where TComponent : class 
     {
-        private bool _active = true;
+        private const bool DefaultState = true;
+        private bool _active = DefaultState;
         private Predicate<TMaterial> _runsOn = o => true;
         readonly Func<TComponent> _factory;
-        internal ComponentFactory(Func<TComponent> factory)
-        {
-            _factory = factory;
-        }
+        internal ComponentFactory(Func<TComponent> factory):this(factory, DefaultState) { }
 
         internal ComponentFactory(Func<TComponent> factory, bool active)
         {
@@ -30,10 +28,10 @@ public void Enable()
 
         public TComponent ConstructFor(TMaterial material)
         {
-            if (!_active || !_runsOn(material))
-                return null;
+            if (_active && _runsOn(material))
+                return _factory();
 
-            return _factory();
+            return null;
         }
 
         public void RunsOn(Predicate<TMaterial> runOn)