feat: add support for reusing discovery instances in test building and property resolution

TUnit.Core/TestContext.cs

@@ -138,6 +138,12 @@ internal override void SetAsyncLocalContext()
 
     internal bool RunOnTestDiscovery { get; set; }
 
+    /// <summary>
+    /// Indicates whether this test is reusing the discovery-time instance instead of creating a new instance.
+    /// When true, property resolution and initialization should be skipped since the instance is already prepared.
+    /// </summary>
+    internal bool IsDiscoveryInstanceReused { get; set; }
+
     public object Lock { get; } = new();
 
 

TUnit.Engine/Building/Interfaces/ITestBuilder.cs

@@ -14,8 +14,9 @@ internal interface ITestBuilder
     /// <param name="metadata">The test metadata</param>
     /// <param name="testData">The test data</param>
     /// <param name="testBuilderContext"></param>
+    /// <param name="isReusingDiscoveryInstance">Whether this test is reusing the discovery instance</param>
     /// <returns>An executable test ready for execution</returns>
-    Task<AbstractExecutableTest> BuildTestAsync(TestMetadata metadata, TestBuilder.TestData testData, TestBuilderContext testBuilderContext);
+    Task<AbstractExecutableTest> BuildTestAsync(TestMetadata metadata, TestBuilder.TestData testData, TestBuilderContext testBuilderContext, bool isReusingDiscoveryInstance = false);
 
     /// <summary>
     /// Builds all executable tests from a single TestMetadata using its DataCombinationGenerator delegate.

TUnit.Engine/Building/TestBuilder.cs

@@ -209,6 +209,7 @@ public async Task<IEnumerable<AbstractExecutableTest>> BuildTestsFromMetadataAsy
                     var needsInstanceForMethodDataSources = metadata.DataSources.Any(ds => ds is IAccessesInstanceData);
 
                     object? instanceForMethodDataSources = null;
+                    var discoveryInstanceUsed = false;
 
                     if (needsInstanceForMethodDataSources)
                     {
@@ -382,10 +383,21 @@ await _objectLifecycleService.RegisterObjectAsync(
                                 var basicSkipReason = GetBasicSkipReason(metadata, attributes);
 
                                 Func<Task<object>> instanceFactory;
+                                bool isReusingDiscoveryInstance = false;
+
                                 if (basicSkipReason is { Length: > 0 })
                                 {
                                     instanceFactory = () => Task.FromResult<object>(SkippedTestInstance.Instance);
                                 }
+                                else if (methodDataLoopIndex == 1 && i == 0 && instanceForMethodDataSources != null && !discoveryInstanceUsed)
+                                {
+                                    // Reuse the discovery instance for the first test to avoid duplicate initialization
+                                    var capturedInstance = instanceForMethodDataSources;
+                                    discoveryInstanceUsed = true;
+                                    isReusingDiscoveryInstance = true;
+
+                                    instanceFactory = () => Task.FromResult(capturedInstance);
+                                }
                                 else
                                 {
                                     var capturedMetadata = metadata;
@@ -420,7 +432,7 @@ await _objectLifecycleService.RegisterObjectAsync(
                                     InitializedAttributes = attributes
                                 };
 
-                                var test = await BuildTestAsync(metadata, testData, testSpecificContext);
+                                var test = await BuildTestAsync(metadata, testData, testSpecificContext, isReusingDiscoveryInstance);
 
                                 // If we have a basic skip reason, set it immediately
                                 if (!string.IsNullOrEmpty(basicSkipReason))
@@ -799,7 +811,7 @@ private async Task<IDataSourceAttribute[]> GetDataSourcesAsync(IDataSourceAttrib
 
     [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Hook discovery service handles mode-specific logic; reflection calls suppressed in AOT mode")]
     [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "Hook discovery service handles mode-specific logic; dynamic code suppressed in AOT mode")]
-    public async Task<AbstractExecutableTest> BuildTestAsync(TestMetadata metadata, TestData testData, TestBuilderContext testBuilderContext)
+    public async Task<AbstractExecutableTest> BuildTestAsync(TestMetadata metadata, TestData testData, TestBuilderContext testBuilderContext, bool isReusingDiscoveryInstance = false)
     {
         // Discover instance hooks for closed generic types (no-op in source gen mode)
         if (metadata.TestClassType is { IsGenericType: true, IsGenericTypeDefinition: false })
@@ -811,6 +823,9 @@ public async Task<AbstractExecutableTest> BuildTestAsync(TestMetadata metadata,
 
         var context = await CreateTestContextAsync(testId, metadata, testData, testBuilderContext);
 
+        // Mark if this test is reusing the discovery instance (already initialized)
+        context.IsDiscoveryInstanceReused = isReusingDiscoveryInstance;
+
         context.Metadata.TestDetails.ClassInstance = PlaceholderInstance.Instance;
 
         // Arguments will be tracked by TestArgumentTrackingService during TestRegistered event

TUnit.Engine/Services/PropertyInjector.cs

@@ -39,6 +39,12 @@ public async Task ResolveAndCachePropertiesAsync(
         TestContextEvents events,
         TestContext testContext)
     {
+        // Skip property resolution if this test is reusing the discovery instance (already initialized)
+        if (testContext.IsDiscoveryInstanceReused)
+        {
+            return;
+        }
+
         var plan = PropertyInjectionCache.GetOrCreatePlan(testClassType);
 
         if (!plan.HasProperties)

TUnit.TestProject/Bugs/3993/IAsyncInitializerTests.cs

@@ -0,0 +1,62 @@
+using System.Collections.Concurrent;
+using TUnit.Core.Interfaces;
+using TUnit.TestProject.Attributes;
+
+namespace TUnit.TestProject.Bugs._3993;
+
+/// <summary>
+/// Regression test for issue #3993: IAsyncInitializer called 4 times instead of 3
+/// when using ClassDataSource with MethodDataSource that accesses instance properties.
+/// </summary>
+[EngineTest(ExpectedResult.Pass)]
+public class IAsyncInitializerTests
+{
+    [ClassDataSource<PerTestCaseSource>(Shared = SharedType.None)]
+    public required PerTestCaseSource PerTestCaseSource { get; init; }
+
+    public IEnumerable<string> PerTestCaseStrings() => PerTestCaseSource.MyString;
+
+    [Test]
+    [MethodDataSource(nameof(PerTestCaseStrings))]
+    public async Task ForNTestCases_ShouldInitNTimes(string s)
+    {
+        await Assert.That(s).IsNotNull();
+
+        // Each of the 3 test cases should have its own isolated PerTestCaseSource instance
+        // Since Shared = SharedType.None, each test gets a new instance
+        // Therefore, InitializeAsync should be called exactly 3 times (once per test)
+        // NOT 4 times (which would include the discovery instance)
+        await Assert
+            .That(PerTestCaseSource.SetUps)
+            .IsEqualTo(3)
+            .Because("each of the 3 test cases should be wrapped in its own isolated test class, " +
+                     "causing a call to async init, but no more than those three calls should be needed. " +
+                     "The discovery-time instance should NOT be initialized.");
+    }
+
+    [After(Class)]
+    public static void ResetCounter()
+    {
+        // Reset for next run
+        PerTestCaseSource.Reset();
+    }
+}
+
+public class PerTestCaseSource : IAsyncInitializer
+{
+    public string[] MyString = [];
+    private static int _setUps = 0;
+    public static int SetUps => _setUps;
+
+    public Task InitializeAsync()
+    {
+        Interlocked.Increment(ref _setUps);
+        MyString = ["123", "321", "9210"];
+        return Task.CompletedTask;
+    }
+
+    public static void Reset()
+    {
+        _setUps = 0;
+    }
+}