Merge pull request #139 from JakeGinnivan/MethodCallArgument

Try to invoke methods to include value in step title, if we fail just ig...

Author: MehdiK

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

@@ -226,6 +226,23 @@ public void ComplexArgumentWhenContainerIsNull()
             AssertReturnedArguments(arguments, new object[] { null });
         }
 
+        [Test]
+        public void MethodCallValue()
+        {
+            var arguments = GetArguments(x => x.MethodWithInputs(GetNumberThree(), GetFooString()), new ClassUnderTest());
+            AssertReturnedArguments(arguments, new object[] { 3, "Foo" });
+        }
+
+        private string GetFooString()
+        {
+            return "Foo";
+        }
+
+        private int GetNumberThree()
+        {
+            return 3;
+        }
+
         [Test]
         public void ArrayInputArgumentsProvidedUsingInheritedProperty()
         {

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

@@ -0,0 +1,38 @@
+using System.Linq;
+using NUnit.Framework;
+using Shouldly;
+
+namespace TestStack.BDDfy.Tests.Scanner.FluentScanner
+{
+    [TestFixture]
+    public class StepTitleTests
+    {
+        private string _mutatedState;
+
+        [Test]
+        public void MethodCallInStepTitle()
+        {
+            var story = this
+                .Given(_ => GivenWeMutateSomeState())
+                .Then(_ => ThenTitleHas(AMethodCall()))
+                .BDDfy();
+
+            story.Scenarios.Single().Steps.ElementAt(1).Title.ShouldBe("Then title has Mutated state");
+        }
+
+        private string AMethodCall()
+        {
+            return _mutatedState;
+        }
+
+        private void GivenWeMutateSomeState()
+        {
+            _mutatedState = "Mutated state";
+        }
+
+        private void ThenTitleHas(string result)
+        {
+            result.ShouldBe(_mutatedState);
+        }
+    }
+}

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

@@ -89,6 +89,7 @@
     <Compile Include="Scanner\FluentScanner\DoesNotConflictWithnSubstitute.cs" />
     <Compile Include="Scanner\FluentScanner\FluentWithExamples.cs" />
     <Compile Include="Scanner\FluentScanner\InlineAssertions.cs" />
+    <Compile Include="Scanner\FluentScanner\StepTitleTests.cs" />
     <Compile Include="Scanner\ReflectiveScanner\ReflectiveWithExamples.cs" />
     <Compile Include="Scanner\StepScanners\Examples\ExampleTableTests.cs" />
     <Compile Include="Scanner\StepScanners\Examples\ExampleValueTests.cs" />

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

@@ -61,9 +61,19 @@ private static IEnumerable<StepArgument> ExtractArguments<T>(Expression expressi
             if (unaryExpression != null)
                 return ExtractArguments(unaryExpression, value);
 
+            var methodCallExpression = expression as MethodCallExpression;
+            if (methodCallExpression != null)
+                return Invoke(methodCallExpression, ExtractArguments(methodCallExpression, value));
+
             return new StepArgument[0];
         }
 
+        private static IEnumerable<StepArgument> Invoke(MethodCallExpression methodCallExpression, IEnumerable<StepArgument> args)
+        {
+            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)
         {
             var constants = new List<StepArgument>();
@@ -90,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)
@@ -124,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)
@@ -147,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)
@@ -164,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;
         }
@@ -220,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)