+semver:minor - fix(assertions): resolve StackOverflowException in chaining with property tests (#3461) (#3468)

Author: thomhurst

TUnit.Assertions.Tests/TypeOfTests.cs

@@ -679,4 +679,31 @@ public async Task IsTypeOf_EmptyArray_Success()
 
         await Assert.That(result.Length).IsEqualTo(0);
     }
+
+    // ============ CHAINING WITH PROPERTY TESTS (Issue #3461) ============
+
+    private record TestRecord(int Id, string Name);
+
+    [Test]
+    public async Task IsTypeOf_WithHasProperty_OnRecord_DoesNotStackOverflow()
+    {
+        // Regression test for issue #3461
+        // This previously caused a StackOverflowException due to duplicate pending link consumption
+        object record = new TestRecord(2, "Test");
+
+        await Assert.That(record)
+            .IsTypeOf<TestRecord>()
+            .And.HasProperty(x => x.Id).IsEqualTo(2);
+    }
+
+    [Test]
+    public async Task IsTypeOf_WithMultipleHasProperty_OnRecord()
+    {
+        object record = new TestRecord(42, "Hello");
+
+        var casted = await Assert.That(record).IsTypeOf<TestRecord>();
+
+        await Assert.That(casted).HasProperty(x => x.Id).IsEqualTo(42);
+        await Assert.That(casted).HasProperty(x => x.Name).IsEqualTo("Hello");
+    }
 }

TUnit.Assertions/Conditions/TypeOfAssertion.cs

@@ -25,16 +25,8 @@ public TypeOfAssertion(
                     $"Value is of type {value?.GetType().Name ?? "null"}, not {typeof(TTo).Name}");
             }))
     {
-        // Transfer pending links from parent context to handle cross-type chaining
-        // e.g., Assert.That(obj).IsNotNull().And.IsTypeOf<string>()
-        var (pendingAssertion, combinerType) = parentContext.ConsumePendingLink();
-        if (pendingAssertion != null)
-        {
-            // Store the pending assertion execution as pre-work
-            // It will be executed before any assertions on the casted value
-            Context.PendingPreWork = async () => await pendingAssertion.ExecuteCoreAsync();
-        }
-
+        // Note: Pending link transfer is handled by AssertionContext<T>.Map()
+        // No need to duplicate that logic here
         _expectedType = typeof(TTo);
     }
 

TUnit.Assertions/Core/Assertion.cs

@@ -126,8 +126,9 @@ public Assertion<TValue> Because(string message)
         // Execute any pending cross-type assertions first (e.g., string assertions before WhenParsedInto<int>)
         if (Context.PendingPreWork != null)
         {
-            await Context.PendingPreWork();
-            Context.PendingPreWork = null; // Execute only once
+            var preWork = Context.PendingPreWork;
+            Context.PendingPreWork = null; // Clear BEFORE execution to prevent re-entry
+            await preWork();
         }
 
         // If this is an And/OrAssertion (composite), delegate to AssertAsync which has custom logic

TUnit.Assertions/Core/AssertionContext.cs

@@ -46,6 +46,8 @@ public AssertionContext(TValue? value, StringBuilder expressionBuilder)
     /// - Transferring the expression builder
     /// - Consuming pending links from the source context
     /// - Setting up pre-work to execute previous assertions before the transformation
+    ///
+    /// Uses lazy evaluation to prevent stack overflow in circular reference scenarios.
     /// </summary>
     /// <typeparam name="TNew">The target type after transformation</typeparam>
     /// <param name="evaluationFactory">Factory to create the new evaluation context from the current one</param>