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

Omer Raviv · Omer Raviv · commit b771f4cc3e8d · 2014-07-29T12:55:15.000+03:00
diff --git a/TestStack.BDDfy.Tests/Configuration/EmptyScenario.cs b/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() { }
+    }
+}
diff --git a/TestStack.BDDfy.Tests/Configuration/StepExecutorTests.cs b/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();
+            }
+        }
+    }
+}
diff --git a/TestStack.BDDfy.Tests/Processors/TestRunnerTests.cs b/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>());
diff --git a/TestStack.BDDfy.Tests/Reporters/TextReporter/TextReporterTests.cs b/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));
diff --git a/TestStack.BDDfy.Tests/Scanner/ReflectiveScanner/WhenStepScannerFactoryAsyncMethods.cs b/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)
diff --git a/TestStack.BDDfy.Tests/TestStack.BDDfy.Tests.csproj b/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" />
diff --git a/TestStack.BDDfy/Configuration/Configurator.cs b/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; }
+        }
+
     }
 }
diff --git a/TestStack.BDDfy/IStepExecutor.cs b/TestStack.BDDfy/IStepExecutor.cs
@@ -0,0 +1,7 @@
+namespace TestStack.BDDfy
+{
+    public interface IStepExecutor
+    {
+        object Execute(Step step, object testObject);
+    }
+}
diff --git a/TestStack.BDDfy/Processors/AsyncTestRunner.cs b/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);
+        }
+    }
+}
diff --git a/TestStack.BDDfy/Processors/AsyncTestSyncContext.cs b/TestStack.BDDfy/Processors/AsyncTestSyncContext.cs
diff --git a/TestStack.BDDfy/Processors/ScenarioExecutor.cs b/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)
diff --git a/TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs b/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)
             {
diff --git a/TestStack.BDDfy/Scanners/StepScanners/StepActionFactory.cs b/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);
         }
     }
 }
diff --git a/TestStack.BDDfy/Step.cs b/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;
-            }
-        }
     }
 }
diff --git a/TestStack.BDDfy/StepExecutor.cs b/TestStack.BDDfy/StepExecutor.cs
diff --git a/TestStack.BDDfy/TestStack.BDDfy.csproj b/TestStack.BDDfy/TestStack.BDDfy.csproj

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Reflection;`
`3`	`3`	`using System.Threading.Tasks;`
`4`	`4`	`using NUnit.Framework;`
	`5`	`+using TestStack.BDDfy.Processors;`
`5`	`6`
`6`	`7`	`namespace TestStack.BDDfy.Tests.Scanner.ReflectiveScanner`
`7`	`8`	`{`
`@@ -11,17 +12,16 @@ public class WhenStepScannerFactoryAsyncMethods`
`11`	`12`	`[Test]`
`12`	`13`	`public void CallingAsyncTaskWhichThrowsIsObservedAndRethrown()`
`13`	`14`	`{`
`14`		`- var stepAction = StepActionFactory.GetStepAction<SomeScenario>(o => AsyncTaskMethod(o));`
`15`		`-`
`16`		`- Assert.Throws<ArgumentException>(()=>stepAction(new SomeScenario()));`
	`15`	`+ var stepAction = StepActionFactory.GetStepAction<SomeScenario>(o => AsyncTaskMethod(o));`
	`16`	`+ Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(new SomeScenario())));`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`[Test]`
`20`	`20`	`public void CallingAsyncVoidWhichThrowsIsObservedAndRethrown()`
`21`	`21`	`{`
`22`	`22`	`var stepAction = StepActionFactory.GetStepAction<SomeScenario>(s=>AsyncVoidMethod(s));`
`23`	`23`
`24`		`- Assert.Throws<ArgumentException>(() => stepAction(new SomeScenario()));`
	`24`	`+ Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(new SomeScenario())));`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`[Test]`
`@@ -30,7 +30,7 @@ public void InvokingAsyncTaskWhichThrowsIsObservedAndRethrown()`
`30`	`30`	`var methodInfo = typeof(WhenStepScannerFactoryAsyncMethods).GetMethod("AsyncVoidMethod", BindingFlags.Instance \| BindingFlags.NonPublic);`
`31`	`31`	`var stepAction = StepActionFactory.GetStepAction(methodInfo, new object[] { new SomeScenario() });`
`32`	`32`
`33`		`- Assert.Throws<ArgumentException>(() => stepAction(this));`
	`33`	`+ Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(this)));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`[Test]`
`@@ -39,7 +39,7 @@ public void InvokingAsyncVoidWhichThrowsIsObservedAndRethrown()`
`39`	`39`	`var methodInfo = typeof(WhenStepScannerFactoryAsyncMethods).GetMethod("AsyncTaskMethod", BindingFlags.Instance \| BindingFlags.NonPublic);`
`40`	`40`	`var stepAction = StepActionFactory.GetStepAction(methodInfo, new object[] { new SomeScenario() });`
`41`	`41`
`42`		`- Assert.Throws<ArgumentException>(() => stepAction(this));`
	`42`	`+ Assert.Throws<ArgumentException>(()=> AsyncTestRunner.Run(() => stepAction(this)));`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`private async void AsyncVoidMethod(SomeScenario someScenario)`
Original file line number	Diff line number	Diff line change
`@@ -26,5 +26,14 @@ public static IKeyGenerator IdGenerator`
`26`	`26`	`get { return _idGenerator; }`
`27`	`27`	`set { _idGenerator = value; }`
`28`	`28`	`}`
	`29`	`+`
	`30`	`+`
	`31`	`+ private static IStepExecutor _stepExecutor = new StepExecutor();`
	`32`	`+ public static IStepExecutor StepExecutor`
	`33`	`+ {`
	`34`	`+ get { return _stepExecutor; }`
	`35`	`+ set { _stepExecutor = value; }`
	`36`	`+ }`
	`37`	`+`
`29`	`38`	`}`
`30`	`39`	`}`