Config to stop execution on a failing then - fixes #34

Author: MehdiK

TestStack.BDDfy.Tests/Configuration/TestRunnerTests.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+using TestStack.BDDfy.Configuration;
+using TestStack.BDDfy.Core;
+using TestStack.BDDfy.Scanners.StepScanners.ExecutableAttribute.GwtAttributes;
+using TestStack.BDDfy.Scanners.StepScanners.Fluent;
+
+namespace TestStack.BDDfy.Tests.Configuration
+{
+    public class TestRunnerTests
+    {
+        public class ScenarioWithFailingThen
+        {
+            [Given]
+            public void PassingGiven()
+            {
+            }
+
+            [When]
+            public void PassingWhen()
+            {
+            }
+
+            [Then]
+            public void FailingThen()
+            {
+                throw new Exception();
+            }
+
+            [AndThen]
+            public void PassingAndThen()
+            {
+            }
+        }
+
+        [TestFixture]
+        public class When_StopExecutionOnFailingThen_IsSetToTrue
+        {
+            [Test]
+            public void FailingThenStopsThePipelineWithReflectiveAPI()
+            {
+                Configurator.Processors.TestRunner.StopExecutionOnFailingThen = true;
+    
+                try
+                {
+                    var testRun = new ScenarioWithFailingThen().LazyBDDfy();
+                    Verify(testRun);
+                }
+                finally
+                {
+                    Configurator.Processors.TestRunner.StopExecutionOnFailingThen = false;
+                }
+            }
+
+            [Test]
+            public void FailingThenStopsThePipelineWithFluentAPI()
+            {
+                Configurator.Processors.TestRunner.StopExecutionOnFailingThen = true;
+    
+                try
+                {
+                    var testRun = new ScenarioWithFailingThen()
+                        .Given(x => x.PassingGiven())
+                        .When(x => x.PassingWhen())
+                        .Then(x => x.FailingThen())
+                        .And(x => x.PassingAndThen())
+                        .LazyBDDfy();
+
+                    Verify(testRun);
+                }
+                finally
+                {
+                    Configurator.Processors.TestRunner.StopExecutionOnFailingThen = false;
+                }
+            }
+
+            private static void Verify(Engine testRun)
+            {
+                Assert.Throws<Exception>(() => testRun.Run());
+                var scenario = testRun.Story.Scenarios.First();
+                Assert.AreEqual(StepExecutionResult.Failed, scenario.Result);
+                var steps = scenario.Steps;
+
+                Assert.AreEqual(4, steps.Count);
+                Assert.AreEqual(StepExecutionResult.Passed, steps[0].Result);
+                Assert.AreEqual(ExecutionOrder.SetupState, steps[0].ExecutionOrder);
+                Assert.AreEqual(StepExecutionResult.Passed, steps[1].Result);
+                Assert.AreEqual(ExecutionOrder.Transition, steps[1].ExecutionOrder);
+                Assert.AreEqual(StepExecutionResult.Failed, steps[2].Result);
+                Assert.AreEqual(ExecutionOrder.Assertion, steps[2].ExecutionOrder);
+                Assert.AreEqual(StepExecutionResult.NotExecuted, steps[3].Result);
+                Assert.AreEqual(ExecutionOrder.ConsecutiveAssertion, steps[3].ExecutionOrder);
+            }
+        }
+
+        [TestFixture]
+        public class When_StopExecutionOnFailingThen_IsLeftAsDefault
+        {
+            [Test]
+            public void FailingThenDoesNotStopThePipelineWithReflectiveAPI()
+            {
+                var testRun = new ScenarioWithFailingThen().LazyBDDfy();
+                Verify(testRun);
+            }
+
+            [Test]
+            public void FailingThenDoesNotStopThePipelineWithFluentAPI()
+            {
+                var testRun = new ScenarioWithFailingThen()
+                    .Given(x => x.PassingGiven())
+                    .When(x => x.PassingWhen())
+                    .Then(x => x.FailingThen())
+                    .And(x => x.PassingAndThen())
+                    .LazyBDDfy();
+
+                Verify(testRun);
+            }
+
+            private static void Verify(Engine testRun)
+            {
+                Assert.Throws<Exception>(() => testRun.Run());
+                var scenario = testRun.Story.Scenarios.First();
+                Assert.AreEqual(StepExecutionResult.Failed, scenario.Result);
+                var steps = scenario.Steps;
+
+                Assert.AreEqual(4, steps.Count);
+                Assert.AreEqual(StepExecutionResult.Passed, steps[0].Result);
+                Assert.AreEqual(ExecutionOrder.SetupState, steps[0].ExecutionOrder);
+                Assert.AreEqual(StepExecutionResult.Passed, steps[1].Result);
+                Assert.AreEqual(ExecutionOrder.Transition, steps[1].ExecutionOrder);
+                Assert.AreEqual(StepExecutionResult.Failed, steps[2].Result);
+                Assert.AreEqual(ExecutionOrder.Assertion, steps[2].ExecutionOrder);
+                Assert.AreEqual(StepExecutionResult.Passed, steps[3].Result);
+                Assert.AreEqual(ExecutionOrder.ConsecutiveAssertion, steps[3].ExecutionOrder);
+            }
+        }
+    }
+}

TestStack.BDDfy.Tests/TestStack.BDDfy.Tests.csproj

@@ -66,6 +66,7 @@
     <Compile Include="Arguments\ArgumentsProvidedForGiven.cs" />
     <Compile Include="Arguments\ArgumentsProvidedForThen.cs" />
     <Compile Include="Arguments\MultipleArgumentsProvidedForTheSameStep.cs" />
+    <Compile Include="Configuration\TestRunnerTests.cs" />
     <Compile Include="Scanner\WhenStepScannerFactoryAsyncMethods.cs" />
     <Compile Include="Configuration\CustomProcessor.cs" />
     <Compile Include="Configuration\BatchProcessorsTests.cs" />

TestStack.BDDfy/Configuration/Processors.cs

@@ -33,8 +33,8 @@ IEnumerable<IProcessor> _GetProcessors(Story story)
             }
         }
 
-        private readonly ProcessorFactory _testRunnerFactory = new ProcessorFactory(() => new TestRunner());
-        public ProcessorFactory TestRunner { get { return _testRunnerFactory; } }
+        private readonly TestRunnerFactory _testRunnerFactory = new TestRunnerFactory(() => new TestRunner());
+        public TestRunnerFactory TestRunner { get { return _testRunnerFactory; } }
 
         private readonly ProcessorFactory _consoleReportFactory = new ProcessorFactory(() => new ConsoleReporter());
         public ProcessorFactory ConsoleReport { get { return _consoleReportFactory; } }

TestStack.BDDfy/Configuration/TestRunnerFactory.cs

@@ -0,0 +1,23 @@
+using System;
+using TestStack.BDDfy.Core;
+
+namespace TestStack.BDDfy.Configuration
+{
+    public class TestRunnerFactory : ProcessorFactory
+    {
+        internal TestRunnerFactory(Func<IProcessor> factory) : base(factory)
+        {
+            StopExecutionOnFailingThen = false;
+        }
+
+        internal TestRunnerFactory(Func<IProcessor> factory, bool active) : base(factory, active)
+        {
+            StopExecutionOnFailingThen = false;
+        }
+
+        /// <summary>
+        /// Set to true if you want the execution pipleline to stop when a Then step fails. Defaulted to false
+        /// </summary>
+        public bool StopExecutionOnFailingThen { get; set; }
+    }
+}

TestStack.BDDfy/Processors/TestRunner.cs

@@ -18,7 +18,7 @@ public void Process(Story story)
                     if (scenario.ExecuteStep(executionStep) == StepExecutionResult.Passed) 
                         continue;
 
-                    if(!executionStep.Asserts)
+                    if (Configuration.Configurator.Processors.TestRunner.StopExecutionOnFailingThen || !executionStep.Asserts)
                         break;
                 }
             }

TestStack.BDDfy/TestStack.BDDfy.csproj

@@ -70,6 +70,7 @@
     <Compile Include="Configuration\Processors.cs" />
     <Compile Include="Configuration\Scanners.cs" />
     <Compile Include="Configuration\StepScannerFactory.cs" />
+    <Compile Include="Configuration\TestRunnerFactory.cs" />
     <Compile Include="Core\IBatchProcessor.cs" />
     <Compile Include="Processors\Reporters\ConsoleReporter.cs" />
     <Compile Include="Processors\Reporters\Diagnostics\DiagnosticsReportBuilder.cs" />