Added StepExecutor class to allow users to add custom logic before/after each step.

TestStack.BDDfy.Tests/Configuration/EmptyScenario.cs

@@ -0,0 +1,9 @@
+namespace TestStack.BDDfy.Tests.Configuration
+{
+    public class EmptyScenario
+    {
+        public void GivenSomething() { }
+        public void WhenSomething() { }
+        public void ThenSomething() { }
+    }
+}

TestStack.BDDfy.Tests/Configuration/StepExecutorTests.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Text;
+using NUnit.Framework;
+using TestStack.BDDfy.Configuration;
+
+namespace TestStack.BDDfy.Tests.Configuration
+{
+    [TestFixture]
+    public class StepExecutorTests
+    {
+        private class TestStepExecutor : StepExecutor
+        {
+            readonly StringBuilder _builder = new StringBuilder();
+
+            public string Results
+            {
+                get { return _builder.ToString(); }
+            }
+
+            public override object Execute(Step step, object testObject)
+            {
+                try
+                {
+                    _builder.AppendLine(string.Format("About to run step '{0}'", step.Title));
+                    return base.Execute(step, testObject);
+                }
+                finally
+                {
+                    _builder.AppendLine(string.Format("Finished running step '{0}'", step.Title));
+                }
+            }
+        }
+
+        [Test]
+        public void CustomizingStepExecutionByOverridingStepExecutor()
+        {
+            try
+            {
+                var testStepExecutor = new TestStepExecutor();
+
+                Configurator.StepExecutor = testStepExecutor;
+
+                new EmptyScenario()
+                    .Given(s => s.GivenSomething())
+                    .When(s => s.WhenSomething())
+                    .Then(s => s.ThenSomething())
+                    .BDDfy();
+
+                string expected =
+@"About to run step 'Given something'
+Finished running step 'Given something'
+About to run step 'When something'
+Finished running step 'When something'
+About to run step 'Then something'
+Finished running step 'Then something'
+";
+
+                Assert.AreEqual(expected, testStepExecutor.Results);
+
+            }
+            finally
+            {
+                Configurator.StepExecutor = new StepExecutor();
+            }
+        }
+    }
+}

TestStack.BDDfy.Tests/Processors/TestRunnerTests.cs

@@ -12,7 +12,7 @@ public class TestRunnerTests
         public int ExampleValue { get; set; }
 
         [Test]
-        public void InitialisesScenarioWithExampleBeforeRunning()
+        public void InitializesScenarioWithExampleBeforeRunning()
         {
             const int expectedValue = 1;
             var actualValue = 0;
@@ -22,7 +22,7 @@ public void InitialisesScenarioWithExampleBeforeRunning()
             }.Single();
 
             var sut = new TestRunner();
-            Action<object> action = o => actualValue = ExampleValue;
+            Func<object, object> action = o => actualValue = ExampleValue;
             var steps = new List<Step> { new Step(action, new StepTitle("A Step"), true, ExecutionOrder.Initialize, true, new List<StepArgument>()) };
 
             var scenarioWithExample = new Scenario("id", this, steps, "Scenario Text", exampleTable, new List<string>());

TestStack.BDDfy.Tests/Reporters/TextReporter/TextReporterTests.cs

@@ -51,11 +51,11 @@ public void LongStepName()
             var textReporter = new TextReporter();
             var scenario = new Scenario(typeof(TextReporterTests), new List<Step>
             {
-                new Step(o =>{ }, new StepTitle("Given a normal length title"), false, ExecutionOrder.SetupState, true, new List<StepArgument>()),
-                new Step(o =>{ }, new StepTitle("When something of normal length happens"), false, ExecutionOrder.Transition, true, new List<StepArgument>()),
-                new Step(o =>{ }, new StepTitle("Then some long state should be: #Title\r\n\r\nSome more stuff which is quite long on the second line\r\n\r\nAnd finally another really long line"),
+                new Step(o => null, new StepTitle("Given a normal length title"), false, ExecutionOrder.SetupState, true, new List<StepArgument>()),
+                new Step(o => null, new StepTitle("When something of normal length happens"), false, ExecutionOrder.Transition, true, new List<StepArgument>()),
+                new Step(o => null, new StepTitle("Then some long state should be: #Title\r\n\r\nSome more stuff which is quite long on the second line\r\n\r\nAnd finally another really long line"),
                     true, ExecutionOrder.Assertion, true, new List<StepArgument>()),
-                new Step(o =>{ }, new StepTitle("And a normal length assertion"), true, ExecutionOrder.ConsecutiveAssertion, true, new List<StepArgument>())
+                new Step(o => null, new StepTitle("And a normal length assertion"), true, ExecutionOrder.ConsecutiveAssertion, true, new List<StepArgument>())
             }, "Scenario Text", new List<string>());
             textReporter.Process(new Story(new StoryMetadata(typeof(TextReporterTests), new StoryNarrativeAttribute()),
                 scenario));

TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenStepScannerFactoryAsyncMethods.cs

@@ -2,6 +2,7 @@
 using System.Reflection;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using TestStack.BDDfy.Processors;
 
 namespace TestStack.BDDfy.Tests.Scanner.ReflectiveScanner
 {
@@ -11,17 +12,16 @@ public class WhenStepScannerFactoryAsyncMethods
         [Test]
         public void CallingAsyncTaskWhichThrowsIsObservedAndRethrown()
         {
-            var stepAction = StepActionFactory.GetStepAction<SomeScenario>(o => AsyncTaskMethod(o));
-
-            Assert.Throws<ArgumentException>(()=>stepAction(new SomeScenario()));
+            var stepAction = StepActionFactory.GetStepAction<SomeScenario>(o => AsyncTaskMethod(o));            
+            Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(new SomeScenario())));
         }
 
         [Test]
         public void CallingAsyncVoidWhichThrowsIsObservedAndRethrown()
         {
             var stepAction = StepActionFactory.GetStepAction<SomeScenario>(s=>AsyncVoidMethod(s));
 
-            Assert.Throws<ArgumentException>(() => stepAction(new SomeScenario()));
+            Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(new SomeScenario())));
         }
 
         [Test]
@@ -30,7 +30,7 @@ public void InvokingAsyncTaskWhichThrowsIsObservedAndRethrown()
             var methodInfo = typeof(WhenStepScannerFactoryAsyncMethods).GetMethod("AsyncVoidMethod", BindingFlags.Instance | BindingFlags.NonPublic);
             var stepAction = StepActionFactory.GetStepAction(methodInfo, new object[] { new SomeScenario() });
 
-            Assert.Throws<ArgumentException>(() => stepAction(this));
+            Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(this)));
         }
 
         [Test]
@@ -39,7 +39,7 @@ public void InvokingAsyncVoidWhichThrowsIsObservedAndRethrown()
             var methodInfo = typeof(WhenStepScannerFactoryAsyncMethods).GetMethod("AsyncTaskMethod", BindingFlags.Instance | BindingFlags.NonPublic);
             var stepAction = StepActionFactory.GetStepAction(methodInfo, new object[] { new SomeScenario() });
 
-            Assert.Throws<ArgumentException>(() => stepAction(this));
+            Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(this)));
         }
 
         private async void AsyncVoidMethod(SomeScenario someScenario)

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

@@ -76,7 +76,9 @@
     <Compile Include="Arguments\ArgumentsProvidedForGiven.cs" />
     <Compile Include="Arguments\ArgumentsProvidedForThen.cs" />
     <Compile Include="Arguments\MultipleArgumentsProvidedForTheSameStep.cs" />
+    <Compile Include="Configuration\EmptyScenario.cs" />
     <Compile Include="Configuration\SequentialKeyGeneratorTests.cs" />
+    <Compile Include="Configuration\StepExecutorTests.cs" />
     <Compile Include="Configuration\TestRunnerTests.cs" />
     <Compile Include="Reporters\TextReporter\TextReporterTests.cs" />
     <Compile Include="Reporters\Html\MetroReportBuilderTests.cs" />

TestStack.BDDfy/Configuration/Configurator.cs

@@ -26,5 +26,14 @@ public static IKeyGenerator IdGenerator
             get { return _idGenerator; }
             set { _idGenerator = value; }
         }
+
+
+        private static IStepExecutor _stepExecutor = new StepExecutor();
+        public static IStepExecutor  StepExecutor
+        {
+            get { return _stepExecutor; }
+            set { _stepExecutor = value; }
+        }
+
     }
 }

TestStack.BDDfy/IStepExecutor.cs

@@ -0,0 +1,7 @@
+namespace TestStack.BDDfy
+{
+    public interface IStepExecutor
+    {
+        object Execute(Step step, object testObject);
+    }
+}

TestStack.BDDfy/Processors/AsyncTestRunner.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TestStack.BDDfy.Processors
+{
+    public static class AsyncTestRunner
+    {        
+        public static void Run(Func<object> performStep)
+        {
+            var oldSyncContext = SynchronizationContext.Current;
+            try
+            {
+                var asyncSyncContext = new AsyncTestSyncContext();
+                SetSynchronizationContext(asyncSyncContext);
+                var result = performStep();
+                var task = result as Task;
+                if (task != null)
+                {
+                    try
+                    {
+                        task.Wait();
+                    }
+                    catch (AggregateException ae)
+                    {
+                        var innerException = ae.InnerException;
+                        ExceptionProcessor.PreserveStackTrace(innerException);
+                        throw innerException;
+                    }
+                }
+                else
+                {
+                    var ex = asyncSyncContext.WaitForCompletion();
+                    if (ex != null)
+                    {
+                        ExceptionProcessor.PreserveStackTrace(ex);
+                        throw ex;
+                    }
+                }
+            }
+            finally
+            {
+                SetSynchronizationContext(oldSyncContext);
+            }
+        }
+
+        [SecuritySafeCritical]
+        private static void SetSynchronizationContext(SynchronizationContext context)
+        {
+            SynchronizationContext.SetSynchronizationContext(context);
+        }
+    }
+}

TestStack.BDDfy/Processors/ScenarioExecutor.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Reflection;
+using TestStack.BDDfy.Configuration;
 
 namespace TestStack.BDDfy.Processors
 {
@@ -52,7 +53,7 @@ public Result ExecuteStep(Step step)
         {
             try
             {
-                step.Execute(_scenario.TestObject);
+                AsyncTestRunner.Run(() => Configurator.StepExecutor.Execute(step, _scenario.TestObject));
                 step.Result = Result.Passed;
             }
             catch (Exception ex)

TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs

@@ -172,7 +172,7 @@ private static string GetStepTitleFromMethod(MethodInfo method, RunStepWithArgsA
             }
         }
 
-        static Action<object> GetStepAction(MethodInfo method, object[] inputs, bool returnsItsText)
+        static Func<object,object> GetStepAction(MethodInfo method, object[] inputs, bool returnsItsText)
         {
             if (returnsItsText)
             {

TestStack.BDDfy/Scanners/StepScanners/StepActionFactory.cs

@@ -9,69 +9,25 @@ namespace TestStack.BDDfy
 {
     public class StepActionFactory
     {
-        public static Action<object> GetStepAction(MethodInfo method, object[] inputs)
+        public static Func<object,object> GetStepAction(MethodInfo method, object[] inputs)
         {
-            return o => Run(() => method.Invoke(o, inputs));
+            return o => method.Invoke(o, inputs);
         }
 
-        public static Action<object> GetStepAction<TScenario>(Action<TScenario> action)
+        public static Func<object,object> GetStepAction<TScenario>(Action<TScenario> action)
             where TScenario : class
         {
-            return o => Run(() =>
+            return o => 
             {
                 action((TScenario)o);
                 return null;
-            });
+            };
         }
 
-        public static Action<object> GetStepAction<TScenario>(Func<TScenario, Task> action)
+        public static Func<object,object> GetStepAction<TScenario>(Func<TScenario, Task> action)
            where TScenario : class
         {
-            return o => Run(() => action((TScenario)o));
-        }
-
-        private static void Run(Func<object> func)
-        {
-            var oldSyncContext = SynchronizationContext.Current;
-            try
-            {
-                var asyncSyncContext = new AsyncTestSyncContext();
-                SetSynchronizationContext(asyncSyncContext);
-                var result = func();
-                var task = result as Task;
-                if (task != null)
-                {
-                    try
-                    {
-                        task.Wait();
-                    }
-                    catch (AggregateException ae)
-                    {
-                        var innerException = ae.InnerException;
-                        ExceptionProcessor.PreserveStackTrace(innerException);
-                        throw innerException;
-                    }
-                }
-                else
-                {
-                    var ex = asyncSyncContext.WaitForCompletion();
-                    if (ex != null)
-                    {
-                        ExceptionProcessor.PreserveStackTrace(ex);
-                        throw ex;
-                    }
-                }
-            }
-            finally
-            {
-                SetSynchronizationContext(oldSyncContext);
-            }
-        }
-
-        [SecuritySafeCritical]
-        static void SetSynchronizationContext(SynchronizationContext context)
-        {
-            SynchronizationContext.SetSynchronizationContext(context);
+            return o => action((TScenario)o);
         }
     }
 }

TestStack.BDDfy/Step.cs

@@ -10,7 +10,7 @@ public class Step
         private readonly StepTitle _title;
 
         public Step(
-            Action<object> action,
+            Func<object, object> action,
             StepTitle title,
             bool asserts,
             ExecutionOrder executionOrder,
@@ -40,7 +40,7 @@ public Step(Step step)
         }
 
         public string Id { get; private set; }
-        internal Action<object> Action { get; set; }
+        internal Func<object, object> Action { get; set; }
         public bool Asserts { get; private set; }
         public bool ShouldReport { get; private set; }
         public string Title
@@ -58,21 +58,5 @@ public string Title
         public int ExecutionSubOrder { get; set; }
         public TimeSpan Duration { get; set; }
         public List<StepArgument> Arguments { get; private set; }
-
-        public void Execute(object testObject)
-        {
-            Stopwatch sw = Stopwatch.StartNew();
-            try
-            {
-                Action(testObject);
-                sw.Stop();
-                Duration = sw.Elapsed;
-            }
-            finally
-            {
-                sw.Stop();
-                Duration = sw.Elapsed;
-            }
-        }
     }
 }