Fixing issue with argument extractor not working when drilling into subject

Author: Jake Ginnivan

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

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using NUnit.Framework;
+using Shouldly;
 
 namespace TestStack.BDDfy.Tests.Scanner.FluentScanner
 {
@@ -64,6 +65,15 @@ public void MethodWithInputs(ContainerType subContainer)
             {
 
             }
+
+            public Bar Foo { get; set; }
+
+            public class Bar
+            {
+                public void Baz()
+                {
+                }
+            }
         }
 
         object[] GetArguments(Expression<Action<ClassUnderTest>> action, ClassUnderTest instance)
@@ -243,6 +253,13 @@ public void MethodCallValue()
             AssertReturnedArguments(arguments, new object[] { 3, "Foo" });
         }
 
+        [Test]
+        public void DeepPropertyCall()
+        {
+            var arguments = GetArguments(x => x.Foo.Baz(), new ClassUnderTest());
+            arguments.ShouldBeEmpty();
+        }
+
         private string GetFooString()
         {
             return "Foo";

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

@@ -12,12 +12,32 @@ public class StepTitleTests
         [Test]
         public void MethodCallInStepTitle()
         {
+            FooClass something = new FooClass();
             var story = this
                 .Given(_ => GivenWeMutateSomeState())
+                .When(_ => something.Sub.SomethingHappens())
                 .Then(_ => ThenTitleHas(AMethodCall()))
                 .BDDfy();
 
-            story.Scenarios.Single().Steps.ElementAt(1).Title.ShouldBe("Then title has Mutated state");
+            story.Scenarios.Single().Steps.ElementAt(2).Title.ShouldBe("Then title has Mutated state");
+        }
+
+        public class FooClass
+        {
+            public FooClass()
+            {
+                Sub = new BarClass();
+            }
+
+            public BarClass Sub { get; set; }
+        }
+
+        public class BarClass
+        {
+            public void SomethingHappens()
+            {
+                
+            }
         }
 
         private string AMethodCall()

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

@@ -20,7 +20,7 @@ public static IEnumerable<StepArgument> ExtractArguments<T>(this Expression<Acti
             if (methodCallExpression == null)
                 throw new InvalidOperationException("Please provide a *method call* lambda expression.");
 
-            return ExtractArguments(methodCallExpression, value);
+            return ExtractArguments(methodCallExpression, value, false);
         }
 
         public static IEnumerable<StepArgument> ExtractArguments<T>(this Expression<Func<T, Task>> expression, T value)
@@ -33,7 +33,7 @@ public static IEnumerable<StepArgument> ExtractArguments<T>(this Expression<Func
             if (methodCallExpression == null)
                 throw new InvalidOperationException("Please provide a *method call* lambda expression.");
 
-            return ExtractArguments(methodCallExpression, value);
+            return ExtractArguments(methodCallExpression, value, false);
         }
 
         private static IEnumerable<StepArgument> ExtractArguments<T>(Expression expression, T value)
@@ -71,21 +71,30 @@ private static IEnumerable<StepArgument> ExtractArguments<T>(Expression expressi
         private static IEnumerable<StepArgument> Invoke(MethodCallExpression methodCallExpression, IEnumerable<StepArgument> args)
         {
             var constantExpression = methodCallExpression.Object as ConstantExpression;
+            var stepArguments = args.ToArray();
             if (constantExpression != null)
-                return new[] { new StepArgument(() => methodCallExpression.Method.Invoke(constantExpression.Value, args.Select(s => s.Value).ToArray())) };
+                return new[] { new StepArgument(() => methodCallExpression.Method.Invoke(constantExpression.Value, stepArguments.Select(s => s.Value).ToArray())) };
 
-            return new[] { new StepArgument(() => methodCallExpression.Method.Invoke(args.First().Value, args.Skip(1).Select(s => s.Value).ToArray())) };
+            return new[] { new StepArgument(() =>
+            {
+                var value = stepArguments.First().Value;
+                var parameters = stepArguments.Skip(1).Select(s => s.Value).ToArray();
+                return methodCallExpression.Method.Invoke(value, parameters);
+            }) };
         }
 
-        private static IEnumerable<StepArgument> ExtractArguments<T>(MethodCallExpression methodCallExpression, T value)
+        private static IEnumerable<StepArgument> ExtractArguments<T>(MethodCallExpression methodCallExpression, T value, bool extractArgsFromExpression = true)
         {
             var constants = new List<StepArgument>();
             foreach (var arg in methodCallExpression.Arguments)
             {
                 constants.AddRange(ExtractArguments(arg, value));
             }
 
-            constants.AddRange(ExtractArguments(methodCallExpression.Object, value));
+            if (extractArgsFromExpression)
+            {
+                constants.AddRange(ExtractArguments(methodCallExpression.Object, value));
+            }
 
             return constants;
         }