Merge pull request #144 from JakeGinnivan/MovedArgumentsToStep

MehdiK · MehdiK · commit e9dbc631add5 · 2014-05-07T14:07:01.000-04:00
Moved the argument collection for local variable setting support to step...
diff --git a/TestStack.BDDfy.Tests/Processors/TestRunnerTests.cs b/TestStack.BDDfy.Tests/Processors/TestRunnerTests.cs
@@ -23,9 +23,9 @@ public void InitialisesScenarioWithExampleBeforeRunning()
 
             var sut = new TestRunner();
             Action<object> action = o => actualValue = ExampleValue;
-            var steps = new List<Step> { new Step(action, new StepTitle("A Step"), true, ExecutionOrder.Initialize, true) };
+            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<StepArgument>(), new List<string>());
+            var scenarioWithExample = new Scenario("id", this, steps, "Scenario Text", exampleTable, new List<string>());
             var story = new Story(new StoryMetadata(typeof(TestRunnerTests), new StoryNarrativeAttribute()),
                 new[] { scenarioWithExample });
 
diff --git a/TestStack.BDDfy.Tests/Reporters/ReportTestData.cs b/TestStack.BDDfy.Tests/Reporters/ReportTestData.cs
@@ -118,8 +118,8 @@ private Scenario[] GetScenarios(bool includeFailingScenario, bool includeExample
                 }
                 return new List<Scenario>
                 {
-                    new Scenario(exampleId, typeof(ExampleScenario), GetExampleExecutionSteps(), "Example Scenario", exampleTable.ElementAt(0), new List<StepArgument>(), new List<string>()),
-                    new Scenario(exampleId, typeof(ExampleScenario), exampleExecutionSteps, "Example Scenario", exampleTable.ElementAt(1), new List<StepArgument>(), new List<string>())
+                    new Scenario(exampleId, typeof(ExampleScenario), GetExampleExecutionSteps(), "Example Scenario", exampleTable.ElementAt(0), new List<string>()),
+                    new Scenario(exampleId, typeof(ExampleScenario), exampleExecutionSteps, "Example Scenario", exampleTable.ElementAt(1), new List<string>())
                 }.ToArray();
             }
 
@@ -162,9 +162,9 @@ private List<Step> GetHappyExecutionSteps()
         {
             var steps = new List<Step>
             {
-                new Step(null, new StepTitle("Given a positive account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
-                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
-                new Step(null, new StepTitle("Then money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("Given a positive account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("Then money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
             };
             return steps;
         }
@@ -173,9 +173,9 @@ private List<Step> GetExampleExecutionSteps()
         {
             var steps = new List<Step>
             {
-                new Step(null, new StepTitle("Given a <sign> account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
-                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
-                new Step(null, new StepTitle("Then money <action> dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("Given a <sign> account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("Then money <action> dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
             };
             return steps;
         }
@@ -184,9 +184,9 @@ private List<Step> GetSadExecutionSteps()
         {
             var steps = new List<Step>
             {
-                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
-                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
-                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
+                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},
             };
             return steps;
         }
@@ -195,9 +195,9 @@ private List<Step> GetFailingExecutionSteps()
         {
             var steps = new List<Step>
             {
-                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true),
-                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true),
-                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true),
+                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()),
+                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()),
+                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()),
             };
 
             SetAllStepResults(steps, Result.Passed);
@@ -220,9 +220,9 @@ private List<Step> GetInconclusiveExecutionSteps()
         {
             var steps = new List<Step>
             {
-                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
             };
 
             SetAllStepResults(steps, Result.Passed);
@@ -237,9 +237,9 @@ private List<Step> GetNotImplementedExecutionSteps()
         {
             var steps = new List<Step>
             {
-                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
             };
 
             SetAllStepResults(steps, Result.Passed);
diff --git a/TestStack.BDDfy/Processors/ScenarioExecutor.cs b/TestStack.BDDfy/Processors/ScenarioExecutor.cs
@@ -29,7 +29,7 @@ public void InitializeScenario()
                 .OfType<FieldInfo>()
                 .Select(f => new StepArgument(f, _scenario.TestObject))
                 .Union(memberInfos.OfType<PropertyInfo>().Select(m => new StepArgument(m, _scenario.TestObject)))
-                .Union(_scenario.Arguments)
+                .Union(_scenario.Steps.SelectMany(s=>s.Arguments))
                 .ToArray();
 
             foreach (var cell in _scenario.Example.Values)
diff --git a/TestStack.BDDfy/Scanners/ScenarioScanners/FluentScenarioScanner.cs b/TestStack.BDDfy/Scanners/ScenarioScanners/FluentScenarioScanner.cs
@@ -8,13 +8,11 @@ namespace TestStack.BDDfy
     public class FluentScenarioScanner : IScenarioScanner
     {
         private readonly string _title;
-        private readonly List<StepArgument> _arguments;
         private readonly List<Step> _steps;
 
-        public FluentScenarioScanner(List<Step> steps, string title, List<StepArgument> arguments)
+        public FluentScenarioScanner(List<Step> steps, string title)
         {
             _title = title;
-            _arguments = arguments;
             _steps = steps;
         }
 
@@ -25,7 +23,7 @@ public IEnumerable<Scenario> Scan(ITestContext testContext)
             {
                 var scenarioId = Configurator.IdGenerator.GetScenarioId();
                 return testContext.Examples.Select(example =>
-                    new Scenario(scenarioId, testContext.TestObject, CloneSteps(_steps), scenarioText, example, _arguments, testContext.Tags));
+                    new Scenario(scenarioId, testContext.TestObject, CloneSteps(_steps), scenarioText, example, testContext.Tags));
             }
 
             return new[] { new Scenario(testContext.TestObject, _steps, scenarioText, testContext.Tags) };
diff --git a/TestStack.BDDfy/Scanners/ScenarioScanners/ReflectiveScenarioScanner.cs b/TestStack.BDDfy/Scanners/ScenarioScanners/ReflectiveScenarioScanner.cs
@@ -47,7 +47,7 @@ public virtual IEnumerable<Scenario> Scan(ITestContext testContext)
             {
                 var steps = ScanScenarioForSteps(testContext, example);
                 var orderedSteps = steps.OrderBy(o => o.ExecutionOrder).ThenBy(o => o.ExecutionSubOrder).ToList();
-                yield return new Scenario(scenarioId, testContext.TestObject, orderedSteps, scenarioTitle, example, new List<StepArgument>(), testContext.Tags);
+                yield return new Scenario(scenarioId, testContext.TestObject, orderedSteps, scenarioTitle, example, testContext.Tags);
             }
         }
 
diff --git a/TestStack.BDDfy/Scanners/StepScanners/ExecutableAttribute/ExecutableAttributeStepScanner.cs b/TestStack.BDDfy/Scanners/StepScanners/ExecutableAttribute/ExecutableAttributeStepScanner.cs
@@ -41,8 +41,8 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo candidateMeth
             var runStepWithArgsAttributes = (RunStepWithArgsAttribute[])candidateMethod.GetCustomAttributes(typeof(RunStepWithArgsAttribute), false);
             if (runStepWithArgsAttributes.Length == 0)
             {
-                yield return
-                    new Step(StepActionFactory.GetStepAction(candidateMethod, new object[0]), stepTitle, stepAsserts, executableAttribute.ExecutionOrder, true)
+                var stepAction = StepActionFactory.GetStepAction(candidateMethod, new object[0]);
+                yield return new Step(stepAction, stepTitle, stepAsserts, executableAttribute.ExecutionOrder, true, new List<StepArgument>())
                         {
                             ExecutionSubOrder = executableAttribute.Order
                         };
@@ -60,9 +60,9 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo candidateMeth
                 else if (!string.IsNullOrEmpty(executableAttribute.StepTitle))
                     methodName = string.Format(executableAttribute.StepTitle, flatInput);
 
-                yield return
-                    new Step(StepActionFactory.GetStepAction(candidateMethod, inputArguments), new StepTitle(methodName), stepAsserts,
-                                      executableAttribute.ExecutionOrder, true)
+                var stepAction = StepActionFactory.GetStepAction(candidateMethod, inputArguments);
+                yield return new Step(stepAction, new StepTitle(methodName), stepAsserts,
+                                      executableAttribute.ExecutionOrder, true, new List<StepArgument>())
                         {
                             ExecutionSubOrder = executableAttribute.Order
                         };
@@ -100,7 +100,7 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo method, Examp
             }
 
             var stepAction = StepActionFactory.GetStepAction(method, inputs.ToArray());
-            yield return new Step(stepAction, new StepTitle(stepTitle), stepAsserts, executableAttribute.ExecutionOrder, true);
+            yield return new Step(stepAction, new StepTitle(stepTitle), stepAsserts, executableAttribute.ExecutionOrder, true, new List<StepArgument>());
         }
 
 
diff --git a/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs b/TestStack.BDDfy/Scanners/StepScanners/Fluent/FluentScanner.cs
@@ -41,7 +41,6 @@ internal class FluentScanner<TScenario> : IFluentScanner
         private readonly List<Step> _steps = new List<Step>();
         private readonly TScenario _testObject;
         private readonly ITestContext _testContext;
-        private readonly List<StepArgument> _arguments = new List<StepArgument>();
 
         internal FluentScanner(TScenario testObject)
         {
@@ -51,17 +50,19 @@ internal FluentScanner(TScenario testObject)
 
         IScanner IFluentScanner.GetScanner(string scenarioTitle, Type explicitStoryType)
         {
-            return new DefaultScanner(_testContext, new FluentScenarioScanner(_steps, scenarioTitle, _arguments), explicitStoryType);
+            return new DefaultScanner(_testContext, new FluentScenarioScanner(_steps, scenarioTitle), explicitStoryType);
         }
 
         public void AddStep(Action stepAction, string title, bool reports, ExecutionOrder executionOrder, bool asserts)
         {
-            _steps.Add(new Step(StepActionFactory.GetStepAction<object>(o => stepAction()), new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));
+            var action = StepActionFactory.GetStepAction<object>(o => stepAction());
+            _steps.Add(new Step(action, new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, new List<StepArgument>()));
         }
 
         public void AddStep(Func<Task> stepAction, string title, bool reports, ExecutionOrder executionOrder, bool asserts)
         {
-            _steps.Add(new Step(StepActionFactory.GetStepAction<object>(o => stepAction()), new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));
+            var action = StepActionFactory.GetStepAction<object>(o => stepAction());
+            _steps.Add(new Step(action, new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, new List<StepArgument>()));
         }
 
         public void AddStep(Expression<Func<TScenario, Task>> stepAction, string stepTextTemplate, bool includeInputsInStepTitle, bool reports, ExecutionOrder executionOrder, bool asserts)
@@ -74,8 +75,8 @@ public void AddStep(Expression<Func<TScenario, Task>> stepAction, string stepTex
             }
 
             var title = CreateTitle(stepTextTemplate, includeInputsInStepTitle, GetMethodInfo(stepAction), inputArguments);
-            _arguments.AddRange(inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)));
-            _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));
+            var args = inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)).ToList();
+            _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, args));
         }
 
         public void AddStep(Expression<Action<TScenario>> stepAction, string stepTextTemplate, bool includeInputsInStepTitle, bool reports, ExecutionOrder executionOrder, bool asserts)
@@ -89,8 +90,8 @@ public void AddStep(Expression<Action<TScenario>> stepAction, string stepTextTem
             }
 
             var title = CreateTitle(stepTextTemplate, includeInputsInStepTitle, GetMethodInfo(stepAction), inputArguments);
-            _arguments.AddRange(inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)));
-            _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));
+            var args = inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)).ToList();
+            _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, args));
         }
 
         private bool FixAsserts(bool asserts, ExecutionOrder executionOrder)
diff --git a/TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs b/TestStack.BDDfy/Scanners/StepScanners/MethodName/MethodNameStepScanner.cs
@@ -101,14 +101,14 @@ private Step GetStep(object testObject, MethodNameMatcher matcher, MethodInfo me
             }
 
             var stepAction = GetStepAction(method, inputs.ToArray(), returnsItsText);
-            return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport);
+            return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport, new List<StepArgument>());
         }
 
         private Step GetStep(object testObject, MethodNameMatcher matcher, MethodInfo method, bool returnsItsText, object[] inputs = null, RunStepWithArgsAttribute argAttribute = null)
         {
             var stepMethodName = GetStepTitle(method, testObject, argAttribute, returnsItsText);
             var stepAction = GetStepAction(method, inputs, returnsItsText);
-            return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport);
+            return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport, new List<StepArgument>());
         }
 
         private string GetStepTitle(MethodInfo method, object testObject, RunStepWithArgsAttribute argAttribute, bool returnsItsText)
diff --git a/TestStack.BDDfy/Scenario.cs b/TestStack.BDDfy/Scenario.cs
diff --git a/TestStack.BDDfy/Step.cs b/TestStack.BDDfy/Step.cs

Original file line number	Diff line number	Diff line change
`@@ -118,8 +118,8 @@ private Scenario[] GetScenarios(bool includeFailingScenario, bool includeExample`
`118`	`118`	`}`
`119`	`119`	`return new List<Scenario>`
`120`	`120`	`{`
`121`		`- new Scenario(exampleId, typeof(ExampleScenario), GetExampleExecutionSteps(), "Example Scenario", exampleTable.ElementAt(0), new List<StepArgument>(), new List<string>()),`
`122`		`- new Scenario(exampleId, typeof(ExampleScenario), exampleExecutionSteps, "Example Scenario", exampleTable.ElementAt(1), new List<StepArgument>(), new List<string>())`
	`121`	`+ new Scenario(exampleId, typeof(ExampleScenario), GetExampleExecutionSteps(), "Example Scenario", exampleTable.ElementAt(0), new List<string>()),`
	`122`	`+ new Scenario(exampleId, typeof(ExampleScenario), exampleExecutionSteps, "Example Scenario", exampleTable.ElementAt(1), new List<string>())`
`123`	`123`	`}.ToArray();`
`124`	`124`	`}`
`125`	`125`
`@@ -162,9 +162,9 @@ private List<Step> GetHappyExecutionSteps()`
`162`	`162`	`{`
`163`	`163`	`var steps = new List<Step>`
`164`	`164`	`{`
`165`		`- new Step(null, new StepTitle("Given a positive account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`166`		`- new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`167`		`- new Step(null, new StepTitle("Then money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`165`	`+ new Step(null, new StepTitle("Given a positive account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`166`	`+ new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`167`	`+ new Step(null, new StepTitle("Then money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`168`	`168`	`};`
`169`	`169`	`return steps;`
`170`	`170`	`}`
`@@ -173,9 +173,9 @@ private List<Step> GetExampleExecutionSteps()`
`173`	`173`	`{`
`174`	`174`	`var steps = new List<Step>`
`175`	`175`	`{`
`176`		`- new Step(null, new StepTitle("Given a <sign> account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`177`		`- new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`178`		`- new Step(null, new StepTitle("Then money <action> dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`176`	`+ new Step(null, new StepTitle("Given a <sign> account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`177`	`+ new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`178`	`+ new Step(null, new StepTitle("Then money <action> dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`179`	`179`	`};`
`180`	`180`	`return steps;`
`181`	`181`	`}`
`@@ -184,9 +184,9 @@ private List<Step> GetSadExecutionSteps()`
`184`	`184`	`{`
`185`	`185`	`var steps = new List<Step>`
`186`	`186`	`{`
`187`		`- new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`188`		`- new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`189`		`- new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`187`	`+ new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`188`	`+ new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
	`189`	`+ new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5), Result = Result.Passed},`
`190`	`190`	`};`
`191`	`191`	`return steps;`
`192`	`192`	`}`
`@@ -195,9 +195,9 @@ private List<Step> GetFailingExecutionSteps()`
`195`	`195`	`{`
`196`	`196`	`var steps = new List<Step>`
`197`	`197`	`{`
`198`		`- new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true),`
`199`		`- new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true),`
`200`		`- new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true),`
	`198`	`+ new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()),`
	`199`	`+ new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()),`
	`200`	`+ new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()),`
`201`	`201`	`};`
`202`	`202`
`203`	`203`	`SetAllStepResults(steps, Result.Passed);`
`@@ -220,9 +220,9 @@ private List<Step> GetInconclusiveExecutionSteps()`
`220`	`220`	`{`
`221`	`221`	`var steps = new List<Step>`
`222`	`222`	`{`
`223`		`- new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
`224`		`- new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
`225`		`- new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
	`223`	`+ new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
	`224`	`+ new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
	`225`	`+ new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
`226`	`226`	`};`
`227`	`227`
`228`	`228`	`SetAllStepResults(steps, Result.Passed);`
`@@ -237,9 +237,9 @@ private List<Step> GetNotImplementedExecutionSteps()`
`237`	`237`	`{`
`238`	`238`	`var steps = new List<Step>`
`239`	`239`	`{`
`240`		`- new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
`241`		`- new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
`242`		`- new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
	`240`	`+ new Step(null, new StepTitle("Given a negative account balance"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
	`241`	`+ new Step(null, new StepTitle("When the account holder requests money"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
	`242`	`+ new Step(null, new StepTitle("Then no money is dispensed"), true, ExecutionOrder.Assertion, true, new List<StepArgument>()) {Duration = new TimeSpan(0, 0, 0, 0, 5)},`
`243`	`243`	`};`
`244`	`244`
`245`	`245`	`SetAllStepResults(steps, Result.Passed);`
Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,11 @@ namespace TestStack.BDDfy`
`8`	`8`	`public class FluentScenarioScanner : IScenarioScanner`
`9`	`9`	`{`
`10`	`10`	`private readonly string _title;`
`11`		`- private readonly List<StepArgument> _arguments;`
`12`	`11`	`private readonly List<Step> _steps;`
`13`	`12`
`14`		`- public FluentScenarioScanner(List<Step> steps, string title, List<StepArgument> arguments)`
	`13`	`+ public FluentScenarioScanner(List<Step> steps, string title)`
`15`	`14`	`{`
`16`	`15`	`_title = title;`
`17`		`- _arguments = arguments;`
`18`	`16`	`_steps = steps;`
`19`	`17`	`}`
`20`	`18`
`@@ -25,7 +23,7 @@ public IEnumerable<Scenario> Scan(ITestContext testContext)`
`25`	`23`	`{`
`26`	`24`	`var scenarioId = Configurator.IdGenerator.GetScenarioId();`
`27`	`25`	`return testContext.Examples.Select(example =>`
`28`		`- new Scenario(scenarioId, testContext.TestObject, CloneSteps(_steps), scenarioText, example, _arguments, testContext.Tags));`
	`26`	`+ new Scenario(scenarioId, testContext.TestObject, CloneSteps(_steps), scenarioText, example, testContext.Tags));`
`29`	`27`	`}`
`30`	`28`
`31`	`29`	`return new[] { new Scenario(testContext.TestObject, _steps, scenarioText, testContext.Tags) };`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public virtual IEnumerable<Scenario> Scan(ITestContext testContext)`
`47`	`47`	`{`
`48`	`48`	`var steps = ScanScenarioForSteps(testContext, example);`
`49`	`49`	`var orderedSteps = steps.OrderBy(o => o.ExecutionOrder).ThenBy(o => o.ExecutionSubOrder).ToList();`
`50`		`- yield return new Scenario(scenarioId, testContext.TestObject, orderedSteps, scenarioTitle, example, new List<StepArgument>(), testContext.Tags);`
	`50`	`+ yield return new Scenario(scenarioId, testContext.TestObject, orderedSteps, scenarioTitle, example, testContext.Tags);`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo candidateMeth`
`41`	`41`	`var runStepWithArgsAttributes = (RunStepWithArgsAttribute[])candidateMethod.GetCustomAttributes(typeof(RunStepWithArgsAttribute), false);`
`42`	`42`	`if (runStepWithArgsAttributes.Length == 0)`
`43`	`43`	`{`
`44`		`- yield return`
`45`		`- new Step(StepActionFactory.GetStepAction(candidateMethod, new object[0]), stepTitle, stepAsserts, executableAttribute.ExecutionOrder, true)`
	`44`	`+ var stepAction = StepActionFactory.GetStepAction(candidateMethod, new object[0]);`
	`45`	`+ yield return new Step(stepAction, stepTitle, stepAsserts, executableAttribute.ExecutionOrder, true, new List<StepArgument>())`
`46`	`46`	`{`
`47`	`47`	`ExecutionSubOrder = executableAttribute.Order`
`48`	`48`	`};`
`@@ -60,9 +60,9 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo candidateMeth`
`60`	`60`	`else if (!string.IsNullOrEmpty(executableAttribute.StepTitle))`
`61`	`61`	`methodName = string.Format(executableAttribute.StepTitle, flatInput);`
`62`	`62`
`63`		`- yield return`
`64`		`- new Step(StepActionFactory.GetStepAction(candidateMethod, inputArguments), new StepTitle(methodName), stepAsserts,`
`65`		`- executableAttribute.ExecutionOrder, true)`
	`63`	`+ var stepAction = StepActionFactory.GetStepAction(candidateMethod, inputArguments);`
	`64`	`+ yield return new Step(stepAction, new StepTitle(methodName), stepAsserts,`
	`65`	`+ executableAttribute.ExecutionOrder, true, new List<StepArgument>())`
`66`	`66`	`{`
`67`	`67`	`ExecutionSubOrder = executableAttribute.Order`
`68`	`68`	`};`
`@@ -100,7 +100,7 @@ public IEnumerable<Step> Scan(ITestContext testContext, MethodInfo method, Examp`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`var stepAction = StepActionFactory.GetStepAction(method, inputs.ToArray());`
`103`		`- yield return new Step(stepAction, new StepTitle(stepTitle), stepAsserts, executableAttribute.ExecutionOrder, true);`
	`103`	`+ yield return new Step(stepAction, new StepTitle(stepTitle), stepAsserts, executableAttribute.ExecutionOrder, true, new List<StepArgument>());`
`104`	`104`	`}`
`105`	`105`
`106`	`106`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,6 @@ internal class FluentScanner<TScenario> : IFluentScanner`
`41`	`41`	`private readonly List<Step> _steps = new List<Step>();`
`42`	`42`	`private readonly TScenario _testObject;`
`43`	`43`	`private readonly ITestContext _testContext;`
`44`		`- private readonly List<StepArgument> _arguments = new List<StepArgument>();`
`45`	`44`
`46`	`45`	`internal FluentScanner(TScenario testObject)`
`47`	`46`	`{`
`@@ -51,17 +50,19 @@ internal FluentScanner(TScenario testObject)`
`51`	`50`
`52`	`51`	`IScanner IFluentScanner.GetScanner(string scenarioTitle, Type explicitStoryType)`
`53`	`52`	`{`
`54`		`- return new DefaultScanner(_testContext, new FluentScenarioScanner(_steps, scenarioTitle, _arguments), explicitStoryType);`
	`53`	`+ return new DefaultScanner(_testContext, new FluentScenarioScanner(_steps, scenarioTitle), explicitStoryType);`
`55`	`54`	`}`
`56`	`55`
`57`	`56`	`public void AddStep(Action stepAction, string title, bool reports, ExecutionOrder executionOrder, bool asserts)`
`58`	`57`	`{`
`59`		`- _steps.Add(new Step(StepActionFactory.GetStepAction<object>(o => stepAction()), new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));`
	`58`	`+ var action = StepActionFactory.GetStepAction<object>(o => stepAction());`
	`59`	`+ _steps.Add(new Step(action, new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, new List<StepArgument>()));`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`public void AddStep(Func<Task> stepAction, string title, bool reports, ExecutionOrder executionOrder, bool asserts)`
`63`	`63`	`{`
`64`		`- _steps.Add(new Step(StepActionFactory.GetStepAction<object>(o => stepAction()), new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));`
	`64`	`+ var action = StepActionFactory.GetStepAction<object>(o => stepAction());`
	`65`	`+ _steps.Add(new Step(action, new StepTitle(title), FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, new List<StepArgument>()));`
`65`	`66`	`}`
`66`	`67`
`67`	`68`	`public void AddStep(Expression<Func<TScenario, Task>> stepAction, string stepTextTemplate, bool includeInputsInStepTitle, bool reports, ExecutionOrder executionOrder, bool asserts)`
`@@ -74,8 +75,8 @@ public void AddStep(Expression<Func<TScenario, Task>> stepAction, string stepTex`
`74`	`75`	`}`
`75`	`76`
`76`	`77`	`var title = CreateTitle(stepTextTemplate, includeInputsInStepTitle, GetMethodInfo(stepAction), inputArguments);`
`77`		`- _arguments.AddRange(inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)));`
`78`		`- _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));`
	`78`	`+ var args = inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)).ToList();`
	`79`	`+ _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, args));`
`79`	`80`	`}`
`80`	`81`
`81`	`82`	`public void AddStep(Expression<Action<TScenario>> stepAction, string stepTextTemplate, bool includeInputsInStepTitle, bool reports, ExecutionOrder executionOrder, bool asserts)`
`@@ -89,8 +90,8 @@ public void AddStep(Expression<Action<TScenario>> stepAction, string stepTextTem`
`89`	`90`	`}`
`90`	`91`
`91`	`92`	`var title = CreateTitle(stepTextTemplate, includeInputsInStepTitle, GetMethodInfo(stepAction), inputArguments);`
`92`		`- _arguments.AddRange(inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)));`
`93`		`- _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports));`
	`93`	`+ var args = inputArguments.Where(s => !string.IsNullOrEmpty(s.Name)).ToList();`
	`94`	`+ _steps.Add(new Step(StepActionFactory.GetStepAction(action), title, FixAsserts(asserts, executionOrder), FixConsecutiveStep(executionOrder), reports, args));`
`94`	`95`	`}`
`95`	`96`
`96`	`97`	`private bool FixAsserts(bool asserts, ExecutionOrder executionOrder)`
Original file line number	Diff line number	Diff line change
`@@ -101,14 +101,14 @@ private Step GetStep(object testObject, MethodNameMatcher matcher, MethodInfo me`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`var stepAction = GetStepAction(method, inputs.ToArray(), returnsItsText);`
`104`		`- return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport);`
	`104`	`+ return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport, new List<StepArgument>());`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`private Step GetStep(object testObject, MethodNameMatcher matcher, MethodInfo method, bool returnsItsText, object[] inputs = null, RunStepWithArgsAttribute argAttribute = null)`
`108`	`108`	`{`
`109`	`109`	`var stepMethodName = GetStepTitle(method, testObject, argAttribute, returnsItsText);`
`110`	`110`	`var stepAction = GetStepAction(method, inputs, returnsItsText);`
`111`		`- return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport);`
	`111`	`+ return new Step(stepAction, new StepTitle(stepMethodName), matcher.Asserts, matcher.ExecutionOrder, matcher.ShouldReport, new List<StepArgument>());`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`private string GetStepTitle(MethodInfo method, object testObject, RunStepWithArgsAttribute argAttribute, bool returnsItsText)`