Merge pull request #128 from JakeGinnivan/StepExecutionWithErrors

Step execution with errors

Author: JakeGinnivan

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

@@ -1,5 +1,8 @@
-using NUnit.Framework;
+using System;
+using System.Linq;
+using NUnit.Framework;
 using Shouldly;
+using TestStack.BDDfy.Tests.Configuration;
 
 namespace TestStack.BDDfy.Tests.Scanner.FluentScanner
 {
@@ -19,5 +22,34 @@ public void ShouldBeAbleToChainComplexTestWithFluentApi()
                 .And(() => count++.ShouldBe(4), "And we should still be able to use ands")
                 .BDDfy();
         }
+        
+        [Test]
+        public void ShouldContinueExecutingThensButStopWhenNextNotAssertStepIsHit()
+        {
+            var testRun = new TestRunnerTests.ScenarioWithFailingThen()
+                    .Given(x => x.PassingGiven())
+                    .When(x => x.PassingWhen())
+                    .Then(x => x.FailingThen())
+                    .And(x => x.PassingAndThen())
+                    .When(x => x.PassingWhen())
+                    .LazyBDDfy();
+
+            Assert.Throws<Exception>(() => testRun.Run());
+            var scenario = testRun.Story.Scenarios.First();
+            Assert.AreEqual(Result.Failed, scenario.Result);
+            var steps = scenario.Steps;
+
+            Assert.AreEqual(5, steps.Count);
+            Assert.AreEqual(Result.Passed, steps[0].Result);
+            Assert.AreEqual(ExecutionOrder.SetupState, steps[0].ExecutionOrder);
+            Assert.AreEqual(Result.Passed, steps[1].Result);
+            Assert.AreEqual(ExecutionOrder.Transition, steps[1].ExecutionOrder);
+            Assert.AreEqual(Result.Failed, steps[2].Result);
+            Assert.AreEqual(ExecutionOrder.Assertion, steps[2].ExecutionOrder);
+            Assert.AreEqual(Result.Passed, steps[3].Result);
+            Assert.AreEqual(ExecutionOrder.ConsecutiveAssertion, steps[3].ExecutionOrder);
+            Assert.AreEqual(Result.NotExecuted, steps[4].Result);
+            Assert.AreEqual(ExecutionOrder.Transition, steps[4].ExecutionOrder);
+        }
     }
 }

TestStack.BDDfy/Processors/TestRunner.cs

@@ -16,13 +16,19 @@ public void Process(Story story)
                 var executor = new ScenarioExecutor(scenario);
                 executor.InitializeScenario();
 
+                var stepFailed = false;
                 foreach (var executionStep in scenario.Steps)
                 {
+                    if (stepFailed && ShouldExecuteStepWhenPreviousStepFailed(executionStep))
+                        break;
+
                     if (executor.ExecuteStep(executionStep) == Result.Passed) 
                         continue;
 
-                    if (Configuration.Configurator.Processors.TestRunner.StopExecutionOnFailingThen || !executionStep.Asserts)
+                    if (!executionStep.Asserts)
                         break;
+
+                    stepFailed = true;
                 }
 
                 if (scenario.Example != null)
@@ -32,5 +38,10 @@ public void Process(Story story)
                 }
             }
         }
+
+        private static bool ShouldExecuteStepWhenPreviousStepFailed(Step executionStep)
+        {
+            return Configuration.Configurator.Processors.TestRunner.StopExecutionOnFailingThen || !executionStep.Asserts;
+        }
     }
 }