Fix issue with tests failing with [TestCase] or [InlineData]

Author: asos-gurpreetsingh

src/TestStack.BDDfy.Tests/Scanner/Examples/FluentClosureParameterTests.cs

@@ -0,0 +1,49 @@
+using Shouldly;
+using Xunit;
+
+namespace TestStack.BDDfy.Tests.Scanner.Examples
+{
+    /// <summary>
+    /// Verifies that fluent steps using closure-captured method parameters
+    /// from [InlineData] / [TestCase] retain correct values at execution time.
+    /// Regression test: ParameterizedTestDetector must not overwrite closure values
+    /// when the parameter is not stored as a field on the test object.
+    /// </summary>
+    public class FluentClosureParameterTests
+    {
+        private string? _capturedRoute;
+        private int _capturedStatus;
+
+        [Theory]
+        [InlineData("/api/orders", 200)]
+        [InlineData("/api/missing", 404)]
+        public void Multi_parameter_values_should_not_be_corrupted(string endpoint, int statusCode)
+        {
+            this.Given(_ => A_request_is_made_to(endpoint))
+                .When(_ => The_response_status_is(statusCode))
+                .Then(_ => The_resolved_route_should_be(endpoint))
+                .And(_ => The_status_should_be(statusCode))
+                .BDDfy();
+        }
+
+        private void A_request_is_made_to(string route)
+        {
+            _capturedRoute = route;
+        }
+
+        private void The_response_status_is(int statusCode)
+        {
+            _capturedStatus = statusCode;
+        }
+
+        private void The_resolved_route_should_be(params string[] expected)
+        {
+            new[] { _capturedRoute }.ShouldBe(expected);
+        }
+
+        private void The_status_should_be(int expected)
+        {
+            _capturedStatus.ShouldBe(expected);
+        }
+    }
+}

src/TestStack.BDDfy/Scanners/ScenarioScanners/ParameterizedTestDetector.cs

@@ -45,7 +45,6 @@ internal static class ParameterizedTestDetector
 
             // Build example from current parameter values (resolved from the appropriate object)
             var example = BuildExampleFromParameters(declaringObject!, parameters);
-            if (example is null) return null;
 
             // Stable ID based on declaring type + method name (shared across invocations)
             var declaringType = method.DeclaringType ?? testType;
@@ -123,26 +122,35 @@ private static bool IsParameterizedTestMethod(MethodInfo method)
             foreach (var param in parameters)
             {
                 var paramName = param.Name!;
-                object? value = ResolveParameterValue(testObject, type, paramName, bindingFlags);
+                if (!TryResolveParameterValue(testObject, type, paramName, bindingFlags, out var value))
+                    return null; // Can't resolve all parameters — skip Example creation
+
                 values.Add(new ExampleValue(paramName, value, () => rowIndex));
             }
 
             return values.Count > 0 ? new Example([.. values]) : null;
         }
 
-        private static object? ResolveParameterValue(object testObject, Type type, string paramName, BindingFlags flags)
+        private static bool TryResolveParameterValue(object testObject, Type type, string paramName, BindingFlags flags, out object? value)
         {
             // Try field (including backing fields from primary constructors)
             var field = FindField(type, paramName, flags);
             if (field is not null)
-                return field.GetValue(testObject);
+            {
+                value = field.GetValue(testObject);
+                return true;
+            }
 
             // Try property
             var prop = FindProperty(type, paramName, flags);
             if (prop is not null)
-                return prop.GetValue(testObject);
+            {
+                value = prop.GetValue(testObject);
+                return true;
+            }
 
-            return null;
+            value = null;
+            return false;
         }
 
         private static FieldInfo? FindField(Type type, string name, BindingFlags flags)
@@ -159,8 +167,7 @@ private static bool IsParameterizedTestMethod(MethodInfo method)
             var fields = type.GetFields(flags);
             foreach (var f in fields)
             {
-                if (f.Name.Equals($"<{name}>P", StringComparison.Ordinal) ||
-                    f.Name.Contains(name, StringComparison.OrdinalIgnoreCase))
+                if (f.Name.Equals($"<{name}>P", StringComparison.Ordinal))
                     return f;
             }
 
@@ -180,10 +187,10 @@ private static bool IsParameterizedTestMethod(MethodInfo method)
         }
     }
 
-    internal sealed class ParameterizedTestInfo(MethodInfo method, string stableScenarioId, Example example)
+    internal sealed class ParameterizedTestInfo(MethodInfo method, string stableScenarioId, Example? example)
     {
         public MethodInfo Method { get; } = method;
         public string StableScenarioId { get; } = stableScenarioId;
-        public Example Example { get; } = example;
+        public Example? Example { get; } = example;
     }
 }