fix: update invocation logic for dynamic test expressions

Author: thomhurst

TUnit.Engine/Building/Collectors/AotTestDataCollector.cs

@@ -205,21 +205,32 @@ private Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(DynamicDisco
                     throw new InvalidOperationException("Dynamic test method expression is null");
                 }
 
-                // Since we're in AOT mode, we need to handle this differently
-                // The expression should already be compiled in source generation
+                // Extract method info from the expression
                 var lambdaExpression = result.TestMethod as LambdaExpression;
                 if (lambdaExpression == null)
                 {
                     throw new InvalidOperationException("Dynamic test method must be a lambda expression");
                 }
 
-                var compiledExpression = lambdaExpression.Compile();
+                MethodInfo? methodInfo = null;
+                if (lambdaExpression.Body is MethodCallExpression methodCall)
+                {
+                    methodInfo = methodCall.Method;
+                }
+                else if (lambdaExpression.Body is UnaryExpression { Operand: MethodCallExpression unaryMethodCall })
+                {
+                    methodInfo = unaryMethodCall.Method;
+                }
+
+                if (methodInfo == null)
+                {
+                    throw new InvalidOperationException("Could not extract method info from dynamic test expression");
+                }
+
                 var testInstance = instance ?? throw new InvalidOperationException("Test instance is null");
 
-                // The expression is already bound to the correct method with arguments
-                // so we just need to invoke it with the instance
-                var invokeMethod = compiledExpression.GetType().GetMethod("Invoke")!;
-                var invokeResult = invokeMethod.Invoke(compiledExpression, [testInstance]);
+                // Use the provided args from TestMethodArguments instead of the expression's placeholder values
+                var invokeResult = methodInfo.Invoke(testInstance, args);
 
                 if (invokeResult is Task task)
                 {

TUnit.Engine/Discovery/ReflectionTestDataCollector.cs

@@ -2049,20 +2049,32 @@ private Task<TestMetadata> CreateMetadataFromDynamicDiscoveryResult(DynamicDisco
                     throw new InvalidOperationException("Dynamic test method expression is null");
                 }
 
-                // Since we're in reflection mode, we can compile and invoke the expression
+                // Extract method info from the expression
                 var lambdaExpression = result.TestMethod as System.Linq.Expressions.LambdaExpression;
                 if (lambdaExpression == null)
                 {
                     throw new InvalidOperationException("Dynamic test method must be a lambda expression");
                 }
 
-                var compiledExpression = lambdaExpression.Compile();
+                MethodInfo? methodInfo = null;
+                if (lambdaExpression.Body is System.Linq.Expressions.MethodCallExpression methodCall)
+                {
+                    methodInfo = methodCall.Method;
+                }
+                else if (lambdaExpression.Body is System.Linq.Expressions.UnaryExpression { Operand: System.Linq.Expressions.MethodCallExpression unaryMethodCall })
+                {
+                    methodInfo = unaryMethodCall.Method;
+                }
+
+                if (methodInfo == null)
+                {
+                    throw new InvalidOperationException("Could not extract method info from dynamic test expression");
+                }
+
                 var testInstance = instance ?? throw new InvalidOperationException("Test instance is null");
 
-                // The expression is already bound to the correct method with arguments
-                // so we just need to invoke it with the instance
-                var invokeMethod = compiledExpression.GetType().GetMethod("Invoke")!;
-                var invokeResult = invokeMethod.Invoke(compiledExpression, [testInstance]);
+                // Use the provided args from TestMethodArguments instead of the expression's placeholder values
+                var invokeResult = methodInfo.Invoke(testInstance, args);
 
                 if (invokeResult is Task task)
                 {

TUnit.TestProject/Bugs/3173/DynamicTestArgumentsTests.cs

@@ -0,0 +1,56 @@
+using TUnit.TestProject.Attributes;
+
+#pragma warning disable TUnitWIP0001
+
+namespace TUnit.TestProject.Bugs._3173;
+
+[EngineTest(ExpectedResult.Pass)]
+public class DynamicTestArgumentsTests
+{
+    [DynamicTestBuilder]
+    public void BuildDynamicTests(DynamicTestBuilderContext context)
+    {
+        string testValue = "abc";
+
+        context.AddTest(new DynamicTest<DynamicTestArgumentsTests>
+        {
+            TestMethod = (@class) => @class.TestStringArgument(DynamicTestHelper.Argument<string>()),
+            TestMethodArguments = [testValue],
+        });
+
+        int testInt = 42;
+        context.AddTest(new DynamicTest<DynamicTestArgumentsTests>
+        {
+            TestMethod = (@class) => @class.TestIntArgument(DynamicTestHelper.Argument<int>()),
+            TestMethodArguments = [testInt],
+        });
+
+        context.AddTest(new DynamicTest<DynamicTestArgumentsTests>
+        {
+            TestMethod = (@class) => @class.TestMultipleArguments(
+                DynamicTestHelper.Argument<string>(),
+                DynamicTestHelper.Argument<int>(),
+                DynamicTestHelper.Argument<bool>()),
+            TestMethodArguments = ["test", 123, true],
+        });
+    }
+
+    public async Task TestStringArgument(string value)
+    {
+        await Assert.That(value).IsNotNull();
+        await Assert.That(value).IsEqualTo("abc");
+    }
+
+    public async Task TestIntArgument(int value)
+    {
+        await Assert.That(value).IsNotEqualTo(0);
+        await Assert.That(value).IsEqualTo(42);
+    }
+
+    public async Task TestMultipleArguments(string str, int num, bool flag)
+    {
+        await Assert.That(str).IsEqualTo("test");
+        await Assert.That(num).IsEqualTo(123);
+        await Assert.That(flag).IsTrue();
+    }
+}