Made StepArgument evaluation lazy

Author: Jake Ginnivan

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

@@ -7,23 +7,32 @@ namespace TestStack.BDDfy.Tests.Scanner.FluentScanner
     [TestFixture]
     public class StepTitleTests
     {
+        private string _mutatedState;
+
         [Test]
         public void MethodCallInStepTitle()
         {
-            var story = this.Given(_ => GivenAValueOf(AMethodCall()))
+            var story = this
+                .Given(_ => GivenWeMutateSomeState())
+                .Then(_ => ThenTitleHas(AMethodCall()))
                 .BDDfy();
 
-            story.Scenarios.Single().Steps.Single().Title.ShouldBe("Given a value of Some value");
+            story.Scenarios.Single().Steps.ElementAt(1).Title.ShouldBe("Then title has Mutated state");
         }
 
         private string AMethodCall()
         {
-            return "Some value";
+            return _mutatedState;
+        }
+
+        private void GivenWeMutateSomeState()
+        {
+            _mutatedState = "Mutated state";
         }
 
-        private void GivenAValueOf(string result)
+        private void ThenTitleHas(string result)
         {
-            
+            result.ShouldBe(_mutatedState);
         }
     }
 }

TestStack.BDDfy/Scanners/StepScanners/Fluent/ExpressionExtensions.cs

@@ -70,15 +70,8 @@ private static IEnumerable<StepArgument> ExtractArguments<T>(Expression expressi
 
         private static IEnumerable<StepArgument> Invoke(MethodCallExpression methodCallExpression, IEnumerable<StepArgument> args)
         {
-            try
-            {
-                var value = ((ConstantExpression)methodCallExpression.Object).Value;
-                return new[] { new StepArgument(methodCallExpression.Method.Invoke(value, args.Select(s => s.Value).ToArray())) };
-            }
-            catch (Exception)
-            {
-                return Enumerable.Empty<StepArgument>();
-            }
+            var value = ((ConstantExpression)methodCallExpression.Object).Value;
+            return new[] { new StepArgument(() => methodCallExpression.Method.Invoke(value, args.Select(s => s.Value).ToArray())) };
         }
 
         private static IEnumerable<StepArgument> ExtractArguments<T>(MethodCallExpression methodCallExpression, T value)
@@ -107,7 +100,7 @@ private static IEnumerable<StepArgument> ExtractArguments<T>(NewExpression newEx
                 arguments.AddRange(ExtractArguments(argumentExpression, value));
             }
 
-            return new[] { new StepArgument(newExpression.Constructor.Invoke(arguments.Select(o => o.Value).ToArray())) };
+            return new[] { new StepArgument(() => newExpression.Constructor.Invoke(arguments.Select(o => o.Value).ToArray())) };
         }
 
         private static IEnumerable<StepArgument> ExtractArguments<T>(NewArrayExpression newArrayExpression, T value)
@@ -141,7 +134,7 @@ private static IEnumerable<StepArgument> ExtractNonConvertibleArrayConstants<T>(
                     arrayElements.Add(arrayElement);
             }
 
-            return ToArray(arrayElements).Select(o => new StepArgument(o));
+            return ToArray(arrayElements).Select(o => new StepArgument(() => o));
         }
 
         private static IEnumerable<object> ToArray(IList list)
@@ -164,7 +157,7 @@ private static IEnumerable<StepArgument> ExtractConvertibleTypeArrayConstants(Ne
                 arrayElements.Add(Convert.ChangeType(arrayElement, arrayElementExpression.Type, null));
             }
 
-            return new[] { new StepArgument(ToArray(arrayElements)) };
+            return new[] { new StepArgument(() => ToArray(arrayElements)) };
         }
 
         private static IEnumerable<StepArgument> ExtractArguments<T>(ConstantExpression constantExpression, T value)
@@ -181,7 +174,7 @@ private static IEnumerable<StepArgument> ExtractArguments<T>(ConstantExpression
                 constantExpression.Type.IsPrimitive ||
                 constantExpression.Type.IsEnum ||
                 constantExpression.Value == null)
-                constants.Add(new StepArgument(constantExpression.Value));
+                constants.Add(new StepArgument(() => constantExpression.Value));
 
             return constants;
         }
@@ -237,14 +230,7 @@ private static StepArgument ExtractPropertyValue<T>(MemberExpression expression,
             if (memberExpression != null)
             {
                 var extractArguments = ExtractArgument(memberExpression, value).Value;
-                try
-                {
-                    return new StepArgument(member, extractArguments);
-                }
-                catch (TargetException)
-                {
-                    return new StepArgument(null);
-                }
+                return new StepArgument(member, extractArguments);
             }
             return new StepArgument(member, value);
         }

TestStack.BDDfy/Scanners/StepScanners/Fluent/StepArgument.cs

@@ -6,31 +6,46 @@ namespace TestStack.BDDfy
     public class StepArgument
     {
         private readonly Action<object> _set = o => { };
+        private readonly Func<object> _get;
 
         public StepArgument(FieldInfo member, object declaringObject)
         {
             Name = member.Name;
-            Value = member.GetValue(declaringObject);
+            _get = () => member.GetValue(declaringObject);
             _set = o => member.SetValue(declaringObject, o);
             ArgumentType = member.FieldType;
         }
 
         public StepArgument(PropertyInfo member, object declaringObject)
         {
             Name = member.Name;
-            Value = member.GetGetMethod(true).Invoke(declaringObject, null);
+            _get = () => member.GetGetMethod(true).Invoke(declaringObject, null);
             _set = o => member.GetSetMethod(true).Invoke(declaringObject, new[] { o });
             ArgumentType = member.PropertyType;
         }
 
-        public StepArgument(object value)
+        public StepArgument(Func<object> value)
         {
-            Value = value;
+            _get = value;
             ArgumentType = typeof(object);
         }
 
-        public string Name { get; set; }
-        public object Value { get; set; }
+        public string Name { get; private set; }
+
+        public object Value
+        {
+            get
+            {
+                try
+                {
+                    return _get();
+                }
+                catch (Exception)
+                {
+                    return null;
+                }
+            }
+        }
         public Type ArgumentType { get; private set; }
 
         public void SetValue(object newValue)