fix IAsyncInitializer order when using nested property injection (#4036)

* fix IAsyncInitializer order when using nested property injection

* fix: enhance direct property detection for injected properties in object graph discovery

Author: thomhurst

CLAUDE.md

@@ -147,6 +147,17 @@ dotnet test TUnit.Core.SourceGenerator.Tests
 
 **Rule**: Only run TUnit.TestProject with explicit `--treenode-filter` to target specific tests or classes.
 
+**IMPORTANT: Run filters ONE AT A TIME!** Using OR patterns (`Pattern1|Pattern2`) can match thousands of unintended tests. Always run one specific filter per command:
+
+```bash
+# ❌ WRONG - OR patterns can match too broadly
+--treenode-filter "/*/*/ClassA/*|/*/*/ClassB/*"
+
+# ✅ CORRECT - Run separate commands for each class
+dotnet run -- --treenode-filter "/*/*/ClassA/*"
+dotnet run -- --treenode-filter "/*/*/ClassB/*"
+```
+
 ---
 
 ### Most Common Commands

TUnit.Core/Discovery/ObjectGraphDiscoverer.cs

@@ -476,6 +476,12 @@ private static void TraverseInitializerProperties(
     /// Collects root-level objects (class args, method args, properties) from test details.
     /// Eliminates duplicate loops in DiscoverObjectGraph and DiscoverAndTrackObjects.
     /// </summary>
+    /// <remarks>
+    /// For injected properties, only DIRECT test class properties (including inherited) are added at depth 0.
+    /// Nested properties (properties of injected objects) are discovered through normal
+    /// graph traversal at appropriate depths (1+), ensuring correct initialization order
+    /// for nested IAsyncInitializer dependencies. See GitHub issue #4032.
+    /// </remarks>
     private static void CollectRootObjects(
         TestDetails testDetails,
         TryAddObjectFunc tryAdd,
@@ -488,8 +494,70 @@ private static void CollectRootObjects(
         // Process method arguments
         ProcessRootCollection(testDetails.TestMethodArguments, tryAdd, onRootObjectAdded, cancellationToken);
 
-        // Process injected property values
-        ProcessRootCollection(testDetails.TestClassInjectedPropertyArguments.Values, tryAdd, onRootObjectAdded, cancellationToken);
+        // Build set of types in the test class hierarchy (for identifying direct properties)
+        var hierarchyTypes = GetTypeHierarchy(testDetails.ClassType);
+
+        // Process ONLY direct test class injected properties at depth 0.
+        // Nested properties will be discovered through normal graph traversal at depth 1+.
+        // This ensures proper initialization order for nested IAsyncInitializer dependencies.
+        foreach (var kvp in testDetails.TestClassInjectedPropertyArguments)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (kvp.Value == null)
+            {
+                continue;
+            }
+
+            // Check if this property belongs to the test class hierarchy (not nested object properties)
+            // Cache key format: "{DeclaringType.FullName}.{PropertyName}"
+            if (IsDirectProperty(kvp.Key, hierarchyTypes))
+            {
+                if (tryAdd(kvp.Value, 0))
+                {
+                    onRootObjectAdded(kvp.Value);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets all types in the inheritance hierarchy from the given type up to (but not including) object.
+    /// </summary>
+    private static HashSet<string> GetTypeHierarchy(Type type)
+    {
+        var result = new HashSet<string>();
+        var currentType = type;
+
+        while (currentType != null && currentType != typeof(object))
+        {
+            if (currentType.FullName != null)
+            {
+                result.Add(currentType.FullName);
+            }
+
+            currentType = currentType.BaseType;
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Determines if a cache key represents a direct property (belonging to test class hierarchy)
+    /// vs a nested property (belonging to an injected object).
+    /// Cache key format: "{DeclaringType.FullName}.{PropertyName}"
+    /// </summary>
+    private static bool IsDirectProperty(string cacheKey, HashSet<string> hierarchyTypes)
+    {
+        // Find the last dot to separate type from property name
+        var lastDotIndex = cacheKey.LastIndexOf('.');
+        if (lastDotIndex <= 0)
+        {
+            return true; // Malformed key, treat as direct
+        }
+
+        var declaringTypeName = cacheKey.Substring(0, lastDotIndex);
+        return hierarchyTypes.Contains(declaringTypeName);
     }
 
     /// <summary>