From 1b6c09fc2817f2952c8ebc14d67de76a9a929c24 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Mon, 2 Nov 2026 23:14:01 +0000 Subject: [PATCH 01/27] fix: dispatch test context lifecycle delegates (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 8 ++ .../Services/EventReceiverOrchestrator.cs | 45 ++++++++-- .../Services/TestExecution/RetryHelper.cs | 8 ++ .../Services/TestFilterService.cs | 8 ++ .../DelegateLifecycleEventTests.cs | 86 +++++++++++++++++++ 5 files changed, 146 insertions(+), 9 deletions(-) create mode 100644 tests/TUnit.TestProject/DelegateLifecycleEventTests.cs diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index c6a287e7ac0..ea33834a813 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -481,6 +481,10 @@ public async ValueTask> BuildTestsFromMetada // Shares the per-iteration bag lazily; it is only allocated if something reads it. testSpecificContext.ShareStateBagWith(contextAccessor.Current); + if (contextAccessor.Current.EventsIfCreated is { } events) + { + testSpecificContext.Events = events; + } } var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken); @@ -2495,6 +2499,10 @@ private async Task CreateInstanceForMethodDataSources( // Shares the per-iteration bag lazily; it is only allocated if something reads it. testSpecificContext.ShareStateBagWith(contextAccessor.Current); + if (contextAccessor.Current.EventsIfCreated is { } events) + { + testSpecificContext.Events = events; + } var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); diff --git a/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs b/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs index 8bf554dd6e1..b64b4979c9d 100644 --- a/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs +++ b/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs @@ -154,7 +154,7 @@ public ValueTask InvokeTestStartEventReceiversAsync(TestContext context, Cancell } #endif // Fast path - no allocation if no receivers - if (!_registry.HasTestStartReceivers()) + if (!_registry.HasTestStartReceivers() && (stage == EventReceiverStage.Early || context.InternalEventsIfCreated?.OnTestStart is null)) { return ValueTask.CompletedTask; } @@ -196,6 +196,14 @@ private async ValueTask InvokeTestStartEventReceiversCore(TestContext context, C await receiver.OnTestStart(context); } #endif + // Delegate events have no stage; dispatch once, with the default (late) receivers. + if (stage != EventReceiverStage.Early && context.InternalEventsIfCreated?.OnTestStart is { } onStart) + { + foreach (var handler in onStart.InvocationList) + { + await handler.InvokeAsync(context, context); + } + } } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -207,7 +215,7 @@ public ValueTask> InvokeTestEndEventReceiversAsync(Test return new ValueTask>([]); } #endif - if (!_registry.HasTestEndReceivers()) + if (!_registry.HasTestEndReceivers() && (stage == EventReceiverStage.Early || context.InternalEventsIfCreated?.OnTestEnd is null)) { return new ValueTask>([]); } @@ -215,7 +223,7 @@ public ValueTask> InvokeTestEndEventReceiversAsync(Test if (stage.HasValue) { var receivers = context.GetTestEndReceivers(stage.Value); - if (receivers.Length == 0) + if (receivers.Length == 0 && (stage == EventReceiverStage.Early || context.InternalEventsIfCreated?.OnTestEnd is null)) { return new ValueTask>([]); } @@ -225,7 +233,7 @@ public ValueTask> InvokeTestEndEventReceiversAsync(Test var earlyReceivers = context.GetTestEndReceivers(EventReceiverStage.Early); var lateReceivers = context.GetTestEndReceivers(EventReceiverStage.Late); - if (earlyReceivers.Length == 0 && lateReceivers.Length == 0) + if (earlyReceivers.Length == 0 && lateReceivers.Length == 0 && context.InternalEventsIfCreated?.OnTestEnd is null) { return new ValueTask>([]); } @@ -309,13 +317,29 @@ private async ValueTask> InvokeTestEndEventReceiversCor } #endif + if (stage != EventReceiverStage.Early && context.InternalEventsIfCreated?.OnTestEnd is { } onEnd) + { + foreach (var handler in onEnd.InvocationList) + { + try + { + await handler.InvokeAsync(context, context); + } + catch (Exception ex) + { + await _logger.LogErrorAsync($"Error in test end event handler: {ex.Message}"); + (exceptions ??= []).Add(ex); + } + } + } + return exceptions == null ? Array.Empty() : exceptions; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public ValueTask InvokeTestSkippedEventReceiversAsync(TestContext context, CancellationToken cancellationToken) { - if (!_registry.HasTestSkippedReceivers()) + if (!_registry.HasTestSkippedReceivers() && context.InternalEventsIfCreated?.OnTestSkipped is null) { return ValueTask.CompletedTask; } @@ -328,14 +352,17 @@ private async ValueTask InvokeTestSkippedEventReceiversCore(TestContext context, // Use pre-computed receivers (already filtered, sorted, and scoped-attribute filtered) var receivers = context.GetTestSkippedReceivers(); - if (receivers.Length == 0) + foreach (var receiver in receivers) { - return; + await receiver.OnTestSkipped(context); } - foreach (var receiver in receivers) + if (context.InternalEventsIfCreated?.OnTestSkipped is { } onSkipped) { - await receiver.OnTestSkipped(context); + foreach (var handler in onSkipped.InvocationList) + { + await handler.InvokeAsync(context, context); + } } } diff --git a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs index 09af835a7ba..7e5861dad87 100644 --- a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs +++ b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs @@ -109,6 +109,14 @@ public static async Task ExecuteWithRetry(TestContext testContext, Func + { + protected override IEnumerable> GenerateDataSources(DataGeneratorMetadata metadata) + { + yield return () => + { + var events = metadata.TestBuilderContext.Current.Events; + events.OnTestRegistered += Record("registered"); + events.OnTestStart += Record("start"); + events.OnTestEnd += Record("end"); + events.OnTestSkipped += Record("skipped"); + events.OnTestRetry += (_, args) => + { + args.TestContext.StateBag.Items["retry"] = args.RetryAttempt; + return default; + }; + return 1; + }; + } + + private static Func Record(string name) => (_, context) => + { + context.StateBag.Items.TryGetValue(name, out var count); + context.StateBag.Items[name] = (count as int? ?? 0) + 1; + return default; + }; + } + + [Test, Subscribe, EngineTest(ExpectedResult.Pass)] + public async Task Passing(int value) + { + await Assert.That(TestContext.Current!.StateBag.Items["registered"]).IsEqualTo(1); + await Assert.That(TestContext.Current.StateBag.Items["start"]).IsEqualTo(1); + } + + [Test, Subscribe, EngineTest(ExpectedResult.Pass)] + public async Task Generic(T value) + { + await Assert.That(TestContext.Current!.StateBag.Items["registered"]).IsEqualTo(1); + await Assert.That(TestContext.Current.StateBag.Items["start"]).IsEqualTo(1); + } + + [Test, Subscribe, Retry(1), EngineTest(ExpectedResult.Pass)] + public async Task Retried(int value) + { + var context = TestContext.Current!; + if (!context.StateBag.Items.ContainsKey("retry")) + { + throw new InvalidOperationException("Exercise retry notification"); + } + + await Assert.That(context.StateBag.Items["retry"]).IsEqualTo(1); + await Assert.That(context.StateBag.Items["start"]).IsEqualTo(2); + await Assert.That(context.StateBag.Items["end"]).IsEqualTo(1); + } + + [Test, Subscribe, Skip("Exercise skipped notification")] + public void Skipped(int value) => throw new InvalidOperationException("Must not execute"); + + [After(Class)] + public static async Task Verify(ClassHookContext context) + { + foreach (var test in context.Tests) + { + await Assert.That(test.StateBag.Items["registered"]).IsEqualTo(1); + if (test.Metadata.TestDetails.MethodName == nameof(Skipped)) + { + await Assert.That(test.StateBag.Items["skipped"]).IsEqualTo(1); + await Assert.That(test.StateBag.Items["end"]).IsEqualTo(1); + await Assert.That(test.StateBag.Items.ContainsKey("start")).IsFalse(); + } + else + { + var expected = test.Metadata.TestDetails.MethodName == nameof(Retried) ? 2 : 1; + await Assert.That(test.StateBag.Items["end"]).IsEqualTo(expected); + } + } + } +} From 2ba3c665241d1345c70e40db4c1bbdf397605465 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Mon, 2 Nov 2026 23:45:14 +0000 Subject: [PATCH 02/27] fix: preserve class row callbacks and retry scope lifetime (#7308) --- ...dencyInjectionDataSourceSourceAttribute.cs | 4 +- src/TUnit.Core/TestContextEvents.cs | 2 + src/TUnit.Engine/Building/TestBuilder.cs | 56 ++++++++++-- .../Services/TestExecution/TestCoordinator.cs | 15 ++++ .../DelegateLifecycleEventTests.cs | 88 ++++++++++++++++--- 5 files changed, 142 insertions(+), 23 deletions(-) diff --git a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs index 3d7ea2468b7..b798ff9f62f 100644 --- a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs +++ b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs @@ -11,8 +11,8 @@ public abstract class DependencyInjectionDataSourceAttribute : UntypedDa // Create a new scope for each test execution var scope = CreateScope(dataGeneratorMetadata); - // Set up disposal for this specific scope in the current test context - dataGeneratorMetadata.TestBuilderContext.Current.Events.OnDispose += async (_, _) => + // Method and class arguments are reused by retries; dispose their scope after the final attempt. + dataGeneratorMetadata.TestBuilderContext.Current.Events.OnDataRowDispose += async (_, _) => { if (scope is IAsyncDisposable asyncDisposable) { diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 9ba1587ab67..26fe3074399 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -7,6 +7,8 @@ namespace TUnit.Core; /// public class TestContextEvents : ITestEvents { + internal AsyncEvent? OnDataRowDispose { get; set; } + public AsyncEvent? OnDispose { get; set; } public AsyncEvent? OnTestRegistered { get; set; } public AsyncEvent? OnInitialize { get; set; } diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index ea33834a813..bfbba65d90f 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -225,12 +225,23 @@ public async ValueTask> BuildTestsFromMetada hasAnyClassData = true; classDataLoopIndex++; + // Keep the first factory's subscriptions with its saved row, rather than + // leaving them on the previous test's per-row context. + contextAccessor.Current = new TestBuilderContext + { + TestMetadata = metadata.MethodMetadata, + InitializedAttributes = attributes, + ClassConstructor = testBuilderContext.ClassConstructor, + ClassDataSourceAttribute = classDataSource + }; + testBuilderContext.CopyStateBagTo(contextAccessor.Current); + var (classData, firstClassRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); // No test holds this first fetch yet. The first test built from this class row takes it // instead of calling the factory again, so a non-shared source does not create an extra // instance that nothing tracks or disposes (#7157). - var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata); + var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current.EventsIfCreated); #if NET // Register scope for class data objects from the simple path. @@ -306,7 +317,7 @@ public async ValueTask> BuildTestsFromMetada testBuilderContext.CopyStateBagTo(contextAccessor.Current); - var (classDataUnwrapped, classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory); + var (classDataUnwrapped, classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory, contextAccessor.Current); classData = classDataUnwrapped; object?[] methodRow; @@ -352,7 +363,7 @@ public async ValueTask> BuildTestsFromMetada { // Skip this data source as it's not compatible with the expected types. // No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata); + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); continue; } } @@ -1044,18 +1055,25 @@ public ValueTask MoveNextAsync() /// are lent to the instance instead, and the next test built from the row tracks them without /// receiving them, so they are still disposed. /// - private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata) + private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestContextEvents? events) { private object?[]? _data = data; private TestDataRowMetadata? _metadata = metadata; private object?[]? _lent; + private TestContextEvents? _events = events; /// /// Takes the unclaimed objects, or fetches a new row from when a /// test already holds them. /// - public ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> TakeOrFetchAsync(Func> classDataFactory) + public ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> TakeOrFetchAsync(Func> classDataFactory, TestBuilderContext context) { + if (_events is { } savedEvents) + { + context.Events = savedEvents; + _events = null; + } + if (_data is { } data) { var row = (data, _metadata); @@ -1072,10 +1090,11 @@ private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? meta /// /// Hands back objects that were taken but that no test ended up holding, so the next test takes them. /// - public void Return(object?[] data, TestDataRowMetadata? metadata) + public void Return(object?[] data, TestDataRowMetadata? metadata, TestContextEvents? events) { _data = data; _metadata = metadata; + _events = events; } /// @@ -2159,11 +2178,20 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( cancellationToken.ThrowIfCancellationRequested(); classDataLoopIndex++; + contextAccessor.Current = new TestBuilderContext + { + TestMetadata = metadata.MethodMetadata, + InitializedAttributes = attributes, + ClassConstructor = baseContext.ClassConstructor, + ClassDataSourceAttribute = classDataSource + }; + baseContext.CopyStateBagTo(contextAccessor.Current); + var (classData, firstClassRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); // The first test built from this class row takes this fetch instead of calling the factory // again, so a non-shared source does not create an extra, untracked instance (#7157). - var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata); + var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current.EventsIfCreated); // Initialize objects before method data sources are evaluated (ObjectInitializer is phase-aware) await InitializeClassDataAsync(classData); @@ -2223,6 +2251,16 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( { cancellationToken.ThrowIfCancellationRequested(); + contextAccessor.Current = new TestBuilderContext + { + TestMetadata = metadata.MethodMetadata, + InitializedAttributes = attributes, + ClassConstructor = baseContext.ClassConstructor, + ClassDataSourceAttribute = classDataSource, + DataSourceAttribute = methodDataSource + }; + baseContext.CopyStateBagTo(contextAccessor.Current); + // Build and yield single test var test = await BuildSingleTestAsync( metadata, classDataFactory, unclaimedClassRow, methodDataFactory, @@ -2379,7 +2417,7 @@ private async Task CreateInstanceForMethodDataSources( try { - (classData, var classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory); + (classData, var classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory, contextAccessor.Current); (methodData, var methodRowMetadata) = DataUnwrapper.UnwrapWithTypesAndMetadata(await methodDataFactory() ?? [], metadata.MethodMetadata.Parameters); // Extract and merge metadata from data source attributes and TestDataRow wrappers @@ -2398,7 +2436,7 @@ private async Task CreateInstanceForMethodDataSources( if (!IsDataCompatibleWithExpectedTypes(metadata, methodData)) { // Skip incompatible data. No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata); + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); return null; } } diff --git a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs index a22e78b1e34..4262b886025 100644 --- a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs +++ b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs @@ -227,6 +227,21 @@ await RetryHelper.ExecuteWithRetry(test.Context, test.Context.StopHoldingSharedReferences(); var cleanupExceptions = await _objectTracker.UntrackObjects(test.Context).ConfigureAwait(false); + if (test.Context.InternalEventsIfCreated?.OnDataRowDispose is { } onDataRowDispose) + { + foreach (var handler in onDataRowDispose.InvocationList) + { + try + { + await handler.InvokeAsync(this, test.Context).ConfigureAwait(false); + } + catch (Exception ex) + { + (cleanupExceptions ??= []).Add(ex); + } + } + } + #if NET // Per-test cleanup has completed. Keep the test activity open for final status // and export, but detach it from the ambient async-local context so shared diff --git a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs index be66770e25a..630c66c1d83 100644 --- a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs +++ b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs @@ -4,25 +4,30 @@ namespace TUnit.TestProject; public class DelegateLifecycleEventTests { - [AttributeUsage(AttributeTargets.Method)] + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)] public sealed class SubscribeAttribute : DataSourceGeneratorAttribute { + public int Rows { get; set; } = 1; + protected override IEnumerable> GenerateDataSources(DataGeneratorMetadata metadata) { - yield return () => + for (var i = 0; i < Rows; i++) { - var events = metadata.TestBuilderContext.Current.Events; - events.OnTestRegistered += Record("registered"); - events.OnTestStart += Record("start"); - events.OnTestEnd += Record("end"); - events.OnTestSkipped += Record("skipped"); - events.OnTestRetry += (_, args) => + yield return () => { - args.TestContext.StateBag.Items["retry"] = args.RetryAttempt; - return default; + var events = metadata.TestBuilderContext.Current.Events; + events.OnTestRegistered += Record("registered"); + events.OnTestStart += Record("start"); + events.OnTestEnd += Record("end"); + events.OnTestSkipped += Record("skipped"); + events.OnTestRetry += (_, args) => + { + args.TestContext.StateBag.Items["retry"] = args.RetryAttempt; + return default; + }; + return 1; }; - return 1; - }; + } } private static Func Record(string name) => (_, context) => @@ -84,3 +89,62 @@ public static async Task Verify(ClassHookContext context) } } } + +[DelegateLifecycleEventTests.Subscribe(Rows = 2)] +public class ClassDelegateLifecycleEventTests(int value) +{ + [Test, Repeat(1), EngineTest(ExpectedResult.Pass)] + public async Task FirstRow() + { + await Assert.That(value).IsEqualTo(1); + await Assert.That(TestContext.Current!.StateBag.Items["registered"]).IsEqualTo(1); + await Assert.That(TestContext.Current.StateBag.Items["start"]).IsEqualTo(1); + } + + [After(Class)] + public static async Task Verify(ClassHookContext context) + { + foreach (var test in context.Tests) + { + await Assert.That(test.StateBag.Items["end"]).IsEqualTo(1); + } + } +} + +public class DataScopeRetryLifecycleTests +{ + public sealed class Scope : IDisposable + { + public int DisposeCount; + public void Dispose() => DisposeCount++; + } + + public sealed record Service(Scope Scope); + + public sealed class ScopeDataAttribute : DependencyInjectionDataSourceAttribute + { + public override Scope CreateScope(DataGeneratorMetadata metadata) => new(); + public override object Create(Scope scope, Type type) => new Service(scope); + } + + [Test, ScopeData, Retry(1), EngineTest(ExpectedResult.Pass)] + public async Task ScopeSurvivesRetry(Service service) + { + var context = TestContext.Current!; + context.StateBag.Items["scope"] = service.Scope; + await Assert.That(service.Scope.DisposeCount).IsEqualTo(0); + if (context.StateBag.Items.TryAdd("firstAttempt", true)) + { + throw new InvalidOperationException("Exercise scope lifetime across retries"); + } + } + + [After(Class)] + public static async Task Verify(ClassHookContext context) + { + foreach (var test in context.Tests) + { + await Assert.That(((Scope)test.StateBag.Items["scope"]!).DisposeCount).IsEqualTo(1); + } + } +} From daf26b3dc177efa463e1ec318eb4ca0d1ea1f1a8 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Mon, 2 Nov 2026 23:57:02 +0000 Subject: [PATCH 03/27] fix: preserve row state and isolate class callbacks (#7308) --- src/TUnit.Core/AsyncEvent.cs | 5 ++ src/TUnit.Core/TestContextEvents.cs | 12 +++++ src/TUnit.Engine/Building/TestBuilder.cs | 46 +++++++++++-------- .../DelegateLifecycleEventTests.cs | 2 + 4 files changed, 46 insertions(+), 19 deletions(-) diff --git a/src/TUnit.Core/AsyncEvent.cs b/src/TUnit.Core/AsyncEvent.cs index 34cedd51612..35635ac1464 100644 --- a/src/TUnit.Core/AsyncEvent.cs +++ b/src/TUnit.Core/AsyncEvent.cs @@ -49,6 +49,11 @@ public class AsyncEvent { private List? _handlers; + internal AsyncEvent Clone() => new() + { + _handlers = _handlers is null ? null : [.. _handlers] + }; + /// /// Represents a single invocation of an async event handler. /// diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 26fe3074399..798ab08e016 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -7,6 +7,18 @@ namespace TUnit.Core; /// public class TestContextEvents : ITestEvents { + internal TestContextEvents Clone() => new() + { + OnDataRowDispose = OnDataRowDispose?.Clone(), + OnDispose = OnDispose?.Clone(), + OnTestRegistered = OnTestRegistered?.Clone(), + OnInitialize = OnInitialize?.Clone(), + OnTestStart = OnTestStart?.Clone(), + OnTestEnd = OnTestEnd?.Clone(), + OnTestSkipped = OnTestSkipped?.Clone(), + OnTestRetry = OnTestRetry?.Clone() + }; + internal AsyncEvent? OnDataRowDispose { get; set; } public AsyncEvent? OnDispose { get; set; } diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index bfbba65d90f..457f791247d 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -241,7 +241,7 @@ public async ValueTask> BuildTestsFromMetada // No test holds this first fetch yet. The first test built from this class row takes it // instead of calling the factory again, so a non-shared source does not create an extra // instance that nothing tracks or disposes (#7157). - var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current.EventsIfCreated); + var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current); #if NET // Register scope for class data objects from the simple path. @@ -306,6 +306,7 @@ public async ValueTask> BuildTestsFromMetada { // Update context BEFORE calling data factories so they track objects in the right context // StateBag and Events are lazy-initialized for performance + var enumerationContext = contextAccessor.Current; contextAccessor.Current = new TestBuilderContext { TestMetadata = metadata.MethodMetadata, @@ -315,7 +316,7 @@ public async ValueTask> BuildTestsFromMetada ClassConstructor = testBuilderContext.ClassConstructor }; - testBuilderContext.CopyStateBagTo(contextAccessor.Current); + enumerationContext.CopyStateBagTo(contextAccessor.Current); var (classDataUnwrapped, classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory, contextAccessor.Current); classData = classDataUnwrapped; @@ -363,7 +364,7 @@ public async ValueTask> BuildTestsFromMetada { // Skip this data source as it's not compatible with the expected types. // No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); + unclaimedClassRow.Return(classData, classRowMetadata); continue; } } @@ -1055,12 +1056,14 @@ public ValueTask MoveNextAsync() /// are lent to the instance instead, and the next test built from the row tracks them without /// receiving them, so they are still disposed. /// - private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestContextEvents? events) + private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rowContext) { private object?[]? _data = data; private TestDataRowMetadata? _metadata = metadata; private object?[]? _lent; - private TestContextEvents? _events = events; + private TestBuilderContext _rowContext = rowContext; + // Snapshot before any method factory can mutate the class subscriptions. + private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); /// /// Takes the unclaimed objects, or fetches a new row from when a @@ -1068,33 +1071,37 @@ private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? meta /// public ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> TakeOrFetchAsync(Func> classDataFactory, TestBuilderContext context) { - if (_events is { } savedEvents) - { - context.Events = savedEvents; - _events = null; - } - if (_data is { } data) { + _rowContext.CopyStateBagTo(context); + if (_events is { } savedEvents) + { + context.Events = savedEvents.Clone(); + } var row = (data, _metadata); Clear(); return new ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)>(row); } - return FetchAsync(classDataFactory); + return FetchAsync(classDataFactory, context); - static async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory) - => DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); + async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory, TestBuilderContext target) + { + var row = DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); + _rowContext = target with { }; + target.CopyStateBagTo(_rowContext); + _events = target.EventsIfCreated?.Clone(); + return row; + } } /// /// Hands back objects that were taken but that no test ended up holding, so the next test takes them. /// - public void Return(object?[] data, TestDataRowMetadata? metadata, TestContextEvents? events) + public void Return(object?[] data, TestDataRowMetadata? metadata) { _data = data; _metadata = metadata; - _events = events; } /// @@ -2191,7 +2198,7 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( // The first test built from this class row takes this fetch instead of calling the factory // again, so a non-shared source does not create an extra, untracked instance (#7157). - var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current.EventsIfCreated); + var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current); // Initialize objects before method data sources are evaluated (ObjectInitializer is phase-aware) await InitializeClassDataAsync(classData); @@ -2251,6 +2258,7 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( { cancellationToken.ThrowIfCancellationRequested(); + var enumerationContext = contextAccessor.Current; contextAccessor.Current = new TestBuilderContext { TestMetadata = metadata.MethodMetadata, @@ -2259,7 +2267,7 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( ClassDataSourceAttribute = classDataSource, DataSourceAttribute = methodDataSource }; - baseContext.CopyStateBagTo(contextAccessor.Current); + enumerationContext.CopyStateBagTo(contextAccessor.Current); // Build and yield single test var test = await BuildSingleTestAsync( @@ -2436,7 +2444,7 @@ private async Task CreateInstanceForMethodDataSources( if (!IsDataCompatibleWithExpectedTypes(metadata, methodData)) { // Skip incompatible data. No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); + unclaimedClassRow.Return(classData, classRowMetadata); return null; } } diff --git a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs index 630c66c1d83..e84635a838f 100644 --- a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs +++ b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs @@ -15,6 +15,7 @@ protected override IEnumerable> GenerateDataSources(DataGeneratorMetad { yield return () => { + metadata.TestBuilderContext.Current.StateBag["factoryState"] = "preserved"; var events = metadata.TestBuilderContext.Current.Events; events.OnTestRegistered += Record("registered"); events.OnTestStart += Record("start"); @@ -97,6 +98,7 @@ public class ClassDelegateLifecycleEventTests(int value) public async Task FirstRow() { await Assert.That(value).IsEqualTo(1); + await Assert.That(TestContext.Current!.StateBag.Items["factoryState"]).IsEqualTo("preserved"); await Assert.That(TestContext.Current!.StateBag.Items["registered"]).IsEqualTo(1); await Assert.That(TestContext.Current.StateBag.Items["start"]).IsEqualTo(1); } From a0e3e583efda7564f323d88c5c9ed03805c84d1d Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 00:02:46 +0000 Subject: [PATCH 04/27] fix: isolate factory state between data rows (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 12 ++++--- .../StateBagRowIsolationTests.cs | 36 +++++++++++++++++++ 2 files changed, 44 insertions(+), 4 deletions(-) create mode 100644 tests/TUnit.TestProject/StateBagRowIsolationTests.cs diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 457f791247d..658e07c6d3f 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -302,11 +302,11 @@ public async ValueTask> BuildTestsFromMetada hasAnyMethodData = true; methodDataLoopIndex++; + var enumerationContext = contextAccessor.Current; for (var i = 0; i < repeatCount + 1; i++) { // Update context BEFORE calling data factories so they track objects in the right context // StateBag and Events are lazy-initialized for performance - var enumerationContext = contextAccessor.Current; contextAccessor.Current = new TestBuilderContext { TestMetadata = metadata.MethodMetadata, @@ -507,9 +507,10 @@ public async ValueTask> BuildTestsFromMetada test.Context.SkipReason = basicSkipReason; } tests.Add(test); - - // Context already updated at the beginning of the loop before calling factories } + + // Resume enumeration against its own context, without factory-written row state. + contextAccessor.Current = enumerationContext; } // If no data was yielded and SkipIfEmpty is true, create a skipped test @@ -2253,12 +2254,12 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( cancellationToken.ThrowIfCancellationRequested(); methodDataLoopIndex++; + var enumerationContext = contextAccessor.Current; // Stream through repeat count for (var i = 0; i < repeatCount + 1; i++) { cancellationToken.ThrowIfCancellationRequested(); - var enumerationContext = contextAccessor.Current; contextAccessor.Current = new TestBuilderContext { TestMetadata = metadata.MethodMetadata, @@ -2283,6 +2284,9 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( yield return test; } } + + // Keep subsequent rows and repeats independent of each test's factory state. + contextAccessor.Current = enumerationContext; } } } diff --git a/tests/TUnit.TestProject/StateBagRowIsolationTests.cs b/tests/TUnit.TestProject/StateBagRowIsolationTests.cs new file mode 100644 index 00000000000..11579691d3f --- /dev/null +++ b/tests/TUnit.TestProject/StateBagRowIsolationTests.cs @@ -0,0 +1,36 @@ +using TUnit.TestProject.Attributes; + +namespace TUnit.TestProject; + +public class StateBagRowIsolationTests +{ + public sealed class RowStateAttribute : DataSourceGeneratorAttribute + { + protected override IEnumerable> GenerateDataSources(DataGeneratorMetadata metadata) + { + for (var i = 1; i <= 2; i++) + { + var row = i; + metadata.TestBuilderContext.Current.StateBag["enumerationRow"] = row; + yield return () => + { + var context = metadata.TestBuilderContext.Current; + if (!context.StateBag.TryAdd("factoryResource", new object())) + { + throw new InvalidOperationException("Factory inherited another test's resource"); + } + + context.StateBag.TryAdd("factoryRow", row); + return row; + }; + } + } + } + + [Test, RowState, Repeat(1), EngineTest(ExpectedResult.Pass)] + public async Task RowsAndRepeatsHaveIndependentState(int row) + { + await Assert.That(TestContext.Current!.StateBag["enumerationRow"]).IsEqualTo(row); + await Assert.That(TestContext.Current.StateBag["factoryRow"]).IsEqualTo(row); + } +} From b5f51b3882e4a66489324cca59ad255b84896706 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 00:17:25 +0000 Subject: [PATCH 05/27] fix(core): leave scope-owned arguments to their DI scope (#7308) --- ...dencyInjectionDataSourceSourceAttribute.cs | 39 ++++- .../Discovery/ObjectGraphDiscoverer.cs | 65 +++++++- src/TUnit.Core/TestContextEvents.cs | 2 + src/TUnit.Core/Tracking/ObjectTracker.cs | 51 +++++- .../DelegateLifecycleEventTests.cs | 80 ++++++++- tests/TUnit.TestProject/MEDITest.cs | 6 + .../ExternallyOwnedSingletonTests.cs | 153 ++++++++++++++++++ 7 files changed, 379 insertions(+), 17 deletions(-) create mode 100644 tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs diff --git a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs index b798ff9f62f..d748617e570 100644 --- a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs +++ b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs @@ -1,4 +1,5 @@ using System.Diagnostics.CodeAnalysis; +using TUnit.Core.Tracking; namespace TUnit.Core; @@ -11,7 +12,11 @@ public abstract class DependencyInjectionDataSourceAttribute : UntypedDa // Create a new scope for each test execution var scope = CreateScope(dataGeneratorMetadata); - // Method and class arguments are reused by retries; dispose their scope after the final attempt. + // Only a disposable scope can dispose what it resolves. Otherwise the object tracker keeps + // disposing the returned objects, as it does for any other data source. + var scopeOwnsCreatedObjects = scope is IDisposable or IAsyncDisposable; + + // Set up disposal for this specific scope in the current test context dataGeneratorMetadata.TestBuilderContext.Current.Events.OnDataRowDispose += async (_, _) => { if (scope is IAsyncDisposable asyncDisposable) @@ -33,12 +38,42 @@ public abstract class DependencyInjectionDataSourceAttribute : UntypedDa MethodMetadata method => method.Type, _ => throw new InvalidOperationException($"Unknown member type: {m.GetType()}") }) - .Select(x => Create(scope, x)) + .Select(x => + { + var created = Create(scope, x); + + if (scopeOwnsCreatedObjects) + { + // The scope owns what it resolves and disposes it with itself above, so the + // object tracker must not dispose it a second time when the test ends. + ObjectTracker.MarkExternallyOwned(created); + } + + return created; + }) .ToArray(); }; } + /// + /// Creates the scope that resolves one test's arguments. A disposable scope is disposed when the + /// test ends, after its last attempt. + /// + /// + /// A scope that implements or owns the objects + /// returns: TUnit disposes the scope and does not dispose those objects itself, so + /// the scope's disposal must dispose them. + /// public abstract TScope CreateScope(DataGeneratorMetadata dataGeneratorMetadata); + /// + /// Resolves an argument of type from . + /// + /// + /// When the scope is disposable, it owns what this method returns, including the + /// objects held in their properties: TUnit disposes the scope, and the scope is expected to dispose the + /// objects it resolved, so TUnit does not dispose them itself. TUnit still initializes them. + /// When the scope is not disposable, TUnit disposes disposable returned objects when the test ends. + /// public abstract object? Create(TScope scope, Type type); } diff --git a/src/TUnit.Core/Discovery/ObjectGraphDiscoverer.cs b/src/TUnit.Core/Discovery/ObjectGraphDiscoverer.cs index f93dee096c1..5f588a7ea9e 100644 --- a/src/TUnit.Core/Discovery/ObjectGraphDiscoverer.cs +++ b/src/TUnit.Core/Discovery/ObjectGraphDiscoverer.cs @@ -9,6 +9,7 @@ using TUnit.Core.Interfaces; using TUnit.Core.Interfaces.SourceGenerator; using TUnit.Core.PropertyInjection; +using TUnit.Core.Tracking; namespace TUnit.Core.Discovery; @@ -199,7 +200,7 @@ private SortedList> TrackObjectsCore(TestContext testContex TryAddObjectFunc tryAdd = (obj, depth) => TryAddToHashSet(visitedObjects, depth, obj); RootObjectCallback onRootObjectAdded = discoverNested - ? obj => DiscoverNestedObjectsForTracking(obj, visitedObjects, 1, cancellationToken) + ? obj => DiscoverNestedObjectsForTracking(obj, visitedObjects, 1, heldByExternalOwner: false, cancellationToken) : static _ => { }; // Collect root-level objects and discover nested objects for tracking @@ -318,10 +319,15 @@ void Recurse(object value, int depth) /// Discovers nested objects for tracking (uses HashSet pattern for compatibility with TestContext.TrackedObjects). /// Uses consolidated TraverseInjectableProperties and TraverseInitializerProperties methods. /// + /// + /// True when was found beneath an object that another owner (a dependency + /// injection scope) disposes. Such an object is treated as externally owned even when it is not marked. + /// private void DiscoverNestedObjectsForTracking( object obj, IDictionary> visitedObjects, int currentDepth, + bool heldByExternalOwner, CancellationToken cancellationToken) { if (!CheckRecursionDepth(obj, currentDepth)) @@ -338,13 +344,15 @@ private void DiscoverNestedObjectsForTracking( return; } - DiscoverNestedObjectsForTrackingCore(obj, visitedObjects, currentDepth, cancellationToken); + var externallyOwned = heldByExternalOwner || ObjectTracker.IsExternallyOwned(obj); + DiscoverNestedObjectsForTrackingCore(obj, visitedObjects, currentDepth, externallyOwned, cancellationToken); } private void DiscoverNestedObjectsForTrackingCore( object obj, IDictionary> visitedObjects, int currentDepth, + bool externallyOwned, CancellationToken cancellationToken) { // Tracking mode add callback: TryAddToHashSet only @@ -353,17 +361,58 @@ bool TryAddTracking(object value, int depth) return TryAddToHashSet(visitedObjects, depth, value); } - // Recursive callback + // Recursive callback. TUnit creates the values of injectable properties, so the tracker owns them. void Recurse(object value, int depth) { - DiscoverNestedObjectsForTracking(value, visitedObjects, depth, cancellationToken); + DiscoverNestedObjectsForTracking(value, visitedObjects, depth, heldByExternalOwner: false, cancellationToken); } - // Traverse injectable properties (useSourceRegistrarCheck = true for tracking mode) - TraverseInjectableProperties(obj, TryAddTracking, Recurse, currentDepth, cancellationToken, useSourceRegistrarCheck: true); + if (!externallyOwned) + { + // Traverse injectable properties (useSourceRegistrarCheck = true for tracking mode) + TraverseInjectableProperties(obj, TryAddTracking, Recurse, currentDepth, cancellationToken, useSourceRegistrarCheck: true); - // Also discover nested IAsyncInitializer objects from ALL properties - TraverseInitializerProperties(obj, TryAddTracking, Recurse, currentDepth, cancellationToken); + // Also discover nested IAsyncInitializer objects from ALL properties + TraverseInitializerProperties(obj, TryAddTracking, Recurse, currentDepth, cancellationToken); + return; + } + + // TUnit injected these values even though obj is externally owned, so the tracker still owns them. + // The initializer traversal below visits the same properties again and must not mark them. + HashSet? injectedValues = null; + + bool TryAddInjected(object value, int depth) + { + (injectedValues ??= new HashSet(ReferenceComparer)).Add(value); + return TryAddToHashSet(visitedObjects, depth, value); + } + + TraverseInjectableProperties(obj, TryAddInjected, Recurse, currentDepth, cancellationToken, useSourceRegistrarCheck: true); + + // The owner of obj (a dependency injection scope) created the rest of what obj holds and disposes + // it, so the tracker must not dispose it a second time (#7205). The objects are still tracked, so + // they are initialized. + bool TryAddOwned(object value, int depth) + { + if (injectedValues?.Contains(value) == true) + { + return false; + } + + if (value is IDisposable or IAsyncDisposable) + { + ObjectTracker.MarkExternallyOwned(value); + } + + return TryAddToHashSet(visitedObjects, depth, value); + } + + void RecurseOwned(object value, int depth) + { + DiscoverNestedObjectsForTracking(value, visitedObjects, depth, heldByExternalOwner: true, cancellationToken); + } + + TraverseInitializerProperties(obj, TryAddOwned, RecurseOwned, currentDepth, cancellationToken); } /// diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 798ab08e016..3847ae45f9d 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -24,8 +24,10 @@ public class TestContextEvents : ITestEvents public AsyncEvent? OnDispose { get; set; } public AsyncEvent? OnTestRegistered { get; set; } public AsyncEvent? OnInitialize { get; set; } + // Delegate subscribers run once in the late stage, after early-stage receivers. public AsyncEvent? OnTestStart { get; set; } public AsyncEvent? OnTestEnd { get; set; } public AsyncEvent? OnTestSkipped { get; set; } + // A handler failure aborts retry processing, as a failure in retry policy does. public AsyncEvent<(TestContext TestContext, int RetryAttempt)>? OnTestRetry { get; set; } } diff --git a/src/TUnit.Core/Tracking/ObjectTracker.cs b/src/TUnit.Core/Tracking/ObjectTracker.cs index eb161b02841..a602d004114 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -1,4 +1,5 @@ using System.Collections.Concurrent; +using System.Runtime.CompilerServices; using TUnit.Core.Helpers; namespace TUnit.Core.Tracking; @@ -49,7 +50,7 @@ internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphPr foreach (var kvp in s_trackedObjects) { // TryRemove guards against racing disposals (e.g. a late UntrackObject call) - if (!s_trackedObjects.TryRemove(kvp.Key, out _)) + if (!s_trackedObjects.TryRemove(kvp.Key, out _) || IsExternallyOwned(kvp.Key)) { continue; } @@ -335,7 +336,8 @@ private void TrackObject(object? obj) private async ValueTask UntrackObject(object? obj, TestContext? testContext) { - if (obj == null || ShouldSkipTracking(obj)) + // Release any count acquired before another source marked the object externally owned. + if (obj is not IDisposable and not IAsyncDisposable) { return; } @@ -361,7 +363,7 @@ private async ValueTask UntrackObject(object? obj, TestContext? testContext) } } - if (shouldDispose) + if (shouldDispose && !IsExternallyOwned(obj)) { #if NET if (TryGetSharedDisposeScope(obj, out var sharedType)) @@ -523,7 +525,48 @@ private static bool Contains(SortedList>? trackedObjects, o /// private static bool ShouldSkipTracking(object? obj) { - return obj is not IDisposable and not IAsyncDisposable; + return obj is not IDisposable and not IAsyncDisposable + || IsExternallyOwned(obj); + } + + /// + /// Whether marked . + /// + internal static bool IsExternallyOwned(object obj) + => s_hasExternallyOwned && s_externallyOwned.TryGetValue(obj, out _); + + // Objects whose lifetime another owner controls (a dependency injection scope, for example). + // The tracker never counts or disposes them, so their owner is the only thing that disposes them. + private static readonly ConditionalWeakTable s_externallyOwned = new(); + private static readonly object s_externallyOwnedMarker = new(); + + // Skips the table lookup for every tracked object until something is marked. + private static volatile bool s_hasExternallyOwned; + + /// + /// Marks as disposed by another owner, so the tracker never counts or disposes it. + /// Dependency injection data sources mark the services they resolve, because the scope that created + /// them disposes them when the test ends (#7205). Existing tracker references are released + /// without disposing the object, regardless of which data source supplied it first. + /// + /// + /// The mark lasts for the object's lifetime and applies to every data source that later supplies the + /// object, because the object still belongs to the container that resolved it: a root singleton is + /// disposed by its root container, not by a test. A non-owning source may already + /// have counted the object, or count it concurrently with the mark. + /// That count is still released, and the tracker leaves the object to its owner rather than disposing it + /// when the count reaches zero or at session end. + /// + internal static void MarkExternallyOwned(object? obj) + { + // A non-disposable object is marked too: the initializer objects it holds belong to the same owner. + if (obj is null) + { + return; + } + + s_externallyOwned.GetValue(obj, static _ => s_externallyOwnedMarker); + s_hasExternallyOwned = true; } /// diff --git a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs index e84635a838f..b14b8b9664c 100644 --- a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs +++ b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs @@ -118,15 +118,51 @@ public class DataScopeRetryLifecycleTests public sealed class Scope : IDisposable { public int DisposeCount; - public void Dispose() => DisposeCount++; + public Service? Service; + public void Dispose() + { + DisposeCount++; + Service?.Dispose(); + } } - public sealed record Service(Scope Scope); + public sealed record Service(Scope Scope) : IDisposable + { + public int DisposeCount; + public Dependency Dependency { get; } = new(); + + public void Dispose() + { + if (++DisposeCount != 1) + { + throw new InvalidOperationException("Scope-owned service disposed more than once"); + } + Dependency.Dispose(); + } + } + + public sealed class Dependency : TUnit.Core.Interfaces.IAsyncInitializer, IDisposable + { + public bool Initialized { get; private set; } + public int DisposeCount; + public Task InitializeAsync() + { + Initialized = true; + return Task.CompletedTask; + } + public void Dispose() + { + if (++DisposeCount != 1) + { + throw new InvalidOperationException("Scope-owned dependency disposed more than once"); + } + } + } public sealed class ScopeDataAttribute : DependencyInjectionDataSourceAttribute { public override Scope CreateScope(DataGeneratorMetadata metadata) => new(); - public override object Create(Scope scope, Type type) => new Service(scope); + public override object Create(Scope scope, Type type) => scope.Service = new Service(scope); } [Test, ScopeData, Retry(1), EngineTest(ExpectedResult.Pass)] @@ -135,6 +171,9 @@ public async Task ScopeSurvivesRetry(Service service) var context = TestContext.Current!; context.StateBag.Items["scope"] = service.Scope; await Assert.That(service.Scope.DisposeCount).IsEqualTo(0); + await Assert.That(service.DisposeCount).IsEqualTo(0); + await Assert.That(service.Dependency.Initialized).IsTrue(); + await Assert.That(service.Dependency.DisposeCount).IsEqualTo(0); if (context.StateBag.Items.TryAdd("firstAttempt", true)) { throw new InvalidOperationException("Exercise scope lifetime across retries"); @@ -147,6 +186,41 @@ public static async Task Verify(ClassHookContext context) foreach (var test in context.Tests) { await Assert.That(((Scope)test.StateBag.Items["scope"]!).DisposeCount).IsEqualTo(1); + await Assert.That(((Scope)test.StateBag.Items["scope"]!).Service!.DisposeCount).IsEqualTo(1); + await Assert.That(((Scope)test.StateBag.Items["scope"]!).Service!.Dependency.DisposeCount).IsEqualTo(1); + } + } +} + +public class NonDisposableDataScopeLifecycleTests +{ + public sealed class Scope; + + public sealed class Service : IDisposable + { + public int DisposeCount; + public void Dispose() => DisposeCount++; + } + + public sealed class ScopeDataAttribute : DependencyInjectionDataSourceAttribute + { + public override Scope CreateScope(DataGeneratorMetadata metadata) => new(); + public override object Create(Scope scope, Type type) => new Service(); + } + + [Test, ScopeData, EngineTest(ExpectedResult.Pass)] + public async Task TrackerOwnsServicesWithoutDisposableScope(Service service) + { + TestContext.Current!.StateBag.Items["service"] = service; + await Assert.That(service.DisposeCount).IsEqualTo(0); + } + + [After(Class)] + public static async Task Verify(ClassHookContext context) + { + foreach (var test in context.Tests) + { + await Assert.That(((Service)test.StateBag.Items["service"]!).DisposeCount).IsEqualTo(1); } } } diff --git a/tests/TUnit.TestProject/MEDITest.cs b/tests/TUnit.TestProject/MEDITest.cs index c1bd61659c8..452ebf36405 100644 --- a/tests/TUnit.TestProject/MEDITest.cs +++ b/tests/TUnit.TestProject/MEDITest.cs @@ -66,6 +66,7 @@ public static async Task CheckDisposed(TestSessionContext testSessionContext) } await Assert.That(mediClass.IsDisposed).IsTrue(); + await Assert.That(mediClass.DisposeCount).IsEqualTo(1); } } @@ -73,6 +74,7 @@ public class MEDIClass : IAsyncInitializer, IAsyncDisposable { public bool IsInitialized { get; private set; } public bool IsDisposed { get; private set; } + public int DisposeCount { get; private set; } public Task InitializeAsync() { @@ -82,6 +84,10 @@ public Task InitializeAsync() public ValueTask DisposeAsync() { + if (++DisposeCount != 1) + { + throw new InvalidOperationException("Scope-owned service disposed more than once"); + } IsDisposed = true; return default(ValueTask); } diff --git a/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs b/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs new file mode 100644 index 00000000000..adf494eb836 --- /dev/null +++ b/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs @@ -0,0 +1,153 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using TUnit.Core.Discovery; +using TUnit.Core.Interfaces; +using TUnit.Core.Tracking; + +namespace TUnit.UnitTests; + +/// +/// A root singleton can reach tests both through a dependency injection scope, which marks what it returns +/// as externally owned, and through a data source that does not own it. These tests pin what the object +/// tracker does with such an object in each order, including when the scope's mark races with another +/// source's count (#7205). +/// +public class ExternallyOwnedSingletonTests +{ + // Synthetic contexts never reach the engine's cleanup, so each test removes its own from the registry. + private readonly List _contexts = []; + + [After(Test)] + public void RemoveContextsFromRegistry() + { + foreach (var context in _contexts) + { + context.RemoveFromRegistry(); + } + } + + [Test] + public async Task Marked_Before_Another_Source_Supplies_It_Is_Never_Disposed_By_The_Tracker() + { + var tracker = CreateTracker(); + var singleton = new TrackedDisposable(); + + ObjectTracker.MarkExternallyOwned(singleton); + + var nonOwningTest = CreateContext(singleton); + tracker.TrackObjects(nonOwningTest); + await tracker.UntrackObjects(nonOwningTest); + + await Assert.That(ObjectTracker.IsExternallyOwned(singleton)).IsTrue(); + await Assert.That(singleton.DisposeCount).IsEqualTo(0); + } + + [Test] + public async Task Counted_Before_The_Scope_Returns_It_Is_Released_Without_Disposal() + { + var tracker = CreateTracker(); + var singleton = new TrackedDisposable(); + + var nonOwningTest = CreateContext(singleton); + tracker.TrackObjects(nonOwningTest); + + // A non-owning source can supply a container singleton before its owning source does. + ObjectTracker.MarkExternallyOwned(singleton); + await Assert.That(ObjectTracker.IsExternallyOwned(singleton)).IsTrue(); + + await tracker.UntrackObjects(nonOwningTest); + + await Assert.That(singleton.DisposeCount).IsEqualTo(0); + await Assert.That(IsCounted(singleton)).IsFalse(); + } + + [Test] + public async Task Counted_Between_The_Check_And_The_Mark_Is_Released_Without_Being_Disposed() + { + var tracker = CreateTracker(); + var singleton = new TrackedDisposable(); + + var nonOwningTest = CreateContext(singleton); + tracker.TrackObjects(nonOwningTest); + + // MarkExternallyOwned found no count, then another source counted the object before the mark landed. + MarkBypassingTheCountCheck(singleton); + + await tracker.UntrackObjects(nonOwningTest); + + await Assert.That(singleton.DisposeCount).IsEqualTo(0); + + // The count was released, so the session-end sweep will not dispose the object either. + await Assert.That(IsCounted(singleton)).IsFalse(); + + // A later source does not count it. + var laterTest = CreateContext(singleton); + tracker.TrackObjects(laterTest); + await tracker.UntrackObjects(laterTest); + + await Assert.That(singleton.DisposeCount).IsEqualTo(0); + } + + private static void MarkBypassingTheCountCheck(object obj) + { + const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Static; + var table = (ConditionalWeakTable) typeof(ObjectTracker).GetField("s_externallyOwned", flags)!.GetValue(null)!; + table.Add(obj, new object()); + typeof(ObjectTracker).GetField("s_hasExternallyOwned", flags)!.SetValue(null, true); + } + + private static bool IsCounted(object obj) + { + var counters = (System.Collections.IDictionary) typeof(ObjectTracker) + .GetField("s_trackedObjects", BindingFlags.NonPublic | BindingFlags.Static)!.GetValue(null)!; + return counters.Contains(obj); + } + + private static ObjectTracker CreateTracker() + => new(new TrackableObjectGraphProvider(new RootsOnlyDiscoverer()), GlobalContext.Current.Disposer); + + private TestContext CreateContext(object root) + { + var currentContext = TestContext.Current!; + var context = new TestContext(nameof(ExternallyOwnedSingletonTests), currentContext.ServiceProvider, currentContext.ClassContext, + new TestBuilderContext { TestMetadata = currentContext.TestDetails.MethodMetadata }, CancellationToken.None); + Roots.Add(context, root); + _contexts.Add(context); + return context; + } + + // The root each context's data source supplied, which discovery adds to the context's tracked objects. + private static readonly ConditionalWeakTable Roots = new(); + + private sealed class TrackedDisposable : IDisposable + { + private int _disposeCount; + + public int DisposeCount => _disposeCount; + + public void Dispose() => Interlocked.Increment(ref _disposeCount); + } + + private sealed class RootsOnlyDiscoverer : IObjectGraphDiscoverer + { + public SortedList> DiscoverAndTrackObjects(TestContext testContext, CancellationToken cancellationToken = default) + => TrackRootObjects(testContext); + + public SortedList> TrackRootObjects(TestContext testContext) + { + var tracked = testContext.TrackedObjects; + if (Roots.TryGetValue(testContext, out var root)) + { + tracked[0] = new HashSet(TUnit.Core.Helpers.ReferenceEqualityComparer.Instance) { root }; + } + + return tracked; + } + + public ObjectGraph DiscoverObjectGraph(TestContext testContext, CancellationToken cancellationToken = default) + => throw new NotSupportedException(); + + public ObjectGraph DiscoverNestedObjectGraph(object rootObject, CancellationToken cancellationToken = default) + => throw new NotSupportedException(); + } +} From 013916618fccd057ff1f023cb79acad1dcd4d4d4 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 00:24:39 +0000 Subject: [PATCH 06/27] fix: balance scope references and preserve cleanup order (#7308) --- src/TUnit.Core/Tracking/ObjectTracker.cs | 7 +- src/TUnit.Engine/Building/TestBuilder.cs | 12 ++++ .../Services/TestExecution/TestCoordinator.cs | 10 ++- .../DelegateLifecycleEventTests.cs | 67 +++++++++++++++++++ .../ExternallyOwnedSingletonTests.cs | 23 ++++++- 5 files changed, 113 insertions(+), 6 deletions(-) diff --git a/src/TUnit.Core/Tracking/ObjectTracker.cs b/src/TUnit.Core/Tracking/ObjectTracker.cs index a602d004114..7679269f176 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -525,8 +525,7 @@ private static bool Contains(SortedList>? trackedObjects, o /// private static bool ShouldSkipTracking(object? obj) { - return obj is not IDisposable and not IAsyncDisposable - || IsExternallyOwned(obj); + return obj is not IDisposable and not IAsyncDisposable; } /// @@ -536,7 +535,7 @@ internal static bool IsExternallyOwned(object obj) => s_hasExternallyOwned && s_externallyOwned.TryGetValue(obj, out _); // Objects whose lifetime another owner controls (a dependency injection scope, for example). - // The tracker never counts or disposes them, so their owner is the only thing that disposes them. + // The tracker balances references but never disposes them; their owner controls disposal. private static readonly ConditionalWeakTable s_externallyOwned = new(); private static readonly object s_externallyOwnedMarker = new(); @@ -544,7 +543,7 @@ internal static bool IsExternallyOwned(object obj) private static volatile bool s_hasExternallyOwned; /// - /// Marks as disposed by another owner, so the tracker never counts or disposes it. + /// Marks as disposed by another owner, so the tracker never disposes it. /// Dependency injection data sources mark the services they resolve, because the scope that created /// them disposes them when the test ends (#7205). Existing tracker references are released /// without disposing the object, regardless of which data source supplied it first. diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 658e07c6d3f..63191cf42d8 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1062,6 +1062,7 @@ private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? meta private object?[]? _data = data; private TestDataRowMetadata? _metadata = metadata; private object?[]? _lent; + private AsyncEvent? _lentCleanup; private TestBuilderContext _rowContext = rowContext; // Snapshot before any method factory can mutate the class subscriptions. private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); @@ -1089,6 +1090,16 @@ private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? meta async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory, TestBuilderContext target) { var row = DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); + // The temporary instance used a different scope. Keep its cleanup even when + // this fetch replaces the original class row's event snapshot. + if (_lentCleanup is { } lentCleanup) + { + foreach (var handler in lentCleanup.InvocationList) + { + target.Events.OnDataRowDispose += handler.InvokeAsync; + } + _lentCleanup = null; + } _rowContext = target with { }; target.CopyStateBagTo(_rowContext); _events = target.EventsIfCreated?.Clone(); @@ -1122,6 +1133,7 @@ public void Clear() public void LendToTemporaryInstance() { _lent = _data; + _lentCleanup = _events?.OnDataRowDispose?.Clone(); _data = null; _metadata = null; } diff --git a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs index 4262b886025..1a471c920b9 100644 --- a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs +++ b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs @@ -225,7 +225,7 @@ await RetryHelper.ExecuteWithRetry(test.Context, // Stay null on the success path — materializing the list only when something actually fails // saves ~56 bytes per passing test (and passing is the overwhelming majority). test.Context.StopHoldingSharedReferences(); - var cleanupExceptions = await _objectTracker.UntrackObjects(test.Context).ConfigureAwait(false); + List? cleanupExceptions = null; if (test.Context.InternalEventsIfCreated?.OnDataRowDispose is { } onDataRowDispose) { @@ -242,6 +242,14 @@ await RetryHelper.ExecuteWithRetry(test.Context, } } + // Scope-owned parents can use TUnit-injected dependencies during disposal. + // Release those dependencies only after their parents' scope cleanup has completed. + var trackingExceptions = await _objectTracker.UntrackObjects(test.Context).ConfigureAwait(false); + if (trackingExceptions is { Count: > 0 }) + { + (cleanupExceptions ??= []).AddRange(trackingExceptions); + } + #if NET // Per-test cleanup has completed. Keep the test activity open for final status // and export, but detach it from the ambient async-local context so shared diff --git a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs index b14b8b9664c..caa27320444 100644 --- a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs +++ b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs @@ -224,3 +224,70 @@ public static async Task Verify(ClassHookContext context) } } } + +[ScopeOwnedConstructorLifecycleTests.ScopeData] +public class ScopeOwnedConstructorLifecycleTests(ScopeOwnedConstructorLifecycleTests.Service service) +{ + public sealed class Scope : IDisposable + { + public Service? Service; + public int DisposeCount; + public void Dispose() + { + if (++DisposeCount != 1) throw new InvalidOperationException("Scope disposed twice"); + Service?.Dispose(); + } + } + + public sealed class Service(Scope scope) : IDisposable + { + public Scope Scope => scope; + [ClassDataSource] + public required InjectedDependency Dependency { get; init; } + public void Dispose() + { + if (Dependency is { Disposed: true }) + throw new InvalidOperationException("Injected dependency disposed before its parent"); + } + } + + public sealed class InjectedDependency : IDisposable + { + public bool Disposed; + public void Dispose() => Disposed = true; + } + + public sealed class ScopeDataAttribute : DependencyInjectionDataSourceAttribute + { + public static readonly System.Collections.Concurrent.ConcurrentBag Scopes = []; + public override Scope CreateScope(DataGeneratorMetadata metadata) + { + var scope = new Scope(); + Scopes.Add(scope); + return scope; + } + public override object Create(Scope scope, Type type) + => scope.Service = new Service(scope) { Dependency = null! }; + } + + public IEnumerable Rows() => [1, 2]; + + [Test, InstanceMethodDataSource(nameof(Rows)), EngineTest(ExpectedResult.Pass)] + public async Task ScopeAndDependencyAreAlive(int row) + { + await Assert.That(service.Scope.DisposeCount).IsEqualTo(0); + await Assert.That(service.Dependency.Disposed).IsFalse(); + } + + [After(Class)] + public static async Task Verify() + { + foreach (var scope in ScopeDataAttribute.Scopes) + { + await Assert.That(scope.DisposeCount).IsEqualTo(1); + // The initial instance is used only for discovery, so its properties may not be injected. + if (scope.Service?.Dependency is { } dependency) + await Assert.That(dependency.Disposed).IsTrue(); + } + } +} diff --git a/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs b/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs index adf494eb836..23c119369c1 100644 --- a/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs +++ b/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs @@ -80,7 +80,7 @@ public async Task Counted_Between_The_Check_And_The_Mark_Is_Released_Without_Bei // The count was released, so the session-end sweep will not dispose the object either. await Assert.That(IsCounted(singleton)).IsFalse(); - // A later source does not count it. + // A later source balances its own reference without taking disposal ownership. var laterTest = CreateContext(singleton); tracker.TrackObjects(laterTest); await tracker.UntrackObjects(laterTest); @@ -88,6 +88,27 @@ public async Task Counted_Between_The_Check_And_The_Mark_Is_Released_Without_Bei await Assert.That(singleton.DisposeCount).IsEqualTo(0); } + [Test] + public async Task Consumers_After_Ownership_Mark_Hold_Their_Own_References() + { + var tracker = CreateTracker(); + var singleton = new TrackedDisposable(); + var earlierTest = CreateContext(singleton); + tracker.TrackObjects(earlierTest); + ObjectTracker.MarkExternallyOwned(singleton); + var laterTest = CreateContext(singleton); + tracker.TrackObjects(laterTest); + + // Both consumers must hold a reference before either can release it. + await Assert.That(ObjectTracker.IsShared(singleton)).IsTrue(); + await Task.WhenAll( + Task.Run(async () => await tracker.UntrackObjects(earlierTest)), + Task.Run(async () => await tracker.UntrackObjects(laterTest))); + + await Assert.That(IsCounted(singleton)).IsFalse(); + await Assert.That(singleton.DisposeCount).IsEqualTo(0); + } + private static void MarkBypassingTheCountCheck(object obj) { const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Static; From d8d8af75b3ac788c6dd5742a3c2ba5a30cb19588 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 00:35:18 +0000 Subject: [PATCH 07/27] fix: dispose DI scopes in dependency graph order (#7308) --- ...dencyInjectionDataSourceSourceAttribute.cs | 35 +++++++- src/TUnit.Core/TestContextEvents.cs | 4 +- src/TUnit.Core/Tracking/ObjectTracker.cs | 15 ++++ src/TUnit.Engine/Building/TestBuilder.cs | 2 +- .../Services/TestExecution/TestCoordinator.cs | 18 ++-- .../DelegateLifecycleEventTests.cs | 87 +++++++++++++++++++ 6 files changed, 147 insertions(+), 14 deletions(-) diff --git a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs index d748617e570..4e98b14b799 100644 --- a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs +++ b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs @@ -16,9 +16,38 @@ public abstract class DependencyInjectionDataSourceAttribute : UntypedDa // disposing the returned objects, as it does for any other data source. var scopeOwnsCreatedObjects = scope is IDisposable or IAsyncDisposable; - // Set up disposal for this specific scope in the current test context - dataGeneratorMetadata.TestBuilderContext.Current.Events.OnDataRowDispose += async (_, _) => + // Dispose at the depth of the resolved objects, before their nested dependencies. + // The final null notification also cleans up scopes whose objects were not tracked. + object?[]? createdObjects = null; + var disposed = 0; + dataGeneratorMetadata.TestBuilderContext.Current.Events.OnDataRowDispose += async (_, args) => { + if (args.Object is not null) + { + var ownsObject = false; + if (createdObjects is not null) + { + foreach (var created in createdObjects) + { + if (ReferenceEquals(created, args.Object)) + { + ownsObject = true; + break; + } + } + } + + if (!ownsObject) + { + return; + } + } + + if (Interlocked.Exchange(ref disposed, 1) != 0) + { + return; + } + if (scope is IAsyncDisposable asyncDisposable) { await asyncDisposable.DisposeAsync().ConfigureAwait(false); @@ -29,7 +58,7 @@ public abstract class DependencyInjectionDataSourceAttribute : UntypedDa } }; - return dataGeneratorMetadata.MembersToGenerate + return createdObjects = dataGeneratorMetadata.MembersToGenerate .Select(m => m switch { PropertyMetadata prop => prop.Type, diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 3847ae45f9d..05f2c6beb2f 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -19,7 +19,9 @@ public class TestContextEvents : ITestEvents OnTestRetry = OnTestRetry?.Clone() }; - internal AsyncEvent? OnDataRowDispose { get; set; } + // Notified before each tracked object is released, then with null for any untracked scopes. + // Scope handlers match their resolved objects and dispose at most once. + internal AsyncEvent<(TestContext Context, object? Object)>? OnDataRowDispose { get; set; } public AsyncEvent? OnDispose { get; set; } public AsyncEvent? OnTestRegistered { get; set; } diff --git a/src/TUnit.Core/Tracking/ObjectTracker.cs b/src/TUnit.Core/Tracking/ObjectTracker.cs index 7679269f176..1573f6bb21e 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -263,6 +263,21 @@ private static void RemoveObjectsNotIn(SortedList>? tracked foreach (var obj in bucket) { + if (testContext.InternalEventsIfCreated?.OnDataRowDispose is { } scopeCleanup) + { + foreach (var handler in scopeCleanup.InvocationList) + { + try + { + await handler.InvokeAsync(this, (testContext, obj)).ConfigureAwait(false); + } + catch (Exception e) + { + (cleanupExceptions ??= []).Add(e); + } + } + } + try { var task = UntrackObject(obj, testContext); diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 63191cf42d8..31bb587e12f 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1062,7 +1062,7 @@ private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? meta private object?[]? _data = data; private TestDataRowMetadata? _metadata = metadata; private object?[]? _lent; - private AsyncEvent? _lentCleanup; + private AsyncEvent<(TestContext Context, object? Object)>? _lentCleanup; private TestBuilderContext _rowContext = rowContext; // Snapshot before any method factory can mutate the class subscriptions. private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); diff --git a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs index 1a471c920b9..5174a792884 100644 --- a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs +++ b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs @@ -227,13 +227,21 @@ await RetryHelper.ExecuteWithRetry(test.Context, test.Context.StopHoldingSharedReferences(); List? cleanupExceptions = null; + // Release roots before their dependencies. Scope cleanup is invoked at the resolved + // object's graph depth by the tracker; the final notification catches untracked scopes. + var trackingExceptions = await _objectTracker.UntrackObjects(test.Context).ConfigureAwait(false); + if (trackingExceptions is { Count: > 0 }) + { + (cleanupExceptions ??= []).AddRange(trackingExceptions); + } + if (test.Context.InternalEventsIfCreated?.OnDataRowDispose is { } onDataRowDispose) { foreach (var handler in onDataRowDispose.InvocationList) { try { - await handler.InvokeAsync(this, test.Context).ConfigureAwait(false); + await handler.InvokeAsync(this, (test.Context, null)).ConfigureAwait(false); } catch (Exception ex) { @@ -242,14 +250,6 @@ await RetryHelper.ExecuteWithRetry(test.Context, } } - // Scope-owned parents can use TUnit-injected dependencies during disposal. - // Release those dependencies only after their parents' scope cleanup has completed. - var trackingExceptions = await _objectTracker.UntrackObjects(test.Context).ConfigureAwait(false); - if (trackingExceptions is { Count: > 0 }) - { - (cleanupExceptions ??= []).AddRange(trackingExceptions); - } - #if NET // Per-test cleanup has completed. Keep the test activity open for final status // and export, but detach it from the ambient async-local context so shared diff --git a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs index caa27320444..1dd8ce61235 100644 --- a/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs +++ b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs @@ -291,3 +291,90 @@ public static async Task Verify() } } } + +public class InjectedScopeDisposalOrderTests +{ + public sealed class Parent : IAsyncDisposable + { + public static readonly System.Collections.Concurrent.ConcurrentBag Instances = []; + public Parent() => Instances.Add(this); + + [ScopeData] + public required Service Service { get; init; } + public int DisposeCount; + + public async ValueTask DisposeAsync() + { + await Task.Yield(); + if (++DisposeCount != 1 || Service.DisposeCount != 0) + throw new InvalidOperationException("Injected service must remain alive until its parent is disposed"); + } + } + + public sealed class Service : IDisposable + { + [ClassDataSource] + public required Dependency Dependency { get; init; } + public int DisposeCount; + public void Dispose() + { + if (++DisposeCount != 1 || Dependency.DisposeCount != 0) + throw new InvalidOperationException("Nested dependency must remain alive until its scope-owned parent is disposed"); + } + } + + public sealed class Dependency : IDisposable + { + public int DisposeCount; + public void Dispose() + { + if (++DisposeCount != 1) throw new InvalidOperationException("Dependency disposed twice"); + } + } + + public sealed class Scope : IDisposable + { + public Service? Service; + public int DisposeCount; + public void Dispose() + { + if (++DisposeCount != 1) throw new InvalidOperationException("Scope disposed twice"); + Service?.Dispose(); + } + } + + public sealed class ScopeDataAttribute : DependencyInjectionDataSourceAttribute + { + public static readonly System.Collections.Concurrent.ConcurrentBag Scopes = []; + public override Scope CreateScope(DataGeneratorMetadata metadata) + { + var scope = new Scope(); + Scopes.Add(scope); + return scope; + } + public override object Create(Scope scope, Type type) + => scope.Service = new Service { Dependency = null! }; + } + + [Test, ClassDataSource, Repeat(1), EngineTest(ExpectedResult.Pass)] + public async Task ParentAndDependenciesAreAlive(Parent parent) + { + await Assert.That(parent.DisposeCount).IsEqualTo(0); + await Assert.That(parent.Service.DisposeCount).IsEqualTo(0); + await Assert.That(parent.Service.Dependency.DisposeCount).IsEqualTo(0); + } + + [After(Class)] + public static async Task Verify() + { + await Assert.That(Parent.Instances.Count).IsEqualTo(2); + foreach (var parent in Parent.Instances) + { + await Assert.That(parent.DisposeCount).IsEqualTo(1); + await Assert.That(parent.Service.DisposeCount).IsEqualTo(1); + await Assert.That(parent.Service.Dependency.DisposeCount).IsEqualTo(1); + } + foreach (var scope in ScopeDataAttribute.Scopes) + await Assert.That(scope.DisposeCount).IsEqualTo(1); + } +} From 993e845ad05dc3acd97523cdbb5eecefef6d2866 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 00:56:15 +0000 Subject: [PATCH 08/27] fix: retain DI cleanup for skipped and failed rows (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 74 +++++++++++++------ .../SkippedScopeLifecycleTests.cs | 65 ++++++++++++++++ 2 files changed, 116 insertions(+), 23 deletions(-) create mode 100644 tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 31bb587e12f..f615948e36f 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -128,6 +128,7 @@ public async ValueTask> BuildTestsFromMetada } var tests = new List(); + TestBuilderContextAccessor? contextAccessor = null; try { @@ -194,7 +195,7 @@ public async ValueTask> BuildTestsFromMetada testBuilderContext.ClassConstructor = (IClassConstructor)Activator.CreateInstance(classConstructorAttribute.ClassConstructorType)!; } - var contextAccessor = new TestBuilderContextAccessor(testBuilderContext, publishBuilderContext); + contextAccessor = new TestBuilderContextAccessor(testBuilderContext, publishBuilderContext); // DeferEnumeration: emit a single placeholder node instead of enumerating the data source(s). // The placeholder is built during both discovery and the execution build (so it matches the @@ -275,7 +276,8 @@ public async ValueTask> BuildTestsFromMetada if (!instanceResult.Success) { - var failedTest = CreateFailedTestForInstanceDataSourceError(metadata, instanceResult.Exception!, classData); + unclaimedClassRow.TransferCleanupTo(contextAccessor.Current); + var failedTest = CreateFailedTestForInstanceDataSourceError(metadata, instanceResult.Exception!, classData, contextAccessor.Current); tests.Add(failedTest); continue; } @@ -332,7 +334,7 @@ public async ValueTask> BuildTestsFromMetada // constraints: fail this row only, as reflection mode does when it resolves // the row's type arguments, and keep building the remaining rows. var (reportedException, rowData) = UnpackConstraintViolation(ex, metadata.MethodMetadata.Parameters); - tests.Add(CreateFailedTestForDataRowError(metadata, reportedException, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), rowData)); + tests.Add(CreateFailedTestForDataRowError(metadata, reportedException, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), rowData, contextAccessor.Current)); continue; } @@ -418,7 +420,7 @@ public async ValueTask> BuildTestsFromMetada catch (Exception innerEx) { // If we still can't resolve, create a failed test - var failedTest = CreateFailedTestForDataRowError(metadata, innerEx, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), methodData); + var failedTest = CreateFailedTestForDataRowError(metadata, innerEx, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), methodData, contextAccessor.Current); tests.Add(failedTest); continue; } @@ -426,7 +428,7 @@ public async ValueTask> BuildTestsFromMetada catch (Exception ex) { // If generic resolution fails, create a failed test - var failedTest = CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), methodData); + var failedTest = CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), methodData, contextAccessor.Current); tests.Add(failedTest); continue; } @@ -521,6 +523,7 @@ public async ValueTask> BuildTestsFromMetada // The test built below holds classData, which may be the unclaimed first fetch, // and tracks any objects that a temporary instance used. var lentClassRowObjects = unclaimedClassRow.TakeLentObjects(); + unclaimedClassRow.TransferCleanupTo(contextAccessor.Current); unclaimedClassRow.Clear(); Type[] resolvedClassGenericArgs; @@ -540,7 +543,7 @@ public async ValueTask> BuildTestsFromMetada // If generic type inference failed, create a failed test instead of skipped if (genericResolutionException != null) { - var failedTest = CreateFailedTestForDataGenerationError(metadata, genericResolutionException, new TestDataCombination(), classData, lentClassRowObjects); + var failedTest = CreateFailedTestForDataGenerationError(metadata, genericResolutionException, new TestDataCombination(), classData, lentClassRowObjects, contextAccessor.Current); tests.Add(failedTest); } else @@ -571,6 +574,10 @@ public async ValueTask> BuildTestsFromMetada }; testBuilderContext.CopyStateBagTo(testSpecificContext); + if (contextAccessor.Current.EventsIfCreated?.OnDataRowDispose is { } cleanup) + { + testSpecificContext.Events.OnDataRowDispose = cleanup.Clone(); + } var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); test.Context.SkipReason = skipReason; @@ -675,7 +682,7 @@ public async ValueTask> BuildTestsFromMetada // The build context was disposed on leaving the try block; stop routing output to it. TestBuildContext.Current = null; - var failedTest = CreateFailedTestForDataGenerationError(metadata, ex); + var failedTest = CreateFailedTestForDataGenerationError(metadata, ex, new TestDataCombination(), rowContext: contextAccessor?.Current); tests.Add(failedTest); return tests; } @@ -1117,8 +1124,21 @@ public void Return(object?[] data, TestDataRowMetadata? metadata) } /// - /// Marks the unclaimed objects as held by a test that did not take them through . + /// Preserves scope cleanup when a skipped or failed test takes ownership of the row. /// + public void TransferCleanupTo(TestBuilderContext target) + { + var cleanup = _lentCleanup ?? _events?.OnDataRowDispose; + if (cleanup is null) + { + return; + } + + target.Events.OnDataRowDispose = cleanup.Clone(); + _lentCleanup = null; + } + + /// Marks the unclaimed objects as held by a test. public void Clear() { _data = null; @@ -1520,6 +1540,7 @@ private AbstractExecutableTest CreateFailedTestForDataGenerationError(TestMetada /// /// The class row's objects, if the row produced them before it failed. /// The method row's objects, if the row produced them before it failed. + /// The owning row context whose scope cleanup follows the failed test. private AbstractExecutableTest CreateFailedTestForDataRowError( TestMetadata metadata, Exception exception, @@ -1529,7 +1550,8 @@ private AbstractExecutableTest CreateFailedTestForDataRowError( int methodDataLoopIndex, int repeatIndex, object?[]? classData = null, - object?[]? methodData = null) + object?[]? methodData = null, + TestBuilderContext? rowContext = null) { return CreateFailedTestForDataGenerationError(metadata, exception, new TestDataCombination { @@ -1538,7 +1560,7 @@ private AbstractExecutableTest CreateFailedTestForDataRowError( MethodDataSourceIndex = methodDataAttributeIndex, MethodLoopIndex = methodDataLoopIndex, RepeatIndex = repeatIndex - }, classData, methodData); + }, classData, methodData, rowContext); } /// The test's metadata. @@ -1546,6 +1568,7 @@ private AbstractExecutableTest CreateFailedTestForDataRowError( /// The row's indexes, which go into the test id. /// The class row's objects, if the row produced them before it failed. /// The method row's objects, if the row produced them before it failed. + /// The owning row context whose scope cleanup follows the failed test. /// /// The failed test never receives the row's objects, but it carries them in /// , so the object tracker counts them when the test is @@ -1557,13 +1580,14 @@ private AbstractExecutableTest CreateFailedTestForDataGenerationError( Exception exception, TestDataCombination combination, object?[]? classData = null, - object?[]? methodData = null) + object?[]? methodData = null, + TestBuilderContext? rowContext = null) { exception = ToReportedException(exception); var testId = TestIdentifierService.GenerateFailedTestId(metadata, combination); var testDetails = CreateFailedTestDetails(metadata, testId, CombineRowObjects(classData, methodData)); - var context = CreateFailedTestContext(metadata, testDetails); + var context = CreateFailedTestContext(metadata, testDetails, rowContext); var now = DateTimeOffset.UtcNow; return new FailedExecutableTest(exception) @@ -1792,14 +1816,17 @@ private async ValueTask InitializeAttributesCoreAsync(Attribute[] a return attributes; } - private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails) + private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext) { + var builderContext = new TestBuilderContext { TestMetadata = metadata.MethodMetadata }; + if (rowContext?.EventsIfCreated?.OnDataRowDispose is { } cleanup) + { + builderContext.Events.OnDataRowDispose = cleanup.Clone(); + } + var context = _contextProvider.CreateTestContext( metadata.TestClassType, - new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata - }, + builderContext, testDetails, CancellationToken.None); @@ -1808,9 +1835,9 @@ private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails t - private AbstractExecutableTest CreateFailedTestForInstanceDataSourceError(TestMetadata metadata, Exception exception, object?[] classData) + private AbstractExecutableTest CreateFailedTestForInstanceDataSourceError(TestMetadata metadata, Exception exception, object?[] classData, TestBuilderContext rowContext) { - return CreateFailedTestForDataGenerationError(metadata, exception, new TestDataCombination(), classData); + return CreateFailedTestForDataGenerationError(metadata, exception, new TestDataCombination(), classData, rowContext: rowContext); } private AbstractExecutableTest CreateFailedTestForClassDataSourceCircularDependency(TestMetadata metadata) @@ -2239,8 +2266,9 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( if (!instanceResult.Success) { + unclaimedClassRow.TransferCleanupTo(contextAccessor.Current); // Yield a failed test instead of silently skipping - yield return CreateFailedTestForInstanceDataSourceError(metadata, instanceResult.Exception!, classData); + yield return CreateFailedTestForInstanceDataSourceError(metadata, instanceResult.Exception!, classData, contextAccessor.Current); continue; } @@ -2500,12 +2528,12 @@ private async Task CreateInstanceForMethodDataSources( } catch (Exception ex) { - return CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), methodData); + return CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), methodData, contextAccessor.Current); } } catch (Exception ex) { - return CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), methodData); + return CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), methodData, contextAccessor.Current); } if (metadata.TestClassType.IsGenericTypeDefinition && resolvedClassGenericArgs.Length == 0) @@ -2580,7 +2608,7 @@ private async Task CreateInstanceForMethodDataSources( // Includes a GenericConstraintViolationDataSource row whose inferred type arguments break the // method's constraints. The row's indexes keep its id distinct from the method's other rows. var (reportedException, rowData) = UnpackConstraintViolation(ex, metadata.MethodMetadata.Parameters); - return CreateFailedTestForDataRowError(metadata, reportedException, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), rowData ?? methodData); + return CreateFailedTestForDataRowError(metadata, reportedException, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), rowData ?? methodData, contextAccessor.Current); } } diff --git a/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs b/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs new file mode 100644 index 00000000000..c3bbcfc3295 --- /dev/null +++ b/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs @@ -0,0 +1,65 @@ +using System.Diagnostics.CodeAnalysis; +using TUnit.TestProject.Attributes; + +namespace TUnit.TestProject; + +[EngineTest(ExpectedResult.Pass)] +[MicrosoftDependencyInjectionDataSource] +[UnconditionalSuppressMessage("Usage", "TUnit0042:Global hooks should not be mixed with test classes to avoid confusion. Place them in their own class.")] +public class SkippedScopeLifecycleTests(MEDIClass service) +{ + public static IEnumerable NoRows() => []; + + [Test] + [MethodDataSource(nameof(NoRows), SkipIfEmpty = true)] + public void EmptySource(string value) + { + _ = service; + throw new InvalidOperationException("Must be skipped"); + } + + [After(TestSession)] + public static async Task VerifyScopeCleanup(TestSessionContext session) + { + var tests = session.TestClasses + .Where(x => x.ClassType == typeof(SkippedScopeLifecycleTests)) + .SelectMany(x => x.Tests) + .Where(x => x.Execution.Result != null) + .ToArray(); + + foreach (var test in tests) + { + var argument = test.Metadata.TestDetails.TestClassArguments.OfType().Single(); + await Assert.That(argument.DisposeCount).IsEqualTo(1); + } + } +} + +[EngineTest(ExpectedResult.Failure)] +[MicrosoftDependencyInjectionDataSource] +[UnconditionalSuppressMessage("Usage", "TUnit0042:Global hooks should not be mixed with test classes to avoid confusion. Place them in their own class.")] +public class FailedScopeLifecycleTests +{ + private static MEDIClass? _service; + + public FailedScopeLifecycleTests(MEDIClass service) + { + _service = service; + throw new InvalidOperationException("Intentional constructor failure"); + } + + public IEnumerable Rows() => ["row"]; + + [Test] + [InstanceMethodDataSource(nameof(Rows))] + public void FailedInstance(string value) => throw new InvalidOperationException("Must not execute"); + + [After(TestSession)] + public static async Task VerifyScopeCleanup() + { + if (_service is { } service) + { + await Assert.That(service.DisposeCount).IsEqualTo(1); + } + } +} From c9d5e82135ad71df62a17ef5eda64d34788df760 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:05:53 +0000 Subject: [PATCH 09/27] fix: preserve row cleanup ownership and retry cancellation (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 26 ++++-- .../Services/TestExecution/RetryHelper.cs | 17 +++- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 88 +++++++++++++++++++ .../RetryDelegateCancellationTests.cs | 71 +++++++++++++++ 4 files changed, 193 insertions(+), 9 deletions(-) create mode 100644 tests/TUnit.UnitTests/ClassRowCleanupTests.cs create mode 100644 tests/TUnit.UnitTests/RetryDelegateCancellationTests.cs diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index f615948e36f..48bffc099b0 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -523,7 +523,7 @@ public async ValueTask> BuildTestsFromMetada // The test built below holds classData, which may be the unclaimed first fetch, // and tracks any objects that a temporary instance used. var lentClassRowObjects = unclaimedClassRow.TakeLentObjects(); - unclaimedClassRow.TransferCleanupTo(contextAccessor.Current); + var rowCleanup = unclaimedClassRow.TakeCleanup(); unclaimedClassRow.Clear(); Type[] resolvedClassGenericArgs; @@ -543,6 +543,10 @@ public async ValueTask> BuildTestsFromMetada // If generic type inference failed, create a failed test instead of skipped if (genericResolutionException != null) { + if (rowCleanup is not null) + { + contextAccessor.Current.Events.OnDataRowDispose = rowCleanup.Clone(); + } var failedTest = CreateFailedTestForDataGenerationError(metadata, genericResolutionException, new TestDataCombination(), classData, lentClassRowObjects, contextAccessor.Current); tests.Add(failedTest); } @@ -574,7 +578,7 @@ public async ValueTask> BuildTestsFromMetada }; testBuilderContext.CopyStateBagTo(testSpecificContext); - if (contextAccessor.Current.EventsIfCreated?.OnDataRowDispose is { } cleanup) + if (rowCleanup is { } cleanup) { testSpecificContext.Events.OnDataRowDispose = cleanup.Clone(); } @@ -1064,7 +1068,7 @@ public ValueTask MoveNextAsync() /// are lent to the instance instead, and the next test built from the row tracks them without /// receiving them, so they are still disposed. /// - private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rowContext) + internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rowContext) { private object?[]? _data = data; private TestDataRowMetadata? _metadata = metadata; @@ -1096,9 +1100,8 @@ private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? meta async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory, TestBuilderContext target) { - var row = DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); - // The temporary instance used a different scope. Keep its cleanup even when - // this fetch replaces the original class row's event snapshot. + // Transfer the temporary instance's scope before invoking a factory that may + // throw, so failed-row cleanup can still release that scope. if (_lentCleanup is { } lentCleanup) { foreach (var handler in lentCleanup.InvocationList) @@ -1107,6 +1110,7 @@ private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? meta } _lentCleanup = null; } + var row = DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); _rowContext = target with { }; target.CopyStateBagTo(_rowContext); _events = target.EventsIfCreated?.Clone(); @@ -1128,14 +1132,22 @@ public void Return(object?[] data, TestDataRowMetadata? metadata) /// public void TransferCleanupTo(TestBuilderContext target) { - var cleanup = _lentCleanup ?? _events?.OnDataRowDispose; + var cleanup = TakeCleanup(); if (cleanup is null) { return; } target.Events.OnDataRowDispose = cleanup.Clone(); + } + + public AsyncEvent<(TestContext Context, object? Object)>? TakeCleanup() + { + // A claimed row already belongs to a runnable test. Never copy its cleanup + // to a later empty source, which may finish before that test. + var cleanup = _lentCleanup ?? (_data is not null ? _events?.OnDataRowDispose : null); _lentCleanup = null; + return cleanup; } /// Marks the unclaimed objects as held by a test. diff --git a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs index 7e5861dad87..89d9833191f 100644 --- a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs +++ b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs @@ -111,9 +111,22 @@ public static async Task ExecuteWithRetry(TestContext testContext, Func + { + disposals++; + return default; + }; + var row = new TestBuilder.UnclaimedClassRow([new object()], null, original); + var runnable = CreateContext(); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must use saved row"), runnable); + + var skipped = CreateContext(); + row.TransferCleanupTo(skipped); + await DisposeRow(skipped); + await Assert.That(disposals).IsEqualTo(0); + await DisposeRow(runnable); + await Assert.That(disposals).IsEqualTo(1); + } + + [Test] + public async Task UnclaimedRowTransfersCleanupToSkippedTest() + { + var original = CreateContext(); + var disposals = 0; + original.Events.OnDataRowDispose += (_, _) => + { + disposals++; + return default; + }; + var row = new TestBuilder.UnclaimedClassRow([new object()], null, original); + var skipped = CreateContext(); + row.TransferCleanupTo(skipped); + row.Clear(); + await DisposeRow(skipped); + await Assert.That(disposals).IsEqualTo(1); + } + + [Test] + public async Task LentRowTransfersCleanupEvenWhenNextFactoryThrows() + { + var original = CreateContext(); + var disposals = 0; + original.Events.OnDataRowDispose += (_, _) => + { + disposals++; + return default; + }; + var row = new TestBuilder.UnclaimedClassRow([new object()], null, original); + row.LendToTemporaryInstance(); + var failed = CreateContext(); + await Assert.That(async () => await row.TakeOrFetchAsync( + () => throw new InvalidOperationException("Factory failure"), failed)) + .Throws(); + + await DisposeRow(failed); + await Assert.That(disposals).IsEqualTo(1); + var later = CreateContext(); + row.TransferCleanupTo(later); + await DisposeRow(later); + await Assert.That(disposals).IsEqualTo(1); + } + + private static TestBuilderContext CreateContext() => new() + { + TestMetadata = TestContext.Current!.TestDetails.MethodMetadata + }; + + private static async Task DisposeRow(TestBuilderContext context) + { + if (context.EventsIfCreated?.OnDataRowDispose is { } cleanup) + { + foreach (var handler in cleanup.InvocationList) + { + await handler.InvokeAsync(TestContext.Current!, (TestContext.Current!, null)); + } + } + } +} diff --git a/tests/TUnit.UnitTests/RetryDelegateCancellationTests.cs b/tests/TUnit.UnitTests/RetryDelegateCancellationTests.cs new file mode 100644 index 00000000000..e01d0f2584a --- /dev/null +++ b/tests/TUnit.UnitTests/RetryDelegateCancellationTests.cs @@ -0,0 +1,71 @@ +using TUnit.Core; +using TUnit.Engine.Services.TestExecution; + +namespace TUnit.UnitTests; + +public class RetryDelegateCancellationTests +{ + [Test] + [Arguments(true)] + [Arguments(false)] + public async Task FailingRetryHandlerCompletesCancellation(bool requestCancellation) + { + var current = TestContext.Current!; + var builder = new TestBuilderContext { TestMetadata = current.TestDetails.MethodMetadata }; + var context = new TestContext(nameof(RetryDelegateCancellationTests), current.ServiceProvider, + current.ClassContext, builder, CancellationToken.None); + context.Metadata.TestDetails = new TestDetails([]) + { + TestId = context.Id, TestName = "Retry", ClassType = typeof(RetryDelegateCancellationTests), + MethodName = "Retry", ClassInstance = this, TestMethodArguments = [], TestClassArguments = [], + MethodMetadata = current.TestDetails.MethodMetadata, ReturnType = typeof(void), RetryLimit = 1, + AttributesByType = new Dictionary>() + }; + var executable = new StubExecutableTest { TestId = context.Id, Arguments = [], Context = context }; + context.InitializeTestCancellation(CancellationToken.None); + context.CompleteTestCancellation(); + var failure = new InvalidOperationException("Retry handler failure"); + builder.Events.OnTestRetry += (_, _) => + { + if (requestCancellation) + { + context.Cancel(); + } + throw failure; + }; + var attempts = 0; + try + { + async Task Execute() => await RetryHelper.ExecuteWithRetry(context, () => + { + attempts++; + throw new InvalidOperationException("Attempt failure"); + }); + + if (requestCancellation) + { + await Execute(); + await Assert.That(executable.State).IsEqualTo(TestState.Cancelled); + } + else + { + var thrown = await Assert.That(Execute).Throws(); + await Assert.That(thrown).IsSameReferenceAs(failure); + context.Cancel(); + await Assert.That(context.IsTestCancellationRequested).IsFalse(); + } + await Assert.That(attempts).IsEqualTo(1); + } + finally + { + context.DisposeLinkedCancellationTokenSources(); + context.RemoveFromRegistry(); + } + } + + private sealed class StubExecutableTest : AbstractExecutableTest + { + public override Task CreateInstanceAsync() => throw new NotSupportedException(); + public override Task InvokeTestAsync(object instance, CancellationToken cancellationToken) => throw new NotSupportedException(); + } +} From 02d10901b877e96778c172e8eccb04ed38bbaea1 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:13:46 +0000 Subject: [PATCH 10/27] fix: keep claimed scope cleanup off enumeration failures (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 24 +++++++++++++++++ tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 27 +++++++++++++++++++ 2 files changed, 51 insertions(+) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 48bffc099b0..1f875042bbc 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -256,6 +256,7 @@ public async ValueTask> BuildTestsFromMetada var needsInstanceForMethodDataSources = HasInstanceDataAccessor(metadata.DataSources); + var classEnumerationContext = contextAccessor.Current; object? instanceForMethodDataSources = null; try { @@ -590,6 +591,20 @@ public async ValueTask> BuildTestsFromMetada } } } + catch (Exception ex) + { + // Enumeration may resume on a context whose class cleanup already belongs + // to a runnable row. Only the unclaimed row may lend cleanup to this failure. + var failureContext = ReferenceEquals(contextAccessor.Current, classEnumerationContext) + ? unclaimedClassRow.CreateEnumerationFailureContext(classEnumerationContext) + : contextAccessor.Current; + contextAccessor.Current = failureContext; + var failedTest = CreateFailedTestForDataGenerationError(metadata, ex, + new TestDataCombination(), methodData: unclaimedClassRow.TakeLentObjects(), + rowContext: failureContext); + tests.Add(failedTest); + return tests; + } finally { await DisposeInstanceForMethodDataSourcesAsync(instanceForMethodDataSources); @@ -1141,6 +1156,15 @@ public void TransferCleanupTo(TestBuilderContext target) target.Events.OnDataRowDispose = cleanup.Clone(); } + internal TestBuilderContext CreateEnumerationFailureContext(TestBuilderContext enumerationContext) + { + var failureContext = enumerationContext with { }; + enumerationContext.CopyStateBagTo(failureContext); + failureContext.Events = enumerationContext.EventsIfCreated?.Clone() ?? new(); + failureContext.Events.OnDataRowDispose = TakeCleanup()?.Clone(); + return failureContext; + } + public AsyncEvent<(TestContext Context, object? Object)>? TakeCleanup() { // A claimed row already belongs to a runnable test. Never copy its cleanup diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index d834401afc3..8a6eb631d8b 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -70,6 +70,33 @@ await Assert.That(async () => await row.TakeOrFetchAsync( await Assert.That(disposals).IsEqualTo(1); } + [Test] + [Arguments(true)] + [Arguments(false)] + public async Task EnumerationFailureOnlyDisposesUnclaimedClassScope(bool claimed) + { + var enumeration = CreateContext(); + var disposals = 0; + enumeration.Events.OnDataRowDispose += (_, _) => + { + disposals++; + return default; + }; + var row = new TestBuilder.UnclaimedClassRow([new object()], null, enumeration); + var runnable = CreateContext(); + if (claimed) + { + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must use saved row"), runnable); + } + + // MoveNext throws after yielding a row (or before yielding any rows). + var failed = row.CreateEnumerationFailureContext(enumeration); + await DisposeRow(failed); + await Assert.That(disposals).IsEqualTo(claimed ? 0 : 1); + await DisposeRow(runnable); + await Assert.That(disposals).IsEqualTo(1); + } + private static TestBuilderContext CreateContext() => new() { TestMetadata = TestContext.Current!.TestDetails.MethodMetadata From 0c27ce0fcdc9d636669bb3f56a937270f88a517e Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:22:46 +0000 Subject: [PATCH 11/27] fix: guard class iterator failure cleanup ownership (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 25 ++++- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 96 ++++++++++++++++++- 2 files changed, 119 insertions(+), 2 deletions(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 1f875042bbc..81df2bc2949 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -129,6 +129,7 @@ public async ValueTask> BuildTestsFromMetada var tests = new List(); TestBuilderContextAccessor? contextAccessor = null; + UnclaimedClassRow? activeClassRow = null; try { @@ -210,6 +211,7 @@ public async ValueTask> BuildTestsFromMetada var classDataAttributeIndex = 0; foreach (var classDataSource in await GetDataSourcesAsync(metadata.ClassDataSources, cancellationToken)) { + activeClassRow = null; classDataAttributeIndex++; var classDataLoopIndex = 0; @@ -237,12 +239,15 @@ public async ValueTask> BuildTestsFromMetada }; testBuilderContext.CopyStateBagTo(contextAccessor.Current); + // A new factory owns its own cleanup, even if it throws before producing a row. + activeClassRow = null; var (classData, firstClassRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); // No test holds this first fetch yet. The first test built from this class row takes it // instead of calling the factory again, so a non-shared source does not create an extra // instance that nothing tracks or disposes (#7157). var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current); + activeClassRow = unclaimedClassRow; #if NET // Register scope for class data objects from the simple path. @@ -701,7 +706,15 @@ public async ValueTask> BuildTestsFromMetada // The build context was disposed on leaving the try block; stop routing output to it. TestBuildContext.Current = null; - var failedTest = CreateFailedTestForDataGenerationError(metadata, ex, new TestDataCombination(), rowContext: contextAccessor?.Current); + // Class-source MoveNext runs outside the per-class-row catch. Its context can + // still carry cleanup already claimed by a runnable row. + var failureContext = contextAccessor?.Current; + if (activeClassRow is not null && failureContext is not null) + { + failureContext = activeClassRow.CreateFailureContext(failureContext); + } + var failedTest = CreateFailedTestForDataGenerationError(metadata, ex, new TestDataCombination(), + methodData: activeClassRow?.TakeLentObjects(), rowContext: failureContext); tests.Add(failedTest); return tests; } @@ -1089,6 +1102,7 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met private TestDataRowMetadata? _metadata = metadata; private object?[]? _lent; private AsyncEvent<(TestContext Context, object? Object)>? _lentCleanup; + private readonly TestBuilderContext _enumerationContext = rowContext; private TestBuilderContext _rowContext = rowContext; // Snapshot before any method factory can mutate the class subscriptions. private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); @@ -1156,6 +1170,15 @@ public void TransferCleanupTo(TestBuilderContext target) target.Events.OnDataRowDispose = cleanup.Clone(); } + internal TestBuilderContext CreateFailureContext(TestBuilderContext currentContext) + { + // A separate factory context owns its callbacks, including callbacks added + // before a factory failure. Only the saved enumeration context needs filtering. + return ReferenceEquals(currentContext, _enumerationContext) + ? CreateEnumerationFailureContext(currentContext) + : currentContext; + } + internal TestBuilderContext CreateEnumerationFailureContext(TestBuilderContext enumerationContext) { var failureContext = enumerationContext with { }; diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 8a6eb631d8b..9a4e9ed0913 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -1,5 +1,6 @@ using TUnit.Core; using TUnit.Engine.Building; +using TUnit.Engine.Building.Interfaces; namespace TUnit.UnitTests; @@ -90,13 +91,106 @@ public async Task EnumerationFailureOnlyDisposesUnclaimedClassScope(bool claimed } // MoveNext throws after yielding a row (or before yielding any rows). - var failed = row.CreateEnumerationFailureContext(enumeration); + var failed = row.CreateFailureContext(enumeration); await DisposeRow(failed); await Assert.That(disposals).IsEqualTo(claimed ? 0 : 1); await DisposeRow(runnable); await Assert.That(disposals).IsEqualTo(1); } + [Test] + public async Task ClassEnumerationFailurePreservesSeparateFactoryCleanup() + { + var enumeration = CreateContext(); + var row = new TestBuilder.UnclaimedClassRow([new object()], null, enumeration); + var factoryContext = CreateContext(); + var disposals = 0; + factoryContext.Events.OnDataRowDispose += (_, _) => + { + disposals++; + return default; + }; + + var failed = row.CreateFailureContext(factoryContext); + await DisposeRow(failed); + await Assert.That(disposals).IsEqualTo(1); + } + + [Test] + public async Task ClassIteratorFailureDoesNotDisposeRunnableScope() + { + var current = TestContext.Current!; + var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; + var source = new ThrowingClassSource(); + var metadata = new TestMetadata + { + TestClassType = typeof(ClassRowCleanupTests), + TestMethodName = nameof(ClassIteratorFailureDoesNotDisposeRunnableScope), + TestName = "Class iterator failure regression", + FilePath = "Unknown", + LineNumber = 0, + AttributeFactory = () => [], + MethodMetadata = current.TestDetails.MethodMetadata, + DataSources = [], + ClassDataSources = [source], + PropertyDataSources = [], + InstanceFactory = (_, _) => new ClassRowCleanupTests(), + InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask + }; + + var tests = (await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))).ToArray(); + try + { + await Assert.That(tests.Length).IsEqualTo(2); + await Assert.That(tests[1].Result!.Exception!.Message).IsEqualTo("Class iterator failure"); + await DisposeTestRow(tests[1].Context); + await Assert.That(source.Disposals).IsEqualTo(0); + await DisposeTestRow(tests[0].Context); + await Assert.That(source.Disposals).IsEqualTo(1); + } + finally + { + foreach (var test in tests) + { + test.Context.RemoveFromRegistry(); + test.Context.Dispose(); + } + } + } + + private sealed class ThrowingClassSource : Attribute, IDataSourceAttribute + { + public int Disposals; + public bool SkipIfEmpty { get; set; } + public bool DeferEnumeration { get; set; } + + public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata) + { + await Task.CompletedTask; + yield return () => + { + metadata.TestBuilderContext.Current.Events.OnDataRowDispose += (_, _) => + { + Disposals++; + return default; + }; + return Task.FromResult([new object()]); + }; + throw new InvalidOperationException("Class iterator failure"); + } + } + + private static async Task DisposeTestRow(TestContext context) + { + if (context.InternalEventsIfCreated?.OnDataRowDispose is { } cleanup) + { + foreach (var handler in cleanup.InvocationList) + { + await handler.InvokeAsync(context, (context, null)); + } + } + } + private static TestBuilderContext CreateContext() => new() { TestMetadata = TestContext.Current!.TestDetails.MethodMetadata From 4d8ad3df27d1669caed38746c7e312211d4cb3b1 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:28:06 +0000 Subject: [PATCH 12/27] fix: isolate class source and constructor factory contexts (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 36 +++++- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 104 +++++++++++++++++- 2 files changed, 132 insertions(+), 8 deletions(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 81df2bc2949..4302971d061 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -212,6 +212,14 @@ public async ValueTask> BuildTestsFromMetada foreach (var classDataSource in await GetDataSourcesAsync(metadata.ClassDataSources, cancellationToken)) { activeClassRow = null; + contextAccessor.Current = new TestBuilderContext + { + TestMetadata = metadata.MethodMetadata, + InitializedAttributes = attributes, + ClassConstructor = testBuilderContext.ClassConstructor, + ClassDataSourceAttribute = classDataSource + }; + testBuilderContext.CopyStateBagTo(contextAccessor.Current); classDataAttributeIndex++; var classDataLoopIndex = 0; @@ -241,12 +249,22 @@ public async ValueTask> BuildTestsFromMetada // A new factory owns its own cleanup, even if it throws before producing a row. activeClassRow = null; + // Keep constructor-factory state on its saved row, outside the enumeration baseline. + var classRowEnumerationContext = new TestBuilderContext + { + TestMetadata = metadata.MethodMetadata, + InitializedAttributes = attributes, + ClassConstructor = contextAccessor.Current.ClassConstructor, + ClassDataSourceAttribute = classDataSource + }; + contextAccessor.Current.CopyStateBagTo(classRowEnumerationContext); var (classData, firstClassRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); // No test holds this first fetch yet. The first test built from this class row takes it // instead of calling the factory again, so a non-shared source does not create an extra // instance that nothing tracks or disposes (#7157). - var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current); + var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current, classRowEnumerationContext); + contextAccessor.Current = classRowEnumerationContext; activeClassRow = unclaimedClassRow; #if NET @@ -1096,13 +1114,13 @@ public ValueTask MoveNextAsync() /// are lent to the instance instead, and the next test built from the row tracks them without /// receiving them, so they are still disposed. /// - internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rowContext) + internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rowContext, TestBuilderContext? enumerationContext = null) { private object?[]? _data = data; private TestDataRowMetadata? _metadata = metadata; private object?[]? _lent; private AsyncEvent<(TestContext Context, object? Object)>? _lentCleanup; - private readonly TestBuilderContext _enumerationContext = rowContext; + private readonly TestBuilderContext _enumerationContext = enumerationContext ?? rowContext; private TestBuilderContext _rowContext = rowContext; // Snapshot before any method factory can mutate the class subscriptions. private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); @@ -2293,11 +2311,21 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( }; baseContext.CopyStateBagTo(contextAccessor.Current); + // Keep constructor-factory state on its saved row, outside the enumeration baseline. + var classRowEnumerationContext = new TestBuilderContext + { + TestMetadata = metadata.MethodMetadata, + InitializedAttributes = attributes, + ClassConstructor = contextAccessor.Current.ClassConstructor, + ClassDataSourceAttribute = classDataSource + }; + contextAccessor.Current.CopyStateBagTo(classRowEnumerationContext); var (classData, firstClassRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); // The first test built from this class row takes this fetch instead of calling the factory // again, so a non-shared source does not create an extra, untracked instance (#7157). - var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current); + var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current, classRowEnumerationContext); + contextAccessor.Current = classRowEnumerationContext; // Initialize objects before method data sources are evaluated (ObjectInitializer is phase-aware) await InitializeClassDataAsync(classData); diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 9a4e9ed0913..a6592e6c02b 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -117,11 +117,13 @@ public async Task ClassEnumerationFailurePreservesSeparateFactoryCleanup() } [Test] - public async Task ClassIteratorFailureDoesNotDisposeRunnableScope() + [Arguments(false)] + [Arguments(true)] + public async Task ClassIteratorFailureDoesNotDisposeRunnableScope(bool laterSource) { var current = TestContext.Current!; var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; - var source = new ThrowingClassSource(); + var source = new ThrowingClassSource { ThrowAfterRow = !laterSource }; var metadata = new TestMetadata { TestClassType = typeof(ClassRowCleanupTests), @@ -132,7 +134,7 @@ public async Task ClassIteratorFailureDoesNotDisposeRunnableScope() AttributeFactory = () => [], MethodMetadata = current.TestDetails.MethodMetadata, DataSources = [], - ClassDataSources = [source], + ClassDataSources = laterSource ? [source, new ThrowingBeforeRowSource()] : [source], PropertyDataSources = [], InstanceFactory = (_, _) => new ClassRowCleanupTests(), InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask @@ -161,6 +163,7 @@ public async Task ClassIteratorFailureDoesNotDisposeRunnableScope() private sealed class ThrowingClassSource : Attribute, IDataSourceAttribute { public int Disposals; + public bool ThrowAfterRow = true; public bool SkipIfEmpty { get; set; } public bool DeferEnumeration { get; set; } @@ -176,7 +179,100 @@ private sealed class ThrowingClassSource : Attribute, IDataSourceAttribute }; return Task.FromResult([new object()]); }; - throw new InvalidOperationException("Class iterator failure"); + if (ThrowAfterRow) + { + throw new InvalidOperationException("Class iterator failure"); + } + } + } + + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task ConstructorFactoryStateIsIsolatedAcrossRepeats(bool streaming) + { + var current = TestContext.Current!; + var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; + var source = new StatefulConstructorSource(); + var metadata = new TestMetadata + { + TestClassType = typeof(ClassRowCleanupTests), + TestMethodName = nameof(ConstructorFactoryStateIsIsolatedAcrossRepeats), + TestName = "Constructor factory state regression", + FilePath = "Unknown", + LineNumber = 0, + AttributeFactory = () => [], + MethodMetadata = current.TestDetails.MethodMetadata, + RepeatCount = 2, + DataSources = [], + ClassDataSources = [source], + PropertyDataSources = [], + InstanceFactory = (_, _) => new ClassRowCleanupTests(), + InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask + }; + var tests = new List(); + try + { + if (streaming) + { + await foreach (var test in builder.BuildTestsStreamingAsync(metadata)) + { + tests.Add(test); + } + } + else + { + tests.AddRange(await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))); + } + await Assert.That(tests.Count).IsEqualTo(3); + await Assert.That(source.Resources.Count).IsEqualTo(3); + for (var i = 0; i < tests.Count; i++) + { + await Assert.That(tests[i].Result?.Exception).IsNull(); + await Assert.That(ReferenceEquals(tests[i].Context.StateBag.Items["resource"], source.Resources[i])).IsTrue(); + } + } + finally + { + foreach (var test in tests) + { + test.Context.RemoveFromRegistry(); + test.Context.Dispose(); + } + } + } + + private sealed class StatefulConstructorSource : Attribute, IDataSourceAttribute + { + public readonly List Resources = []; + public bool SkipIfEmpty { get; set; } + public bool DeferEnumeration { get; set; } + + public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata) + { + await Task.CompletedTask; + yield return () => + { + var resource = new object(); + if (!metadata.TestBuilderContext.Current.StateBag.TryAdd("resource", resource)) + { + throw new InvalidOperationException("Constructor factory inherited another row's resource"); + } + Resources.Add(resource); + return Task.FromResult([resource]); + }; + } + } + + private sealed class ThrowingBeforeRowSource : Attribute, IDataSourceAttribute + { + public bool SkipIfEmpty { get; set; } + public bool DeferEnumeration { get; set; } + + public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata) + { + await Task.FromException(new InvalidOperationException("Class iterator failure")); + yield break; } } From 44e3b817ee38188efeac0eafd6662a1644135deb Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:43:11 +0000 Subject: [PATCH 13/27] fix: preserve enumeration state across class factories (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 26 ++++- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 98 +++++++++++++++++++ 2 files changed, 121 insertions(+), 3 deletions(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 4302971d061..60ae54b2f3a 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -220,6 +220,7 @@ public async ValueTask> BuildTestsFromMetada ClassDataSourceAttribute = classDataSource }; testBuilderContext.CopyStateBagTo(contextAccessor.Current); + var classSourceContext = contextAccessor.Current; classDataAttributeIndex++; var classDataLoopIndex = 0; @@ -245,7 +246,7 @@ public async ValueTask> BuildTestsFromMetada ClassConstructor = testBuilderContext.ClassConstructor, ClassDataSourceAttribute = classDataSource }; - testBuilderContext.CopyStateBagTo(contextAccessor.Current); + classSourceContext.CopyStateBagTo(contextAccessor.Current); // A new factory owns its own cleanup, even if it throws before producing a row. activeClassRow = null; @@ -631,6 +632,7 @@ public async ValueTask> BuildTestsFromMetada finally { await DisposeInstanceForMethodDataSourcesAsync(instanceForMethodDataSources); + contextAccessor.Current = classSourceContext; } } @@ -1133,7 +1135,15 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met { if (_data is { } data) { - _rowContext.CopyStateBagTo(context); + // The target already holds method-enumeration state. Add saved constructor + // state without replacing that baseline (or its newer values). + if (_rowContext.HasStateBag) + { + foreach (var entry in _rowContext.StateBag) + { + context.StateBag.TryAdd(entry.Key, entry.Value); + } + } if (_events is { } savedEvents) { context.Events = savedEvents.Clone(); @@ -2287,6 +2297,15 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( var classDataAttributeIndex = 0; foreach (var classDataSource in await GetDataSourcesAsync(metadata.ClassDataSources, cancellationToken)) { + var classSourceContext = new TestBuilderContext + { + TestMetadata = metadata.MethodMetadata, + InitializedAttributes = attributes, + ClassConstructor = baseContext.ClassConstructor, + ClassDataSourceAttribute = classDataSource + }; + baseContext.CopyStateBagTo(classSourceContext); + contextAccessor.Current = classSourceContext; classDataAttributeIndex++; var classDataLoopIndex = 0; @@ -2309,7 +2328,7 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( ClassConstructor = baseContext.ClassConstructor, ClassDataSourceAttribute = classDataSource }; - baseContext.CopyStateBagTo(contextAccessor.Current); + classSourceContext.CopyStateBagTo(contextAccessor.Current); // Keep constructor-factory state on its saved row, outside the enumeration baseline. var classRowEnumerationContext = new TestBuilderContext @@ -2420,6 +2439,7 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( finally { await DisposeInstanceForMethodDataSourcesAsync(instanceForMethodDataSources); + contextAccessor.Current = classSourceContext; } } } diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index a6592e6c02b..68c169932aa 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -242,6 +242,104 @@ public async Task ConstructorFactoryStateIsIsolatedAcrossRepeats(bool streaming) } } + [Test] + [Arguments(false, false)] + [Arguments(false, true)] + [Arguments(true, false)] + [Arguments(true, true)] + public async Task ClassAndMethodEnumerationStateSurvivesFactories(bool streaming, bool classEnumeration) + { + var current = TestContext.Current!; + var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; + var metadata = new TestMetadata + { + TestClassType = typeof(ClassRowCleanupTests), + TestMethodName = nameof(ClassAndMethodEnumerationStateSurvivesFactories), + TestName = "Enumeration state regression", + FilePath = "Unknown", + LineNumber = 0, + AttributeFactory = () => [], + MethodMetadata = current.TestDetails.MethodMetadata, + RepeatCount = 1, + DataSources = [new EnumerationStateSource(false)], + ClassDataSources = [new EnumerationStateSource(true, classEnumeration)], + PropertyDataSources = [], + InstanceFactory = (_, _) => new ClassRowCleanupTests(), + InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask + }; + var tests = new List(); + try + { + if (streaming) + { + await foreach (var test in builder.BuildTestsStreamingAsync(metadata)) + { + tests.Add(test); + } + } + else + { + tests.AddRange(await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))); + } + + await Assert.That(tests.Count).IsEqualTo(4); + foreach (var test in tests) + { + await Assert.That(test.Result?.Exception).IsNull(); + if (classEnumeration) + { + await Assert.That(test.Context.StateBag.Items["class-enumeration"]).IsEqualTo(test.Context.StateBag.Items["class-factory"]); + } + await Assert.That(test.Context.StateBag.Items["method-enumeration"]).IsEqualTo(test.Context.StateBag.Items["method-factory"]); + } + } + finally + { + foreach (var test in tests) + { + test.Context.RemoveFromRegistry(); + test.Context.Dispose(); + } + } + } + + private sealed class EnumerationStateSource(bool constructor, bool enumerationState = true) : Attribute, IDataSourceAttribute + { + public bool SkipIfEmpty { get; set; } + public bool DeferEnumeration { get; set; } + + public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata) + { + await Task.CompletedTask; + var prefix = constructor ? "class" : "method"; + for (var i = 0; i < (constructor ? 2 : 1); i++) + { + var value = new object(); + if (enumerationState) + { + metadata.TestBuilderContext.Current.StateBag[prefix + "-enumeration"] = value; + } + yield return () => + { + var state = metadata.TestBuilderContext.Current.StateBag; + if (enumerationState && !ReferenceEquals(state[prefix + "-enumeration"], value)) + { + throw new InvalidOperationException("Enumeration state belongs to another row"); + } + if (!state.TryAdd(prefix + "-factory", value)) + { + throw new InvalidOperationException("Factory state leaked into enumeration"); + } + return Task.FromResult([value]); + }; + if (metadata.TestBuilderContext.Current.StateBag.ContainsKey(prefix + "-factory")) + { + throw new InvalidOperationException("Factory state leaked when enumeration resumed"); + } + } + } + } + private sealed class StatefulConstructorSource : Attribute, IDataSourceAttribute { public readonly List Resources = []; From d7b2518c59c7cd626c1194a5cd0bf4c25b367947 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 01:56:58 +0000 Subject: [PATCH 14/27] fix: retain constructor updates and unclaimed cleanup (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 17 ++++++-- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 42 +++++++++++++++---- 2 files changed, 46 insertions(+), 13 deletions(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 60ae54b2f3a..1503de864a8 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -731,7 +731,7 @@ public async ValueTask> BuildTestsFromMetada var failureContext = contextAccessor?.Current; if (activeClassRow is not null && failureContext is not null) { - failureContext = activeClassRow.CreateFailureContext(failureContext); + failureContext = activeClassRow.CreateEnumerationFailureContext(failureContext); } var failedTest = CreateFailedTestForDataGenerationError(metadata, ex, new TestDataCombination(), methodData: activeClassRow?.TakeLentObjects(), rowContext: failureContext); @@ -1135,13 +1135,22 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met { if (_data is { } data) { - // The target already holds method-enumeration state. Add saved constructor - // state without replacing that baseline (or its newer values). + // Keep method-enumeration state, but replay constructor-factory updates + // to inherited keys as well as newly added constructor state. if (_rowContext.HasStateBag) { foreach (var entry in _rowContext.StateBag) { - context.StateBag.TryAdd(entry.Key, entry.Value); + if (!_enumerationContext.HasStateBag + || !_enumerationContext.StateBag.TryGetValue(entry.Key, out var inherited) + || !ReferenceEquals(inherited, entry.Value)) + { + context.StateBag[entry.Key] = entry.Value; + } + else + { + context.StateBag.TryAdd(entry.Key, entry.Value); + } } } if (_events is { } savedEvents) diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 68c169932aa..72f5630c77d 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -117,9 +117,10 @@ public async Task ClassEnumerationFailurePreservesSeparateFactoryCleanup() } [Test] - [Arguments(false)] - [Arguments(true)] - public async Task ClassIteratorFailureDoesNotDisposeRunnableScope(bool laterSource) + [Arguments(false, false)] + [Arguments(true, false)] + [Arguments(false, true)] + public async Task ClassIteratorFailureDoesNotDisposeRunnableScope(bool laterSource, bool emptyMethodSource) { var current = TestContext.Current!; var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; @@ -133,7 +134,7 @@ public async Task ClassIteratorFailureDoesNotDisposeRunnableScope(bool laterSour LineNumber = 0, AttributeFactory = () => [], MethodMetadata = current.TestDetails.MethodMetadata, - DataSources = [], + DataSources = emptyMethodSource ? [new EmptySource()] : [], ClassDataSources = laterSource ? [source, new ThrowingBeforeRowSource()] : [source], PropertyDataSources = [], InstanceFactory = (_, _) => new ClassRowCleanupTests(), @@ -143,11 +144,14 @@ public async Task ClassIteratorFailureDoesNotDisposeRunnableScope(bool laterSour var tests = (await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))).ToArray(); try { - await Assert.That(tests.Length).IsEqualTo(2); - await Assert.That(tests[1].Result!.Exception!.Message).IsEqualTo("Class iterator failure"); - await DisposeTestRow(tests[1].Context); - await Assert.That(source.Disposals).IsEqualTo(0); - await DisposeTestRow(tests[0].Context); + await Assert.That(tests.Length).IsEqualTo(emptyMethodSource ? 1 : 2); + await Assert.That(tests[^1].Result!.Exception!.Message).IsEqualTo("Class iterator failure"); + await DisposeTestRow(tests[^1].Context); + await Assert.That(source.Disposals).IsEqualTo(emptyMethodSource ? 1 : 0); + if (!emptyMethodSource) + { + await DisposeTestRow(tests[0].Context); + } await Assert.That(source.Disposals).IsEqualTo(1); } finally @@ -160,6 +164,17 @@ public async Task ClassIteratorFailureDoesNotDisposeRunnableScope(bool laterSour } } + private sealed class EmptySource : Attribute, IDataSourceAttribute + { + public bool SkipIfEmpty { get; set; } + public bool DeferEnumeration { get; set; } + public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata) + { + await Task.CompletedTask; + yield break; + } + } + private sealed class ThrowingClassSource : Attribute, IDataSourceAttribute { public int Disposals; @@ -286,6 +301,7 @@ public async Task ClassAndMethodEnumerationStateSurvivesFactories(bool streaming foreach (var test in tests) { await Assert.That(test.Result?.Exception).IsNull(); + await Assert.That(test.Context.StateBag.Items["overwritten"]).IsEqualTo(test.Context.StateBag.Items["class-factory"]); if (classEnumeration) { await Assert.That(test.Context.StateBag.Items["class-enumeration"]).IsEqualTo(test.Context.StateBag.Items["class-factory"]); @@ -319,6 +335,10 @@ private sealed class EnumerationStateSource(bool constructor, bool enumerationSt { metadata.TestBuilderContext.Current.StateBag[prefix + "-enumeration"] = value; } + if (constructor) + { + metadata.TestBuilderContext.Current.StateBag["overwritten"] = new object(); + } yield return () => { var state = metadata.TestBuilderContext.Current.StateBag; @@ -330,6 +350,10 @@ private sealed class EnumerationStateSource(bool constructor, bool enumerationSt { throw new InvalidOperationException("Factory state leaked into enumeration"); } + if (constructor) + { + state["overwritten"] = value; + } return Task.FromResult([value]); }; if (metadata.TestBuilderContext.Current.StateBag.ContainsKey(prefix + "-factory")) From a85e4bacaf234cd7b904bbc46b9fd462debff3eb Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:04:21 +0000 Subject: [PATCH 15/27] fix: compare saved class state against immutable baseline (#7308) --- src/TUnit.Core/Interfaces/ITestEvents.cs | 4 +- src/TUnit.Core/TestContextEvents.cs | 6 +- src/TUnit.Core/Tracking/ObjectTracker.cs | 6 +- src/TUnit.Engine/Building/TestBuilder.cs | 9 ++- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 2 + .../ObjectGraphDiscovererPreCheckTests.cs | 65 +++++++++++++++++++ 6 files changed, 87 insertions(+), 5 deletions(-) diff --git a/src/TUnit.Core/Interfaces/ITestEvents.cs b/src/TUnit.Core/Interfaces/ITestEvents.cs index 2b9fd9d67a0..44165cefdc4 100644 --- a/src/TUnit.Core/Interfaces/ITestEvents.cs +++ b/src/TUnit.Core/Interfaces/ITestEvents.cs @@ -37,7 +37,9 @@ public interface ITestEvents AsyncEvent? OnTestSkipped { get; } /// - /// Gets the event that is raised before a test is retried. + /// Gets the event raised before a retry, after backoff and cancellation checks. + /// The retry attempt is one-based. A handler failure aborts retry processing; + /// an accepted cancellation is preserved as a cancelled result. /// AsyncEvent<(TestContext TestContext, int RetryAttempt)>? OnTestRetry { get; } } diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 05f2c6beb2f..1c250d141e4 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -30,6 +30,10 @@ public class TestContextEvents : ITestEvents public AsyncEvent? OnTestStart { get; set; } public AsyncEvent? OnTestEnd { get; set; } public AsyncEvent? OnTestSkipped { get; set; } - // A handler failure aborts retry processing, as a failure in retry policy does. + /// + /// Gets or sets handlers invoked before a retry, after backoff and cancellation checks. + /// The retry attempt is one-based. A handler failure aborts retry processing; + /// an accepted cancellation is preserved as a cancelled result. + /// public AsyncEvent<(TestContext TestContext, int RetryAttempt)>? OnTestRetry { get; set; } } diff --git a/src/TUnit.Core/Tracking/ObjectTracker.cs b/src/TUnit.Core/Tracking/ObjectTracker.cs index 1573f6bb21e..d6b1fc872e3 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -540,7 +540,7 @@ private static bool Contains(SortedList>? trackedObjects, o /// private static bool ShouldSkipTracking(object? obj) { - return obj is not IDisposable and not IAsyncDisposable; + return obj is null || obj is not IDisposable and not IAsyncDisposable; } /// @@ -554,6 +554,10 @@ internal static bool IsExternallyOwned(object obj) private static readonly ConditionalWeakTable s_externallyOwned = new(); private static readonly object s_externallyOwnedMarker = new(); + // Ownership cannot live only on a row or counted entry: a container singleton can be + // supplied by another source before or after its DI row, including after its count reaches zero. + // A weak identity mark preserves that ownership without retaining the singleton. + // The flag deliberately stays set: live marks can outlast any individual row or test session. // Skips the table lookup for every tracked object until something is marked. private static volatile bool s_hasExternallyOwned; diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 1503de864a8..23ac558b4d4 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1123,6 +1123,11 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met private object?[]? _lent; private AsyncEvent<(TestContext Context, object? Object)>? _lentCleanup; private readonly TestBuilderContext _enumerationContext = enumerationContext ?? rowContext; + // Method enumeration mutates _enumerationContext after this row is saved. + // Compare constructor changes against its original state, never that live context. + private readonly Dictionary? _constructorBaseline = enumerationContext?.HasStateBag == true + ? new(enumerationContext.StateBag) + : null; private TestBuilderContext _rowContext = rowContext; // Snapshot before any method factory can mutate the class subscriptions. private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); @@ -1141,8 +1146,8 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met { foreach (var entry in _rowContext.StateBag) { - if (!_enumerationContext.HasStateBag - || !_enumerationContext.StateBag.TryGetValue(entry.Key, out var inherited) + if (_constructorBaseline is null + || !_constructorBaseline.TryGetValue(entry.Key, out var inherited) || !ReferenceEquals(inherited, entry.Value)) { context.StateBag[entry.Key] = entry.Value; diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 72f5630c77d..29c0dbe1b66 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -301,6 +301,7 @@ public async Task ClassAndMethodEnumerationStateSurvivesFactories(bool streaming foreach (var test in tests) { await Assert.That(test.Result?.Exception).IsNull(); + await Assert.That(test.Context.StateBag.Items["method-overwrite"]).IsEqualTo(test.Context.StateBag.Items["method-enumeration"]); await Assert.That(test.Context.StateBag.Items["overwritten"]).IsEqualTo(test.Context.StateBag.Items["class-factory"]); if (classEnumeration) { @@ -335,6 +336,7 @@ private sealed class EnumerationStateSource(bool constructor, bool enumerationSt { metadata.TestBuilderContext.Current.StateBag[prefix + "-enumeration"] = value; } + metadata.TestBuilderContext.Current.StateBag["method-overwrite"] = value; if (constructor) { metadata.TestBuilderContext.Current.StateBag["overwritten"] = new object(); diff --git a/tests/TUnit.UnitTests/ObjectGraphDiscovererPreCheckTests.cs b/tests/TUnit.UnitTests/ObjectGraphDiscovererPreCheckTests.cs index 334d423eb1a..8cc1a778911 100644 --- a/tests/TUnit.UnitTests/ObjectGraphDiscovererPreCheckTests.cs +++ b/tests/TUnit.UnitTests/ObjectGraphDiscovererPreCheckTests.cs @@ -1,6 +1,7 @@ using System.Reflection; using TUnit.Core.Discovery; using TUnit.Core.Interfaces; +using TUnit.Core.Tracking; namespace TUnit.UnitTests; @@ -77,6 +78,70 @@ public async Task DataSourceInjectedProperty_DeclaredAsNonInitializerInterface_I await AssertParity(holder, expectedMayHaveNested: true, expectedNested: [holder.Value]); } + [Test] + public async Task ScopeOwnedParentDoesNotClaimTUnitInjectedSharedInitializer() + { + var shared = new DisposableInitializer(); + var holder = new InjectedDisposableHolder { Value = shared }; + ObjectTracker.MarkExternallyOwned(holder); + var tracked = new SortedList>(); + var traversal = typeof(ObjectGraphDiscoverer).GetMethod("DiscoverNestedObjectsForTracking", + BindingFlags.Instance | BindingFlags.NonPublic)!; + + traversal.Invoke(new ObjectGraphDiscoverer(), [holder, tracked, 1, true, CancellationToken.None]); + + await Assert.That(tracked.Values.SelectMany(x => x).Contains(shared)).IsTrue(); + await Assert.That(ObjectTracker.IsExternallyOwned(shared)).IsFalse(); + + var current = TestContext.Current!; + var context = new TestContext(nameof(ScopeOwnedParentDoesNotClaimTUnitInjectedSharedInitializer), + current.ServiceProvider, current.ClassContext, + new TestBuilderContext { TestMetadata = current.TestDetails.MethodMetadata }, CancellationToken.None); + try + { + var tracker = new ObjectTracker(new TrackableObjectGraphProvider(new AlreadyDiscoveredGraph(tracked)), + GlobalContext.Current.Disposer); + tracker.TrackObjects(context); + await tracker.UntrackObjects(context); + await Assert.That(shared.DisposeCount).IsEqualTo(1); + } + finally + { + context.RemoveFromRegistry(); + context.Dispose(); + } + } + + private sealed class AlreadyDiscoveredGraph(SortedList> tracked) : IObjectGraphDiscoverer + { + public SortedList> DiscoverAndTrackObjects(TestContext context, CancellationToken cancellationToken = default) + { + foreach (var bucket in tracked) + { + context.TrackedObjects.Add(bucket.Key, bucket.Value); + } + return context.TrackedObjects; + } + public SortedList> TrackRootObjects(TestContext context) => context.TrackedObjects; + public ObjectGraph DiscoverObjectGraph(TestContext context, CancellationToken cancellationToken = default) + => throw new NotSupportedException(); + public ObjectGraph DiscoverNestedObjectGraph(object rootObject, CancellationToken cancellationToken = default) + => throw new NotSupportedException(); + } + + public class DisposableInitializer : IAsyncInitializer, IDisposable + { + public Task InitializeAsync() => Task.CompletedTask; + public int DisposeCount { get; private set; } + public void Dispose() => DisposeCount++; + } + + public class InjectedDisposableHolder + { + [ClassDataSource] + public required DisposableInitializer Value { get; init; } + } + private static async Task AssertParity(object root, bool expectedMayHaveNested, object[] expectedNested) { var mayHaveNested = ObjectGraphDiscoverer.MayHaveNestedObjects(root.GetType()); From b2da25e60879e4a1664e5ee5feb811bde8f31609 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:13:05 +0000 Subject: [PATCH 16/27] fix: replay saved constructor state removals (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 12 +++++++++++- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 6 ++++++ 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 23ac558b4d4..9e72eb4b8b3 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1141,9 +1141,19 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met if (_data is { } data) { // Keep method-enumeration state, but replay constructor-factory updates - // to inherited keys as well as newly added constructor state. + // and removals of inherited keys as well as newly added constructor state. if (_rowContext.HasStateBag) { + if (_constructorBaseline is not null && context.HasStateBag) + { + foreach (var key in _constructorBaseline.Keys) + { + if (!_rowContext.StateBag.ContainsKey(key)) + { + context.StateBag.TryRemove(key, out _); + } + } + } foreach (var entry in _rowContext.StateBag) { if (_constructorBaseline is null diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 29c0dbe1b66..10cd2781115 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -301,6 +301,8 @@ public async Task ClassAndMethodEnumerationStateSurvivesFactories(bool streaming foreach (var test in tests) { await Assert.That(test.Result?.Exception).IsNull(); + await Assert.That(test.Context.StateBag.ContainsKey("removed")).IsFalse(); + await Assert.That(test.Context.StateBag.ContainsKey("removed-after-method-update")).IsFalse(); await Assert.That(test.Context.StateBag.Items["method-overwrite"]).IsEqualTo(test.Context.StateBag.Items["method-enumeration"]); await Assert.That(test.Context.StateBag.Items["overwritten"]).IsEqualTo(test.Context.StateBag.Items["class-factory"]); if (classEnumeration) @@ -337,9 +339,11 @@ private sealed class EnumerationStateSource(bool constructor, bool enumerationSt metadata.TestBuilderContext.Current.StateBag[prefix + "-enumeration"] = value; } metadata.TestBuilderContext.Current.StateBag["method-overwrite"] = value; + metadata.TestBuilderContext.Current.StateBag["removed-after-method-update"] = value; if (constructor) { metadata.TestBuilderContext.Current.StateBag["overwritten"] = new object(); + metadata.TestBuilderContext.Current.StateBag["removed"] = new object(); } yield return () => { @@ -355,6 +359,8 @@ private sealed class EnumerationStateSource(bool constructor, bool enumerationSt if (constructor) { state["overwritten"] = value; + state.TryRemove("removed", out _); + state.TryRemove("removed-after-method-update", out _); } return Task.FromResult([value]); }; From 45e85ced9815478d11821e886986bd2194edb3ed Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:19:25 +0000 Subject: [PATCH 17/27] fix: preserve method-enumeration state removals (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 4 ---- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 6 ++++++ 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 9e72eb4b8b3..fbce1e9ad7f 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1162,10 +1162,6 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met { context.StateBag[entry.Key] = entry.Value; } - else - { - context.StateBag.TryAdd(entry.Key, entry.Value); - } } } if (_events is { } savedEvents) diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 10cd2781115..b4e8f020f5e 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -301,6 +301,7 @@ public async Task ClassAndMethodEnumerationStateSurvivesFactories(bool streaming foreach (var test in tests) { await Assert.That(test.Result?.Exception).IsNull(); + await Assert.That(test.Context.StateBag.ContainsKey("removed-by-method")).IsFalse(); await Assert.That(test.Context.StateBag.ContainsKey("removed")).IsFalse(); await Assert.That(test.Context.StateBag.ContainsKey("removed-after-method-update")).IsFalse(); await Assert.That(test.Context.StateBag.Items["method-overwrite"]).IsEqualTo(test.Context.StateBag.Items["method-enumeration"]); @@ -344,6 +345,11 @@ private sealed class EnumerationStateSource(bool constructor, bool enumerationSt { metadata.TestBuilderContext.Current.StateBag["overwritten"] = new object(); metadata.TestBuilderContext.Current.StateBag["removed"] = new object(); + metadata.TestBuilderContext.Current.StateBag["removed-by-method"] = new object(); + } + else + { + metadata.TestBuilderContext.Current.StateBag.TryRemove("removed-by-method", out _); } yield return () => { From 95e05fd0df635dbfb2029b6bdf3cdab978c922df Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 02:41:45 +0000 Subject: [PATCH 18/27] fix: complete property data-source lifecycle dispatch (#7308) --- src/TUnit.Core/TestContextEvents.cs | 2 +- src/TUnit.Engine/Building/TestBuilder.cs | 4 +- .../Services/StaticPropertyHandler.cs | 40 +++++- .../Services/TestFilterService.cs | 25 +++- .../PropertyRegistrationDelegateTests.cs | 55 ++++++++ .../SkippedScopeLifecycleTests.cs | 11 +- .../StaticScopeCleanupTests.cs | 118 ++++++++++++++++++ 7 files changed, 243 insertions(+), 12 deletions(-) create mode 100644 tests/TUnit.TestProject/PropertyRegistrationDelegateTests.cs create mode 100644 tests/TUnit.UnitTests/StaticScopeCleanupTests.cs diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 1c250d141e4..f9e74dae6a3 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -21,7 +21,7 @@ public class TestContextEvents : ITestEvents // Notified before each tracked object is released, then with null for any untracked scopes. // Scope handlers match their resolved objects and dispose at most once. - internal AsyncEvent<(TestContext Context, object? Object)>? OnDataRowDispose { get; set; } + internal AsyncEvent<(TestContext? Context, object? Object)>? OnDataRowDispose { get; set; } public AsyncEvent? OnDispose { get; set; } public AsyncEvent? OnTestRegistered { get; set; } diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index fbce1e9ad7f..504385832de 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1121,7 +1121,7 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met private object?[]? _data = data; private TestDataRowMetadata? _metadata = metadata; private object?[]? _lent; - private AsyncEvent<(TestContext Context, object? Object)>? _lentCleanup; + private AsyncEvent<(TestContext? Context, object? Object)>? _lentCleanup; private readonly TestBuilderContext _enumerationContext = enumerationContext ?? rowContext; // Method enumeration mutates _enumerationContext after this row is saved. // Compare constructor changes against its original state, never that live context. @@ -1236,7 +1236,7 @@ internal TestBuilderContext CreateEnumerationFailureContext(TestBuilderContext e return failureContext; } - public AsyncEvent<(TestContext Context, object? Object)>? TakeCleanup() + public AsyncEvent<(TestContext? Context, object? Object)>? TakeCleanup() { // A claimed row already belongs to a runnable test. Never copy its cleanup // to a later empty source, which may finish before that test. diff --git a/src/TUnit.Engine/Services/StaticPropertyHandler.cs b/src/TUnit.Engine/Services/StaticPropertyHandler.cs index 271988c5aa5..58b628d65f4 100644 --- a/src/TUnit.Engine/Services/StaticPropertyHandler.cs +++ b/src/TUnit.Engine/Services/StaticPropertyHandler.cs @@ -62,7 +62,7 @@ await _propertyInjector.Value.InjectPropertiesAsync( value, _sessionObjectBag, methodMetadata: null, - new TestContextEvents()); + TestSessionContext.GlobalStaticPropertyContext.Events); // Initialize nested objects depth-first BEFORE initializing the main value // This ensures containers (IAsyncInitializer) are started before the factory @@ -99,14 +99,45 @@ public void TrackStaticProperties() /// sweep in TestSessionCoordinator does not dispose the same object a second time. /// public async Task DisposeStaticPropertiesAsync(List cleanupExceptions) + => await DisposeStaticPropertiesAsync( + _trackableObjectGraphProvider.GetStaticPropertyTrackableObjects(), + TestSessionContext.GlobalStaticPropertyContext.Events, + _objectTracker, + cleanupExceptions).ConfigureAwait(false); + + internal static async Task DisposeStaticPropertiesAsync( + IEnumerable staticProperties, + TestContextEvents events, + ObjectTracker objectTracker, + List cleanupExceptions) { - var staticProperties = _trackableObjectGraphProvider.GetStaticPropertyTrackableObjects(); + async ValueTask DisposeScopesAsync(object? instance) + { + if (events.OnDataRowDispose is not { } cleanup) + { + return; + } + + foreach (var handler in cleanup.InvocationList) + { + try + { + await handler.InvokeAsync(events, (null, instance)).ConfigureAwait(false); + } + catch (Exception e) + { + cleanupExceptions.Add(e); + } + } + } foreach (var staticProperty in staticProperties) { + // Scope-owned values must be released by their scope before tracker disposal is skipped. + await DisposeScopesAsync(staticProperty).ConfigureAwait(false); try { - await _objectTracker.UntrackObjectAsync(staticProperty).ConfigureAwait(false); + await objectTracker.UntrackObjectAsync(staticProperty).ConfigureAwait(false); } catch (Exception e) { @@ -114,6 +145,9 @@ public async Task DisposeStaticPropertiesAsync(List cleanupExceptions } } + // Also release scopes whose factory failed or whose returned value was not trackable. + await DisposeScopesAsync(null).ConfigureAwait(false); + if (cleanupExceptions.Count > 0) { throw new AggregateException("Errors occurred while disposing static properties", cleanupExceptions); diff --git a/src/TUnit.Engine/Services/TestFilterService.cs b/src/TUnit.Engine/Services/TestFilterService.cs index d423084b86c..df65c49485b 100644 --- a/src/TUnit.Engine/Services/TestFilterService.cs +++ b/src/TUnit.Engine/Services/TestFilterService.cs @@ -131,11 +131,25 @@ private async Task RegisterTest(AbstractExecutableTest test, bool isForExecution await InvokeTestRegisteredReceivers(registeredReceivers, registeredContext, invokedReceivers).ConfigureAwait(false); } - if (test.Context.InternalEventsIfCreated?.OnTestRegistered is { } onRegistered) + HashSet.Invocation>? invokedDelegates = null; + await InvokeRegistrationDelegatesAsync().ConfigureAwait(false); + + async Task InvokeRegistrationDelegatesAsync() { - foreach (var handler in onRegistered.InvocationList) + if (test.Context.InternalEventsIfCreated?.OnTestRegistered is not { } onRegistered) { - await handler.InvokeAsync(test.Context, test.Context).ConfigureAwait(false); + return; + } + + // Snapshot because a handler can subscribe another handler while it runs. + // Invocation identity preserves duplicate subscriptions while skipping the earlier pass. + foreach (var handler in onRegistered.InvocationList.ToArray()) + { + invokedDelegates ??= []; + if (invokedDelegates.Add(handler)) + { + await handler.InvokeAsync(test.Context, test.Context).ConfigureAwait(false); + } } } @@ -199,6 +213,11 @@ private async Task RegisterTest(AbstractExecutableTest test, bool isForExecution await InvokeTestRegisteredReceivers(test.Context.GetTestRegisteredReceivers(), registeredContext, invokedReceivers).ConfigureAwait(false); } + + if (argumentsRegistered) + { + await InvokeRegistrationDelegatesAsync().ConfigureAwait(false); + } } // Clear the cached display name after registration events diff --git a/tests/TUnit.TestProject/PropertyRegistrationDelegateTests.cs b/tests/TUnit.TestProject/PropertyRegistrationDelegateTests.cs new file mode 100644 index 00000000000..534bd6c3656 --- /dev/null +++ b/tests/TUnit.TestProject/PropertyRegistrationDelegateTests.cs @@ -0,0 +1,55 @@ +using TUnit.TestProject.Attributes; + +namespace TUnit.TestProject; + +[PropertyRegistrationDelegateTests.ConstructorData] +public class PropertyRegistrationDelegateTests(int value) +{ + [PropertyData] + public required Service Injected { get; init; } + + public sealed class Service; + + public sealed class ConstructorDataAttribute : DataSourceGeneratorAttribute + { + protected override IEnumerable> GenerateDataSources(DataGeneratorMetadata metadata) + { + yield return () => + { + metadata.TestBuilderContext.Current.Events.OnTestRegistered += Record("constructor"); + return 1; + }; + } + } + + public sealed class PropertyDataAttribute : DataSourceGeneratorAttribute + { + protected override IEnumerable> GenerateDataSources(DataGeneratorMetadata metadata) + { + yield return () => + { + var events = metadata.TestBuilderContext.Current.Events; + events.OnTestRegistered ??= new(); + // A newly inserted handler sorts ahead of the previously dispatched subscription. + events.OnTestRegistered.Add(Record("property"), order: 0); + return new Service(); + }; + } + } + + private static Func Record(string key) => (_, context) => + { + context.StateBag.Items.TryGetValue(key, out var count); + context.StateBag.Items[key] = (count as int? ?? 0) + 1; + return default; + }; + + [Test, Repeat(1), EngineTest(ExpectedResult.Pass)] + public async Task PropertyAndConstructorDelegatesRunOnce() + { + await Assert.That(value).IsEqualTo(1); + await Assert.That(Injected).IsNotNull(); + await Assert.That(TestContext.Current!.StateBag.Items["constructor"]).IsEqualTo(1); + await Assert.That(TestContext.Current.StateBag.Items["property"]).IsEqualTo(1); + } +} diff --git a/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs b/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs index c3bbcfc3295..ffdc5ac811b 100644 --- a/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs +++ b/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs @@ -55,11 +55,16 @@ public FailedScopeLifecycleTests(MEDIClass service) public void FailedInstance(string value) => throw new InvalidOperationException("Must not execute"); [After(TestSession)] - public static async Task VerifyScopeCleanup() + public static async Task VerifyScopeCleanup(TestSessionContext session) { - if (_service is { } service) + // Session hooks also run when a filter excludes this class entirely. + if (!session.TestClasses.Where(x => x.ClassType == typeof(FailedScopeLifecycleTests)) + .SelectMany(x => x.Tests).Any(x => x.Execution.Result != null)) { - await Assert.That(service.DisposeCount).IsEqualTo(1); + return; } + + await Assert.That(_service).IsNotNull(); + await Assert.That(_service!.DisposeCount).IsEqualTo(1); } } diff --git a/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs new file mode 100644 index 00000000000..19154fdea99 --- /dev/null +++ b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs @@ -0,0 +1,118 @@ +using TUnit.Core; +using TUnit.Core.Enums; +using TUnit.Core.Tracking; +using TUnit.Engine.Services; + +namespace TUnit.UnitTests; + +public class StaticScopeCleanupTests +{ + [Test] + public async Task StaticScopeOwnsServiceUntilSessionCleanup() + { + var events = new TestContextEvents(); + var source = new ScopeSource(); + var service = source.Resolve(events); + var tracker = new ObjectTracker(new TrackableObjectGraphProvider(), GlobalContext.Current.Disposer); + + await Assert.That(service.DisposeCount).IsEqualTo(0); + await Assert.That(source.Scope.DisposeCount).IsEqualTo(0); + + await StaticPropertyHandler.DisposeStaticPropertiesAsync([service], events, tracker, []); + // Matching-object notification and the final sweep must not dispose the same scope twice. + await Assert.That(source.Scope.DisposeCount).IsEqualTo(1); + await Assert.That(service.DisposeCount).IsEqualTo(1); + } + + [Test] + public async Task FailedStaticFactoryScopeIsReleasedAndOtherScopesStillDispose() + { + var events = new TestContextEvents(); + var failed = new ScopeSource { ThrowOnCreate = true, ThrowOnDispose = true }; + try + { + failed.Resolve(events); + } + catch (InvalidOperationException) + { + } + var successful = new ScopeSource(); + var service = successful.Resolve(events); + var tracker = new ObjectTracker(new TrackableObjectGraphProvider(), GlobalContext.Current.Disposer); + var exceptions = new List(); + + try + { + await StaticPropertyHandler.DisposeStaticPropertiesAsync([service], events, tracker, exceptions); + } + catch (AggregateException) + { + } + + await Assert.That(failed.Scope.DisposeCount).IsEqualTo(1); + await Assert.That(successful.Scope.DisposeCount).IsEqualTo(1); + await Assert.That(service.DisposeCount).IsEqualTo(1); + await Assert.That(exceptions.Count).IsEqualTo(1); + await Assert.That(exceptions[0].Message).IsEqualTo("Scope cleanup failure"); + } + + private sealed class ScopeSource : DependencyInjectionDataSourceAttribute + { + public Scope Scope { get; } = new(); + public bool ThrowOnCreate; + public bool ThrowOnDispose; + + public Service Resolve(TestContextEvents events) + { + var method = TestContext.Current!.TestDetails.MethodMetadata; + var metadata = new DataGeneratorMetadata + { + TestBuilderContext = new TestBuilderContextAccessor(new TestBuilderContext + { + TestMetadata = method, + Events = events + }), + MembersToGenerate = [method.Class], + TestInformation = null, + Type = DataGeneratorType.Property, + TestSessionId = "static-scope-regression", + TestClassInstance = null, + ClassInstanceArguments = [] + }; + return (Service) GenerateDataSources(metadata).Single()()![0]!; + } + + public override Scope CreateScope(DataGeneratorMetadata metadata) + { + Scope.ThrowOnDispose = ThrowOnDispose; + return Scope; + } + + public override object Create(Scope scope, Type type) + => ThrowOnCreate ? throw new InvalidOperationException("Factory failure") : scope.Service = new Service(); + } + + private sealed class Scope : IAsyncDisposable + { + public int DisposeCount; + public bool ThrowOnDispose; + public Service? Service; + + public async ValueTask DisposeAsync() + { + await Task.Yield(); + DisposeCount++; + Service?.Dispose(); + if (ThrowOnDispose) throw new InvalidOperationException("Scope cleanup failure"); + } + } + + private sealed class Service : IDisposable + { + public int DisposeCount; + public void Dispose() + { + if (++DisposeCount > 1) throw new InvalidOperationException("Service disposed twice"); + } + } +} From f9136c5a23f5771faf164213cf549f203e5c6e15 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:08:56 +0000 Subject: [PATCH 19/27] fix: preserve row callbacks and synchronize session cleanup (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 110 +++++++++--------- .../Services/StaticPropertyHandler.cs | 11 +- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 104 +++++++++++++++++ .../StaticScopeCleanupTests.cs | 9 ++ 4 files changed, 175 insertions(+), 59 deletions(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index c774082bf2f..60c6f005182 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -548,7 +548,7 @@ public async ValueTask> BuildTestsFromMetada // The test built below holds classData, which may be the unclaimed first fetch, // and tracks any objects that a temporary instance used. var lentClassRowObjects = unclaimedClassRow.TakeLentObjects(); - var rowCleanup = unclaimedClassRow.TakeCleanup(); + var skippedRowContext = unclaimedClassRow.CreateEnumerationFailureContext(contextAccessor.Current); unclaimedClassRow.Clear(); Type[] resolvedClassGenericArgs; @@ -568,11 +568,7 @@ public async ValueTask> BuildTestsFromMetada // If generic type inference failed, create a failed test instead of skipped if (genericResolutionException != null) { - if (rowCleanup is not null) - { - contextAccessor.Current.Events.OnDataRowDispose = rowCleanup.Clone(); - } - var failedTest = CreateFailedTestForDataGenerationError(metadata, genericResolutionException, new TestDataCombination(), classData, lentClassRowObjects, contextAccessor.Current); + var failedTest = CreateFailedTestForDataGenerationError(metadata, genericResolutionException, new TestDataCombination(), classData, lentClassRowObjects, skippedRowContext); tests.Add(failedTest); } else @@ -602,11 +598,8 @@ public async ValueTask> BuildTestsFromMetada InitializedAttributes = attributes }; - testBuilderContext.CopyStateBagTo(testSpecificContext); - if (rowCleanup is { } cleanup) - { - testSpecificContext.Events.OnDataRowDispose = cleanup.Clone(); - } + skippedRowContext.CopyStateBagTo(testSpecificContext); + testSpecificContext.Events = skippedRowContext.EventsIfCreated?.Clone() ?? new(); var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); test.Context.SkipReason = skipReason; @@ -1140,34 +1133,7 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met { if (_data is { } data) { - // Keep method-enumeration state, but replay constructor-factory updates - // and removals of inherited keys as well as newly added constructor state. - if (_rowContext.HasStateBag) - { - if (_constructorBaseline is not null && context.HasStateBag) - { - foreach (var key in _constructorBaseline.Keys) - { - if (!_rowContext.StateBag.ContainsKey(key)) - { - context.StateBag.TryRemove(key, out _); - } - } - } - foreach (var entry in _rowContext.StateBag) - { - if (_constructorBaseline is null - || !_constructorBaseline.TryGetValue(entry.Key, out var inherited) - || !ReferenceEquals(inherited, entry.Value)) - { - context.StateBag[entry.Key] = entry.Value; - } - } - } - if (_events is { } savedEvents) - { - context.Events = savedEvents.Clone(); - } + ApplySavedContextTo(context); var row = (data, _metadata); Clear(); return new ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)>(row); @@ -1185,6 +1151,38 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met } } + private void ApplySavedContextTo(TestBuilderContext context) + { + // Keep method-enumeration state, but replay constructor-factory updates + // and removals of inherited keys as well as newly added constructor state. + if (_rowContext.HasStateBag) + { + if (_constructorBaseline is not null && context.HasStateBag) + { + foreach (var key in _constructorBaseline.Keys) + { + if (!_rowContext.StateBag.ContainsKey(key)) + { + context.StateBag.TryRemove(key, out _); + } + } + } + foreach (var entry in _rowContext.StateBag) + { + if (_constructorBaseline is null + || !_constructorBaseline.TryGetValue(entry.Key, out var inherited) + || !ReferenceEquals(inherited, entry.Value)) + { + context.StateBag[entry.Key] = entry.Value; + } + } + } + if (_events is { } savedEvents) + { + context.Events = savedEvents.Clone(); + } + } + /// /// Hands back objects that were taken but that no test ended up holding, so the next test takes them. /// @@ -1195,17 +1193,14 @@ public void Return(object?[] data, TestDataRowMetadata? metadata) } /// - /// Preserves scope cleanup when a skipped or failed test takes ownership of the row. + /// Preserves row callbacks and state when a skipped or failed test takes ownership of the row. /// public void TransferCleanupTo(TestBuilderContext target) { - var cleanup = TakeCleanup(); - if (cleanup is null) + if (_data is not null) { - return; + ApplySavedContextTo(target); } - - target.Events.OnDataRowDispose = cleanup.Clone(); } internal TestBuilderContext CreateFailureContext(TestBuilderContext currentContext) @@ -1222,18 +1217,11 @@ internal TestBuilderContext CreateEnumerationFailureContext(TestBuilderContext e var failureContext = enumerationContext with { }; enumerationContext.CopyStateBagTo(failureContext); failureContext.Events = enumerationContext.EventsIfCreated?.Clone() ?? new(); - failureContext.Events.OnDataRowDispose = TakeCleanup()?.Clone(); + failureContext.Events.OnDataRowDispose = null; + TransferCleanupTo(failureContext); return failureContext; } - public AsyncEvent<(TestContext? Context, object? Object)>? TakeCleanup() - { - // A claimed row already belongs to a runnable test. Never copy its cleanup - // to a later empty source, which may finish before that test. - var cleanup = _data is not null ? _events?.OnDataRowDispose : null; - return cleanup; - } - /// Marks the unclaimed objects as held by a test. public void Clear() { @@ -1254,9 +1242,14 @@ public void LendToTemporaryInstance(TestBuilderContext? lifetimeContext = null) if (_events?.OnDataRowDispose is { } cleanup) { lifetimeContext ??= TestSessionContext.GlobalStaticPropertyContext; - foreach (var handler in cleanup.InvocationList) + var lifetimeEvents = lifetimeContext.Events; + // Builders run concurrently. Protect both initial event creation and insertion. + lock (lifetimeEvents) { - lifetimeContext.Events.OnDataRowDispose += handler.InvokeAsync; + foreach (var handler in cleanup.InvocationList) + { + lifetimeEvents.OnDataRowDispose += handler.InvokeAsync; + } } } _events = null; @@ -1925,9 +1918,10 @@ private async ValueTask InitializeAttributesCoreAsync(Attribute[] a private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext) { var builderContext = new TestBuilderContext { TestMetadata = metadata.MethodMetadata }; - if (rowContext?.EventsIfCreated?.OnDataRowDispose is { } cleanup) + if (rowContext is not null) { - builderContext.Events.OnDataRowDispose = cleanup.Clone(); + rowContext.CopyStateBagTo(builderContext); + builderContext.Events = rowContext.EventsIfCreated?.Clone() ?? new(); } var context = _contextProvider.CreateTestContext( diff --git a/src/TUnit.Engine/Services/StaticPropertyHandler.cs b/src/TUnit.Engine/Services/StaticPropertyHandler.cs index 58b628d65f4..64fde3b65d3 100644 --- a/src/TUnit.Engine/Services/StaticPropertyHandler.cs +++ b/src/TUnit.Engine/Services/StaticPropertyHandler.cs @@ -111,9 +111,18 @@ internal static async Task DisposeStaticPropertiesAsync( ObjectTracker objectTracker, List cleanupExceptions) { + AsyncEvent<(TestContext? Context, object? Object)>? cleanup; + lock (events) + { + // Detach this session's handlers before awaiting disposal. A reused host must + // neither retain disposed scopes nor scan their callbacks in later sessions. + cleanup = events.OnDataRowDispose; + events.OnDataRowDispose = null; + } + async ValueTask DisposeScopesAsync(object? instance) { - if (events.OnDataRowDispose is not { } cleanup) + if (cleanup is null) { return; } diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index b99dbe0d45d..654445fce3a 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -167,6 +167,110 @@ public async Task ClassIteratorFailureDoesNotDisposeRunnableScope(bool laterSour } } + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task NonRunnableRowsPreservePublicCallbacksAndState(bool factoryThrows) + { + var current = TestContext.Current!; + var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; + var source = new PublicCleanupSource { FactoryThrows = factoryThrows }; + var metadata = new TestMetadata + { + TestClassType = typeof(ClassRowCleanupTests), + TestMethodName = nameof(NonRunnableRowsPreservePublicCallbacksAndState), + TestName = "Non-runnable row callbacks regression", + FilePath = "Unknown", + LineNumber = 0, + AttributeFactory = () => [], + MethodMetadata = current.TestDetails.MethodMetadata, + DataSources = factoryThrows ? [] : [new EmptySource { SkipIfEmpty = true }], + ClassDataSources = [source], + PropertyDataSources = [], + InstanceFactory = (_, _) => new ClassRowCleanupTests(), + InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask + }; + var tests = (await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))).ToArray(); + try + { + await Assert.That(tests.Length).IsEqualTo(1); + var context = tests[0].Context; + await Assert.That(context.StateBag["resource"]).IsSameReferenceAs(source.Resource); + var events = context.InternalEvents; + foreach (var callback in new[] { events.OnTestRegistered, events.OnTestSkipped, events.OnTestEnd, events.OnDispose }) + { + await Assert.That(callback).IsNotNull(); + foreach (var handler in callback!.InvocationList) + { + await handler.InvokeAsync(context, context); + } + } + await Assert.That(source.Callbacks).IsEqualTo(4); + } + finally + { + foreach (var test in tests) + { + test.Context.RemoveFromRegistry(); + test.Context.Dispose(); + } + } + } + + private sealed class PublicCleanupSource : Attribute, IDataSourceAttribute + { + public readonly object Resource = new(); + public int Callbacks; + public bool FactoryThrows; + public bool SkipIfEmpty { get; set; } + public bool DeferEnumeration { get; set; } + public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata) + { + await Task.CompletedTask; + yield return () => + { + var context = metadata.TestBuilderContext.Current; + context.StateBag["resource"] = Resource; + ValueTask Callback(object sender, TestContext testContext) + { + if (!ReferenceEquals(testContext.StateBag["resource"], Resource)) + { + throw new InvalidOperationException("Cleanup lost its owning state"); + } + Callbacks++; + return default; + } + context.Events.OnTestRegistered += Callback; + context.Events.OnTestSkipped += Callback; + context.Events.OnTestEnd += Callback; + context.Events.OnDispose += Callback; + if (FactoryThrows) throw new InvalidOperationException("Factory failure"); + return Task.FromResult([Resource]); + }; + } + } + + [Test] + public async Task ConcurrentTemporaryRowsKeepEverySessionCleanup() + { + var session = CreateContext(); + session.Events = new(); // Match the eagerly initialized global session context. + var contexts = Enumerable.Range(0, 512).Select(_ => CreateContext()).ToArray(); + var disposals = 0; + foreach (var context in contexts) + { + context.Events.OnDataRowDispose += (_, _) => + { + Interlocked.Increment(ref disposals); + return default; + }; + } + Parallel.ForEach(contexts, context => + new TestBuilder.UnclaimedClassRow([new object()], null, context).LendToTemporaryInstance(session)); + await DisposeRow(session); + await Assert.That(disposals).IsEqualTo(contexts.Length); + } + private sealed class EmptySource : Attribute, IDataSourceAttribute { public bool SkipIfEmpty { get; set; } diff --git a/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs index 19154fdea99..a950c725ac3 100644 --- a/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs +++ b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs @@ -22,6 +22,14 @@ public async Task StaticScopeOwnsServiceUntilSessionCleanup() // Matching-object notification and the final sweep must not dispose the same scope twice. await Assert.That(source.Scope.DisposeCount).IsEqualTo(1); await Assert.That(service.DisposeCount).IsEqualTo(1); + await Assert.That(events.OnDataRowDispose).IsNull(); + + var laterSource = new ScopeSource(); + var laterService = laterSource.Resolve(events); + await StaticPropertyHandler.DisposeStaticPropertiesAsync([laterService], events, tracker, []); + await Assert.That(laterSource.Scope.DisposeCount).IsEqualTo(1); + await Assert.That(source.Scope.DisposeCount).IsEqualTo(1); + await Assert.That(events.OnDataRowDispose).IsNull(); } [Test] @@ -52,6 +60,7 @@ public async Task FailedStaticFactoryScopeIsReleasedAndOtherScopesStillDispose() await Assert.That(failed.Scope.DisposeCount).IsEqualTo(1); await Assert.That(successful.Scope.DisposeCount).IsEqualTo(1); await Assert.That(service.DisposeCount).IsEqualTo(1); + await Assert.That(events.OnDataRowDispose).IsNull(); await Assert.That(exceptions.Count).IsEqualTo(1); await Assert.That(exceptions[0].Message).IsEqualTo("Scope cleanup failure"); } From 009efead53997343d0f2524fd5049dc1b31deed2 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:22:28 +0000 Subject: [PATCH 20/27] fix: model data-row scope ownership explicitly (#7308) --- ...dencyInjectionDataSourceSourceAttribute.cs | 47 +------- src/TUnit.Core/DataRowScopeCollection.cs | 103 ++++++++++++++++++ src/TUnit.Core/TestContextEvents.cs | 7 +- src/TUnit.Core/Tracking/ObjectTracker.cs | 14 +-- src/TUnit.Engine/Building/TestBuilder.cs | 11 +- .../Services/StaticPropertyHandler.cs | 39 ++----- .../Services/TestExecution/TestCoordinator.cs | 16 +-- .../TestExecution/TestOnDisposeRaiser.cs | 12 +- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 49 +++++---- .../DataRowScopeCollectionTests.cs | 76 +++++++++++++ .../StaticScopeCleanupTests.cs | 6 +- 11 files changed, 240 insertions(+), 140 deletions(-) create mode 100644 src/TUnit.Core/DataRowScopeCollection.cs create mode 100644 tests/TUnit.UnitTests/DataRowScopeCollectionTests.cs diff --git a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs index 4e98b14b799..7486bd92326 100644 --- a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs +++ b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs @@ -16,49 +16,11 @@ public abstract class DependencyInjectionDataSourceAttribute : UntypedDa // disposing the returned objects, as it does for any other data source. var scopeOwnsCreatedObjects = scope is IDisposable or IAsyncDisposable; - // Dispose at the depth of the resolved objects, before their nested dependencies. - // The final null notification also cleans up scopes whose objects were not tracked. - object?[]? createdObjects = null; - var disposed = 0; - dataGeneratorMetadata.TestBuilderContext.Current.Events.OnDataRowDispose += async (_, args) => - { - if (args.Object is not null) - { - var ownsObject = false; - if (createdObjects is not null) - { - foreach (var created in createdObjects) - { - if (ReferenceEquals(created, args.Object)) - { - ownsObject = true; - break; - } - } - } - - if (!ownsObject) - { - return; - } - } - - if (Interlocked.Exchange(ref disposed, 1) != 0) - { - return; - } - - if (scope is IAsyncDisposable asyncDisposable) - { - await asyncDisposable.DisposeAsync().ConfigureAwait(false); - } - else if (scope is IDisposable disposable) - { - disposable.Dispose(); - } - }; + // Register before resolving so a failed factory still releases its scope. + var cleanup = dataGeneratorMetadata.TestBuilderContext.Current.Events.DataRowScopes ??= new(); + var owner = cleanup.Register(scope); - return createdObjects = dataGeneratorMetadata.MembersToGenerate + return dataGeneratorMetadata.MembersToGenerate .Select(m => m switch { PropertyMetadata prop => prop.Type, @@ -70,6 +32,7 @@ public abstract class DependencyInjectionDataSourceAttribute : UntypedDa .Select(x => { var created = Create(scope, x); + cleanup.RegisterObject(owner, created); if (scopeOwnsCreatedObjects) { diff --git a/src/TUnit.Core/DataRowScopeCollection.cs b/src/TUnit.Core/DataRowScopeCollection.cs new file mode 100644 index 00000000000..fea9da6a4dd --- /dev/null +++ b/src/TUnit.Core/DataRowScopeCollection.cs @@ -0,0 +1,103 @@ +namespace TUnit.Core; + +/// +/// Owns a row's scopes. Object lookup releases each scope at its first resolved object's graph +/// depth; completion releases scopes left by failed factories or untracked values. +/// +internal sealed class DataRowScopeCollection +{ + private readonly List _owners = []; + private readonly Dictionary> _objects = new(ReferenceEqualityComparer.Instance); + + internal ScopeOwner Register(object? scope) + { + var owner = new ScopeOwner(scope); + _owners.Add(owner); + return owner; + } + + internal void RegisterObject(ScopeOwner owner, object? instance) + { + if (instance is null) + { + return; + } + + if (!_objects.TryGetValue(instance, out var owners)) + { + _objects.Add(instance, owners = []); + } + + if (!owners.Contains(owner)) + { + owners.Add(owner); + } + } + + internal DataRowScopeCollection Clone() + { + var clone = new DataRowScopeCollection(); + clone.AddRange(this); + return clone; + } + + internal void AddRange(DataRowScopeCollection scopes) + { + _owners.AddRange(scopes._owners); + foreach (var pair in scopes._objects) + { + foreach (var owner in pair.Value) + { + RegisterObject(owner, pair.Key); + } + } + } + + internal ValueTask?> ReleaseAsync(object instance, List? exceptions = null) + => _objects.TryGetValue(instance, out var owners) + ? DisposeAsync(owners, exceptions) + : new(exceptions); + + internal ValueTask?> CompleteAsync(List? exceptions = null) + => DisposeAsync(_owners, exceptions); + + private static async ValueTask?> DisposeAsync(List owners, List? exceptions) + { + foreach (var owner in owners) + { + try + { + await owner.DisposeAsync().ConfigureAwait(false); + } + catch (Exception exception) + { + (exceptions ??= []).Add(exception); + } + } + + return exceptions; + } + + /// Shared by cloned rows; scope disposal is attempted once, including when it throws. + internal sealed class ScopeOwner(object? scope) + { + private int _disposed; + + internal async ValueTask DisposeAsync() + { + if (Interlocked.Exchange(ref _disposed, 1) != 0) + { + return; + } + + if (scope is IAsyncDisposable asyncDisposable) + { + await asyncDisposable.DisposeAsync().ConfigureAwait(false); + } + else if (scope is IDisposable disposable) + { + disposable.Dispose(); + } + } + } +} diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index f9e74dae6a3..3d5f495569d 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -9,7 +9,7 @@ public class TestContextEvents : ITestEvents { internal TestContextEvents Clone() => new() { - OnDataRowDispose = OnDataRowDispose?.Clone(), + DataRowScopes = DataRowScopes?.Clone(), OnDispose = OnDispose?.Clone(), OnTestRegistered = OnTestRegistered?.Clone(), OnInitialize = OnInitialize?.Clone(), @@ -19,9 +19,8 @@ public class TestContextEvents : ITestEvents OnTestRetry = OnTestRetry?.Clone() }; - // Notified before each tracked object is released, then with null for any untracked scopes. - // Scope handlers match their resolved objects and dispose at most once. - internal AsyncEvent<(TestContext? Context, object? Object)>? OnDataRowDispose { get; set; } + // Clones share once-only scope owners while keeping row ownership collections isolated. + internal DataRowScopeCollection? DataRowScopes { get; set; } public AsyncEvent? OnDispose { get; set; } public AsyncEvent? OnTestRegistered { get; set; } diff --git a/src/TUnit.Core/Tracking/ObjectTracker.cs b/src/TUnit.Core/Tracking/ObjectTracker.cs index d6b1fc872e3..f65c0b6d201 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -263,19 +263,9 @@ private static void RemoveObjectsNotIn(SortedList>? tracked foreach (var obj in bucket) { - if (testContext.InternalEventsIfCreated?.OnDataRowDispose is { } scopeCleanup) + if (testContext.InternalEventsIfCreated?.DataRowScopes is { } scopes) { - foreach (var handler in scopeCleanup.InvocationList) - { - try - { - await handler.InvokeAsync(this, (testContext, obj)).ConfigureAwait(false); - } - catch (Exception e) - { - (cleanupExceptions ??= []).Add(e); - } - } + cleanupExceptions = await scopes.ReleaseAsync(obj, cleanupExceptions).ConfigureAwait(false); } try diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 60c6f005182..c177ba9dca8 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1217,7 +1217,7 @@ internal TestBuilderContext CreateEnumerationFailureContext(TestBuilderContext e var failureContext = enumerationContext with { }; enumerationContext.CopyStateBagTo(failureContext); failureContext.Events = enumerationContext.EventsIfCreated?.Clone() ?? new(); - failureContext.Events.OnDataRowDispose = null; + failureContext.Events.DataRowScopes = null; TransferCleanupTo(failureContext); return failureContext; } @@ -1239,17 +1239,14 @@ public void LendToTemporaryInstance(TestBuilderContext? lifetimeContext = null) _lent = _data; // Method rows can retain services from this temporary instance's scope. // Keep that scope alive until session cleanup, rather than the first test's cleanup. - if (_events?.OnDataRowDispose is { } cleanup) + if (_events?.DataRowScopes is { } scopes) { lifetimeContext ??= TestSessionContext.GlobalStaticPropertyContext; var lifetimeEvents = lifetimeContext.Events; - // Builders run concurrently. Protect both initial event creation and insertion. + // Builders run concurrently. Protect collection creation and all ownership transfers. lock (lifetimeEvents) { - foreach (var handler in cleanup.InvocationList) - { - lifetimeEvents.OnDataRowDispose += handler.InvokeAsync; - } + (lifetimeEvents.DataRowScopes ??= new()).AddRange(scopes); } } _events = null; diff --git a/src/TUnit.Engine/Services/StaticPropertyHandler.cs b/src/TUnit.Engine/Services/StaticPropertyHandler.cs index 64fde3b65d3..8d7eeed3640 100644 --- a/src/TUnit.Engine/Services/StaticPropertyHandler.cs +++ b/src/TUnit.Engine/Services/StaticPropertyHandler.cs @@ -111,39 +111,21 @@ internal static async Task DisposeStaticPropertiesAsync( ObjectTracker objectTracker, List cleanupExceptions) { - AsyncEvent<(TestContext? Context, object? Object)>? cleanup; + DataRowScopeCollection? scopes; lock (events) { - // Detach this session's handlers before awaiting disposal. A reused host must - // neither retain disposed scopes nor scan their callbacks in later sessions. - cleanup = events.OnDataRowDispose; - events.OnDataRowDispose = null; - } - - async ValueTask DisposeScopesAsync(object? instance) - { - if (cleanup is null) - { - return; - } - - foreach (var handler in cleanup.InvocationList) - { - try - { - await handler.InvokeAsync(events, (null, instance)).ConfigureAwait(false); - } - catch (Exception e) - { - cleanupExceptions.Add(e); - } - } + // Detach before awaiting so a reused host cannot retain scopes from earlier sessions. + scopes = events.DataRowScopes; + events.DataRowScopes = null; } foreach (var staticProperty in staticProperties) { // Scope-owned values must be released by their scope before tracker disposal is skipped. - await DisposeScopesAsync(staticProperty).ConfigureAwait(false); + if (scopes is not null) + { + await scopes.ReleaseAsync(staticProperty, cleanupExceptions).ConfigureAwait(false); + } try { await objectTracker.UntrackObjectAsync(staticProperty).ConfigureAwait(false); @@ -155,7 +137,10 @@ async ValueTask DisposeScopesAsync(object? instance) } // Also release scopes whose factory failed or whose returned value was not trackable. - await DisposeScopesAsync(null).ConfigureAwait(false); + if (scopes is not null) + { + await scopes.CompleteAsync(cleanupExceptions).ConfigureAwait(false); + } if (cleanupExceptions.Count > 0) { diff --git a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs index 21385f92cc2..de8cc0120b5 100644 --- a/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs +++ b/src/TUnit.Engine/Services/TestExecution/TestCoordinator.cs @@ -232,26 +232,16 @@ await RetryHelper.ExecuteWithRetry(test.Context, List? cleanupExceptions = null; // Release roots before their dependencies. Scope cleanup is invoked at the resolved - // object's graph depth by the tracker; the final notification catches untracked scopes. + // object's graph depth by the tracker; completion catches untracked scopes. var trackingExceptions = await _objectTracker.UntrackObjects(test.Context).ConfigureAwait(false); if (trackingExceptions is { Count: > 0 }) { (cleanupExceptions ??= []).AddRange(trackingExceptions); } - if (test.Context.InternalEventsIfCreated?.OnDataRowDispose is { } onDataRowDispose) + if (test.Context.InternalEventsIfCreated?.DataRowScopes is { } scopes) { - foreach (var handler in onDataRowDispose.InvocationList) - { - try - { - await handler.InvokeAsync(this, (test.Context, null)).ConfigureAwait(false); - } - catch (Exception ex) - { - (cleanupExceptions ??= []).Add(ex); - } - } + cleanupExceptions = await scopes.CompleteAsync(cleanupExceptions).ConfigureAwait(false); } #if NET diff --git a/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs b/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs index c880b403618..aacd2f6ede5 100644 --- a/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs +++ b/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs @@ -41,17 +41,13 @@ public static async ValueTask RaiseOnceAsync(AbstractExecutableTest test, TUnitF } // Tests bypassing the coordinator have no tracked graph to release. Release their row // scopes here; the coordinator dispatches these after its depth-ordered graph cleanup. - if (disposeDataRow && test.Context.InternalEventsIfCreated?.OnDataRowDispose is { } cleanup) + if (disposeDataRow && test.Context.InternalEventsIfCreated?.DataRowScopes is { } scopes) { - foreach (var invocation in cleanup.InvocationList) + if (await scopes.CompleteAsync().ConfigureAwait(false) is { } exceptions) { - try + foreach (var exception in exceptions) { - await invocation.InvokeAsync(test.Context, (test.Context, null)).ConfigureAwait(false); - } - catch (Exception ex) - { - await logger.LogErrorAsync($"Error during row cleanup for {test.TestId}: {ex}").ConfigureAwait(false); + await logger.LogErrorAsync($"Error during row cleanup for {test.TestId}: {exception}").ConfigureAwait(false); } } } diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 654445fce3a..c7898a87bb3 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -11,11 +11,11 @@ public async Task ClaimedRowDoesNotTransferCleanupToLaterSkippedTest() { var original = CreateContext(); var disposals = 0; - original.Events.OnDataRowDispose += (_, _) => + (original.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { disposals++; return default; - }; + })); var row = new TestBuilder.UnclaimedClassRow([new object()], null, original); var runnable = CreateContext(); await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must use saved row"), runnable); @@ -33,11 +33,11 @@ public async Task UnclaimedRowTransfersCleanupToSkippedTest() { var original = CreateContext(); var disposals = 0; - original.Events.OnDataRowDispose += (_, _) => + (original.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { disposals++; return default; - }; + })); var row = new TestBuilder.UnclaimedClassRow([new object()], null, original); var skipped = CreateContext(); row.TransferCleanupTo(skipped); @@ -51,11 +51,11 @@ public async Task LentRowKeepsScopeUntilSessionCleanupEvenWhenNextFactoryThrows( { var original = CreateContext(); var disposals = 0; - original.Events.OnDataRowDispose += (_, _) => + (original.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { disposals++; return default; - }; + })); var row = new TestBuilder.UnclaimedClassRow([new object()], null, original); var session = CreateContext(); row.LendToTemporaryInstance(session); @@ -81,11 +81,11 @@ public async Task EnumerationFailureOnlyDisposesUnclaimedClassScope(bool claimed { var enumeration = CreateContext(); var disposals = 0; - enumeration.Events.OnDataRowDispose += (_, _) => + (enumeration.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { disposals++; return default; - }; + })); var row = new TestBuilder.UnclaimedClassRow([new object()], null, enumeration); var runnable = CreateContext(); if (claimed) @@ -108,11 +108,11 @@ public async Task ClassEnumerationFailurePreservesSeparateFactoryCleanup() var row = new TestBuilder.UnclaimedClassRow([new object()], null, enumeration); var factoryContext = CreateContext(); var disposals = 0; - factoryContext.Events.OnDataRowDispose += (_, _) => + (factoryContext.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { disposals++; return default; - }; + })); var failed = row.CreateFailureContext(factoryContext); await DisposeRow(failed); @@ -259,11 +259,11 @@ public async Task ConcurrentTemporaryRowsKeepEverySessionCleanup() var disposals = 0; foreach (var context in contexts) { - context.Events.OnDataRowDispose += (_, _) => + (context.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { Interlocked.Increment(ref disposals); return default; - }; + })); } Parallel.ForEach(contexts, context => new TestBuilder.UnclaimedClassRow([new object()], null, context).LendToTemporaryInstance(session)); @@ -294,11 +294,11 @@ private sealed class ThrowingClassSource : Attribute, IDataSourceAttribute await Task.CompletedTask; yield return () => { - metadata.TestBuilderContext.Current.Events.OnDataRowDispose += (_, _) => + (metadata.TestBuilderContext.Current.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { Disposals++; return default; - }; + })); return Task.FromResult([new object()]); }; if (ThrowAfterRow) @@ -521,12 +521,10 @@ private sealed class ThrowingBeforeRowSource : Attribute, IDataSourceAttribute private static async Task DisposeTestRow(TestContext context) { - if (context.InternalEventsIfCreated?.OnDataRowDispose is { } cleanup) + if (context.InternalEventsIfCreated?.DataRowScopes is { } scopes && + await scopes.CompleteAsync() is { } exceptions) { - foreach (var handler in cleanup.InvocationList) - { - await handler.InvokeAsync(context, (context, null)); - } + throw new AggregateException(exceptions); } } @@ -537,12 +535,15 @@ private static async Task DisposeTestRow(TestContext context) private static async Task DisposeRow(TestBuilderContext context) { - if (context.EventsIfCreated?.OnDataRowDispose is { } cleanup) + if (context.EventsIfCreated?.DataRowScopes is { } scopes && + await scopes.CompleteAsync() is { } exceptions) { - foreach (var handler in cleanup.InvocationList) - { - await handler.InvokeAsync(TestContext.Current!, (TestContext.Current!, null)); - } + throw new AggregateException(exceptions); } } + + private sealed class CallbackScope(Func dispose) : IAsyncDisposable + { + public ValueTask DisposeAsync() => dispose(); + } } diff --git a/tests/TUnit.UnitTests/DataRowScopeCollectionTests.cs b/tests/TUnit.UnitTests/DataRowScopeCollectionTests.cs new file mode 100644 index 00000000000..f0ebbff0e94 --- /dev/null +++ b/tests/TUnit.UnitTests/DataRowScopeCollectionTests.cs @@ -0,0 +1,76 @@ +using TUnit.Core; + +namespace TUnit.UnitTests; + +public class DataRowScopeCollectionTests +{ + [Test] + public async Task ReleaseUsesReferenceIdentityAndLeavesUnrelatedScopesAlive() + { + var scopes = new DataRowScopeCollection(); + var first = new Scope(); + var second = new Scope(); + var firstValue = new EqualValue(); + scopes.RegisterObject(scopes.Register(first), firstValue); + scopes.RegisterObject(scopes.Register(second), new EqualValue()); + + await scopes.ReleaseAsync(firstValue); + await Assert.That(first.DisposeCount).IsEqualTo(1); + await Assert.That(second.DisposeCount).IsEqualTo(0); + await scopes.CompleteAsync(); + await Assert.That(first.DisposeCount).IsEqualTo(1); + await Assert.That(second.DisposeCount).IsEqualTo(1); + } + + [Test] + public async Task SharedResolvedObjectReleasesAllOwnersOnceAcrossClones() + { + var scopes = new DataRowScopeCollection(); + var first = new Scope(); + var second = new Scope(); + var value = new object(); + scopes.RegisterObject(scopes.Register(first), value); + scopes.RegisterObject(scopes.Register(second), value); + var clone = scopes.Clone(); + + await clone.ReleaseAsync(value); + await scopes.CompleteAsync(); + await clone.CompleteAsync(); + await Assert.That(first.DisposeCount).IsEqualTo(1); + await Assert.That(second.DisposeCount).IsEqualTo(1); + } + + [Test] + public async Task ThrowingScopeDoesNotPreventOtherOwnersFromCompleting() + { + var scopes = new DataRowScopeCollection(); + var failed = new Scope { ThrowOnDispose = true }; + var successful = new Scope(); + scopes.Register(failed); // A factory may fail before returning an object. + scopes.Register(successful); + + var errors = await scopes.CompleteAsync(); + await Assert.That(errors!.Count).IsEqualTo(1); + await Assert.That(errors[0].Message).IsEqualTo("Scope failed"); + await Assert.That(failed.DisposeCount).IsEqualTo(1); + await Assert.That(successful.DisposeCount).IsEqualTo(1); + await Assert.That(await scopes.CompleteAsync()).IsNull(); + } + + private sealed class Scope : IDisposable + { + public int DisposeCount; + public bool ThrowOnDispose; + + public void Dispose() + { + DisposeCount++; + if (ThrowOnDispose) + { + throw new InvalidOperationException("Scope failed"); + } + } + } + + private sealed record EqualValue; +} diff --git a/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs index a950c725ac3..e30f371cdd4 100644 --- a/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs +++ b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs @@ -22,14 +22,14 @@ public async Task StaticScopeOwnsServiceUntilSessionCleanup() // Matching-object notification and the final sweep must not dispose the same scope twice. await Assert.That(source.Scope.DisposeCount).IsEqualTo(1); await Assert.That(service.DisposeCount).IsEqualTo(1); - await Assert.That(events.OnDataRowDispose).IsNull(); + await Assert.That(events.DataRowScopes).IsNull(); var laterSource = new ScopeSource(); var laterService = laterSource.Resolve(events); await StaticPropertyHandler.DisposeStaticPropertiesAsync([laterService], events, tracker, []); await Assert.That(laterSource.Scope.DisposeCount).IsEqualTo(1); await Assert.That(source.Scope.DisposeCount).IsEqualTo(1); - await Assert.That(events.OnDataRowDispose).IsNull(); + await Assert.That(events.DataRowScopes).IsNull(); } [Test] @@ -60,7 +60,7 @@ public async Task FailedStaticFactoryScopeIsReleasedAndOtherScopesStillDispose() await Assert.That(failed.Scope.DisposeCount).IsEqualTo(1); await Assert.That(successful.Scope.DisposeCount).IsEqualTo(1); await Assert.That(service.DisposeCount).IsEqualTo(1); - await Assert.That(events.OnDataRowDispose).IsNull(); + await Assert.That(events.DataRowScopes).IsNull(); await Assert.That(exceptions.Count).IsEqualTo(1); await Assert.That(exceptions[0].Message).IsEqualTo("Scope cleanup failure"); } From 001788590ba52adbf416d2fba777ff6ea39c36e7 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:29:31 +0000 Subject: [PATCH 21/27] fix: retain lazy constructor event sharing for #7308 --- docs/docs/execution/retrying.md | 4 ++ src/TUnit.Core/DataRowScopeCollection.cs | 2 +- src/TUnit.Engine/Building/TestBuilder.cs | 12 ++-- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 67 +++++++++++++++++++ 4 files changed, 76 insertions(+), 9 deletions(-) diff --git a/docs/docs/execution/retrying.md b/docs/docs/execution/retrying.md index 47386052542..9a038744813 100644 --- a/docs/docs/execution/retrying.md +++ b/docs/docs/execution/retrying.md @@ -94,3 +94,7 @@ So the order of precedence is: 1. Method 1. Class 1. Assembly + +## Retry event handlers + +Handlers subscribed through `TestBuilderContext.Events.OnTestRetry` receive the upcoming, one-based retry number after backoff and cancellation checks. If a handler throws, retry processing stops and the failure propagates. If cancellation was already accepted, the test remains cancelled instead. diff --git a/src/TUnit.Core/DataRowScopeCollection.cs b/src/TUnit.Core/DataRowScopeCollection.cs index fea9da6a4dd..7ad02980e90 100644 --- a/src/TUnit.Core/DataRowScopeCollection.cs +++ b/src/TUnit.Core/DataRowScopeCollection.cs @@ -7,7 +7,7 @@ namespace TUnit.Core; internal sealed class DataRowScopeCollection { private readonly List _owners = []; - private readonly Dictionary> _objects = new(ReferenceEqualityComparer.Instance); + private readonly Dictionary> _objects = new(Helpers.ReferenceEqualityComparer.Instance); internal ScopeOwner Register(object? scope) { diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index c177ba9dca8..11a7da875a2 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -520,10 +520,8 @@ public async ValueTask> BuildTestsFromMetada // Shares the per-iteration bag lazily; it is only allocated if something reads it. testSpecificContext.ShareStateBagWith(contextAccessor.Current); - if (contextAccessor.Current.EventsIfCreated is { } events) - { - testSpecificContext.Events = events; - } + // The instance factory captures this context and may subscribe only at execution. + testSpecificContext.ShareEventsWith(contextAccessor.Current); } var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken); @@ -2706,10 +2704,8 @@ private async Task CreateInstanceForMethodDataSources( // Shares the per-iteration bag lazily; it is only allocated if something reads it. testSpecificContext.ShareStateBagWith(contextAccessor.Current); - if (contextAccessor.Current.EventsIfCreated is { } events) - { - testSpecificContext.Events = events; - } + // The instance factory captures this context and may subscribe only at execution. + testSpecificContext.ShareEventsWith(contextAccessor.Current); var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index c7898a87bb3..92100f6c49c 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -6,6 +6,73 @@ namespace TUnit.UnitTests; public class ClassRowCleanupTests { + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task InstanceConstructorSubscriptionsReachExecutableRow(bool streaming) + { + var current = TestContext.Current!; + var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; + var metadata = new TestMetadata + { + TestClassType = typeof(ClassRowCleanupTests), + TestMethodName = nameof(InstanceConstructorSubscriptionsReachExecutableRow), + TestName = "Lazy constructor event sharing regression", + FilePath = "Unknown", + LineNumber = 0, + AttributeFactory = () => [new ClassConstructorAttribute()], + MethodMetadata = current.TestDetails.MethodMetadata, + DataSources = [new ArgumentsAttribute(streaming)], + ClassDataSources = [], + PropertyDataSources = [], + InstanceFactory = (_, _) => new ClassRowCleanupTests(), + InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask + }; + var tests = new List(); + try + { + if (streaming) + { + await foreach (var test in builder.BuildTestsStreamingAsync(metadata)) + tests.Add(test); + } + else + { + tests.AddRange(await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))); + } + await Assert.That(tests.Count).IsEqualTo(1); + var executable = tests[0]; + await executable.CreateInstanceAsync(); + await Assert.That(executable.Context.InternalEventsIfCreated?.OnDispose).IsNotNull(); + foreach (var invocation in executable.Context.InternalEvents.OnDispose!.InvocationList) + await invocation.InvokeAsync(this, executable.Context); + await Assert.That(executable.Context.StateBag.Items["constructor-disposals"]).IsEqualTo(1); + } + finally + { + foreach (var test in tests) + { + test.Context.RemoveFromRegistry(); + test.Context.Dispose(); + } + } + } + + public sealed class LateEventConstructor : TUnit.Core.Interfaces.IClassConstructor + { + public Task Create( + [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)] Type type, + ClassConstructorMetadata metadata) + { + metadata.TestBuilderContext.Events.OnDispose += (_, context) => + { + context.StateBag.Items["constructor-disposals"] = 1; + return default; + }; + return Task.FromResult(new ClassRowCleanupTests()); + } + } + [Test] public async Task ClaimedRowDoesNotTransferCleanupToLaterSkippedTest() { From 08df3028a13c654f07181c66d056a0140a2df919 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:40:08 +0000 Subject: [PATCH 22/27] fix: retain rejected row cleanup and encapsulate contexts (#7308) --- src/TUnit.Core/AsyncEvent.cs | 9 ++ src/TUnit.Core/Interfaces/ITestEvents.cs | 3 + src/TUnit.Core/TestBuilderContext.cs | 24 +++ src/TUnit.Core/TestContextEvents.cs | 28 ++++ src/TUnit.Engine/Building/TestBuilder.cs | 148 ++++-------------- .../Services/StaticPropertyHandler.cs | 9 +- .../Services/TestExecution/RetryHelper.cs | 2 +- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 40 +++++ .../EventReceiverRegistrationTests.cs | 21 +++ 9 files changed, 156 insertions(+), 128 deletions(-) diff --git a/src/TUnit.Core/AsyncEvent.cs b/src/TUnit.Core/AsyncEvent.cs index 35635ac1464..22167a52c0f 100644 --- a/src/TUnit.Core/AsyncEvent.cs +++ b/src/TUnit.Core/AsyncEvent.cs @@ -54,6 +54,15 @@ public class AsyncEvent _handlers = _handlers is null ? null : [.. _handlers] }; + internal void AddMissingFrom(AsyncEvent source) + { + foreach (var invocation in source.InvocationList) + { + if (_handlers?.Contains(invocation) != true) + (_handlers ??= []).Insert(FindInsertionIndex(invocation.Order), invocation); + } + } + /// /// Represents a single invocation of an async event handler. /// diff --git a/src/TUnit.Core/Interfaces/ITestEvents.cs b/src/TUnit.Core/Interfaces/ITestEvents.cs index d7401819759..77580cff2eb 100644 --- a/src/TUnit.Core/Interfaces/ITestEvents.cs +++ b/src/TUnit.Core/Interfaces/ITestEvents.cs @@ -34,16 +34,19 @@ public interface ITestEvents /// /// Gets the event that is raised before the test method is invoked. /// + /// Handler failures propagate and prevent the test method from running. AsyncEvent? OnTestStart { get; } /// /// Gets the event that is raised after the test method has completed. /// + /// Handler failures join the teardown exception collection, alongside receiver failures. AsyncEvent? OnTestEnd { get; } /// /// Gets the event that is raised if the test was skipped. /// + /// Handler failures propagate. AsyncEvent? OnTestSkipped { get; } /// diff --git a/src/TUnit.Core/TestBuilderContext.cs b/src/TUnit.Core/TestBuilderContext.cs index 64dcfbc9169..217b1467d88 100644 --- a/src/TUnit.Core/TestBuilderContext.cs +++ b/src/TUnit.Core/TestBuilderContext.cs @@ -141,6 +141,30 @@ internal void ShareEventsWith(TestBuilderContext source) /// internal Attribute[]? InitializedAttributes { get; set; } + // Child rows start with isolated state and no event subscriptions. Callers that build an + // executable view can explicitly share the state/events with their factory context instead. + internal TestBuilderContext CreateChild(IDataSourceAttribute? classDataSource, IDataSourceAttribute? dataSource = null, bool shareFactoryContext = false) + { + var child = new TestBuilderContext + { + TestMetadata = TestMetadata, + InitializedAttributes = InitializedAttributes, + ClassConstructor = ClassConstructor, + ClassDataSourceAttribute = classDataSource, + DataSourceAttribute = dataSource + }; + if (shareFactoryContext) + { + child.ShareStateBagWith(this); + child.ShareEventsWith(this); + } + else + { + CopyStateBagTo(child); + } + return child; + } + public void RegisterForInitialization(object? obj) { Events.OnInitialize += async (sender, args) => diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 3d5f495569d..21d1eb3fc66 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -19,6 +19,34 @@ public class TestContextEvents : ITestEvents OnTestRetry = OnTestRetry?.Clone() }; + private object? _scopeLock; + + internal void AddDataRowScopes(DataRowScopeCollection scopes) + { + lock (LazyInitializer.EnsureInitialized(ref _scopeLock)!) + { + (DataRowScopes ??= new()).AddRange(scopes); + } + } + + internal DataRowScopeCollection? DetachDataRowScopes() + { + lock (LazyInitializer.EnsureInitialized(ref _scopeLock)!) + { + var scopes = DataRowScopes; + DataRowScopes = null; + return scopes; + } + } + + internal void AddCleanupFrom(TestContextEvents source) + { + if (source.DataRowScopes is { } scopes) + AddDataRowScopes(scopes); + if (source.OnDispose is { } onDispose) + (OnDispose ??= new()).AddMissingFrom(onDispose); + } + // Clones share once-only scope owners while keeping row ownership collections isolated. internal DataRowScopeCollection? DataRowScopes { get; set; } diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 11a7da875a2..614f3a25004 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -212,14 +212,7 @@ public async ValueTask> BuildTestsFromMetada foreach (var classDataSource in await GetDataSourcesAsync(metadata.ClassDataSources, cancellationToken)) { activeClassRow = null; - contextAccessor.Current = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - InitializedAttributes = attributes, - ClassConstructor = testBuilderContext.ClassConstructor, - ClassDataSourceAttribute = classDataSource - }; - testBuilderContext.CopyStateBagTo(contextAccessor.Current); + contextAccessor.Current = testBuilderContext.CreateChild(classDataSource, null); var classSourceContext = contextAccessor.Current; classDataAttributeIndex++; @@ -239,26 +232,12 @@ public async ValueTask> BuildTestsFromMetada // Keep the first factory's subscriptions with its saved row, rather than // leaving them on the previous test's per-row context. - contextAccessor.Current = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - InitializedAttributes = attributes, - ClassConstructor = testBuilderContext.ClassConstructor, - ClassDataSourceAttribute = classDataSource - }; - classSourceContext.CopyStateBagTo(contextAccessor.Current); + contextAccessor.Current = classSourceContext.CreateChild(classDataSource, null); // A new factory owns its own cleanup, even if it throws before producing a row. activeClassRow = null; // Keep constructor-factory state on its saved row, outside the enumeration baseline. - var classRowEnumerationContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - InitializedAttributes = attributes, - ClassConstructor = contextAccessor.Current.ClassConstructor, - ClassDataSourceAttribute = classDataSource - }; - contextAccessor.Current.CopyStateBagTo(classRowEnumerationContext); + var classRowEnumerationContext = contextAccessor.Current.CreateChild(classDataSource, null); var (classData, firstClassRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); // No test holds this first fetch yet. The first test built from this class row takes it @@ -334,16 +313,7 @@ public async ValueTask> BuildTestsFromMetada { // Update context BEFORE calling data factories so they track objects in the right context // StateBag and Events are lazy-initialized for performance - contextAccessor.Current = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - DataSourceAttribute = methodDataSource, - ClassDataSourceAttribute = classDataSource, - InitializedAttributes = testBuilderContext.InitializedAttributes, - ClassConstructor = testBuilderContext.ClassConstructor - }; - - enumerationContext.CopyStateBagTo(contextAccessor.Current); + contextAccessor.Current = enumerationContext.CreateChild(classDataSource, methodDataSource); var (classDataUnwrapped, classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory, contextAccessor.Current); classData = classDataUnwrapped; @@ -391,7 +361,7 @@ public async ValueTask> BuildTestsFromMetada { // Skip this data source as it's not compatible with the expected types. // No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata); + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); continue; } } @@ -509,19 +479,7 @@ public async ValueTask> BuildTestsFromMetada else { // Events is lazy-initialized; explicitly share StateBag from per-iteration context - testSpecificContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - ClassConstructor = testBuilderContext.ClassConstructor, - DataSourceAttribute = contextAccessor.Current.DataSourceAttribute, - ClassDataSourceAttribute = classDataSource, - InitializedAttributes = attributes - }; - - // Shares the per-iteration bag lazily; it is only allocated if something reads it. - testSpecificContext.ShareStateBagWith(contextAccessor.Current); - // The instance factory captures this context and may subscribe only at execution. - testSpecificContext.ShareEventsWith(contextAccessor.Current); + testSpecificContext = contextAccessor.Current.CreateChild(classDataSource, contextAccessor.Current.DataSourceAttribute, shareFactoryContext: true); } var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken); @@ -587,16 +545,7 @@ public async ValueTask> BuildTestsFromMetada UnreceivedClassRowObjects = lentClassRowObjects }; - var testSpecificContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - ClassConstructor = testBuilderContext.ClassConstructor, - DataSourceAttribute = methodDataSource, - ClassDataSourceAttribute = classDataSource, - InitializedAttributes = attributes - }; - - skippedRowContext.CopyStateBagTo(testSpecificContext); + var testSpecificContext = skippedRowContext.CreateChild(classDataSource, methodDataSource); testSpecificContext.Events = skippedRowContext.EventsIfCreated?.Clone() ?? new(); var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); @@ -678,15 +627,7 @@ public async ValueTask> BuildTestsFromMetada // enumerated — only ClassDataSourceAttribute is populated. The class attribute // is already present in the initialized attributes (it is declared on the class), // so nothing is lost by leaving the method slot empty. - var testSpecificContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - ClassConstructor = testBuilderContext.ClassConstructor, - ClassDataSourceAttribute = classDataSource, - InitializedAttributes = attributes - }; - - testBuilderContext.CopyStateBagTo(testSpecificContext); + var testSpecificContext = testBuilderContext.CreateChild(classDataSource, null); var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); test.Context.SkipReason = skipReason; @@ -1122,6 +1063,7 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met private TestBuilderContext _rowContext = rowContext; // Snapshot before any method factory can mutate the class subscriptions. private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); + private TestContextEvents? _rejectedCleanup; /// /// Takes the unclaimed objects, or fetches a new row from when a @@ -1179,15 +1121,25 @@ private void ApplySavedContextTo(TestBuilderContext context) { context.Events = savedEvents.Clone(); } + if (_rejectedCleanup is { } cleanup) + { + context.Events.AddCleanupFrom(cleanup); + } } /// /// Hands back objects that were taken but that no test ended up holding, so the next test takes them. /// - public void Return(object?[] data, TestDataRowMetadata? metadata) + public void Return(object?[] data, TestDataRowMetadata? metadata, TestContextEvents? rejectedEvents) { _data = data; _metadata = metadata; + // Only cleanup follows a rejected method row. Its other lifecycle handlers must + // never become constructor subscriptions on later compatible rows. + if (rejectedEvents is not null) + { + (_rejectedCleanup ??= new()).AddCleanupFrom(rejectedEvents); + } } /// @@ -1226,6 +1178,7 @@ public void Clear() _data = null; _metadata = null; _lent = null; + _rejectedCleanup = null; } /// @@ -1241,11 +1194,7 @@ public void LendToTemporaryInstance(TestBuilderContext? lifetimeContext = null) { lifetimeContext ??= TestSessionContext.GlobalStaticPropertyContext; var lifetimeEvents = lifetimeContext.Events; - // Builders run concurrently. Protect collection creation and all ownership transfers. - lock (lifetimeEvents) - { - (lifetimeEvents.DataRowScopes ??= new()).AddRange(scopes); - } + lifetimeEvents.AddDataRowScopes(scopes); } _events = null; _data = null; @@ -2305,14 +2254,7 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( var classDataAttributeIndex = 0; foreach (var classDataSource in await GetDataSourcesAsync(metadata.ClassDataSources, cancellationToken)) { - var classSourceContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - InitializedAttributes = attributes, - ClassConstructor = baseContext.ClassConstructor, - ClassDataSourceAttribute = classDataSource - }; - baseContext.CopyStateBagTo(classSourceContext); + var classSourceContext = baseContext.CreateChild(classDataSource, null); contextAccessor.Current = classSourceContext; classDataAttributeIndex++; var classDataLoopIndex = 0; @@ -2329,24 +2271,10 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( cancellationToken.ThrowIfCancellationRequested(); classDataLoopIndex++; - contextAccessor.Current = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - InitializedAttributes = attributes, - ClassConstructor = baseContext.ClassConstructor, - ClassDataSourceAttribute = classDataSource - }; - classSourceContext.CopyStateBagTo(contextAccessor.Current); + contextAccessor.Current = classSourceContext.CreateChild(classDataSource, null); // Keep constructor-factory state on its saved row, outside the enumeration baseline. - var classRowEnumerationContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - InitializedAttributes = attributes, - ClassConstructor = contextAccessor.Current.ClassConstructor, - ClassDataSourceAttribute = classDataSource - }; - contextAccessor.Current.CopyStateBagTo(classRowEnumerationContext); + var classRowEnumerationContext = contextAccessor.Current.CreateChild(classDataSource, null); var (classData, firstClassRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); // The first test built from this class row takes this fetch instead of calling the factory @@ -2414,15 +2342,7 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( { cancellationToken.ThrowIfCancellationRequested(); - contextAccessor.Current = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - InitializedAttributes = attributes, - ClassConstructor = baseContext.ClassConstructor, - ClassDataSourceAttribute = classDataSource, - DataSourceAttribute = methodDataSource - }; - enumerationContext.CopyStateBagTo(contextAccessor.Current); + contextAccessor.Current = enumerationContext.CreateChild(classDataSource, methodDataSource); // Build and yield single test var test = await BuildSingleTestAsync( @@ -2603,7 +2523,7 @@ private async Task CreateInstanceForMethodDataSources( if (!IsDataCompatibleWithExpectedTypes(metadata, methodData)) { // Skip incompatible data. No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata); + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); return null; } } @@ -2693,19 +2613,7 @@ private async Task CreateInstanceForMethodDataSources( }; // Events is lazy-initialized; explicitly share StateBag from per-iteration context - var testSpecificContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - ClassConstructor = contextAccessor.Current.ClassConstructor, - DataSourceAttribute = methodDataSource ?? contextAccessor.Current.DataSourceAttribute, - ClassDataSourceAttribute = classDataSource ?? contextAccessor.Current.ClassDataSourceAttribute, - InitializedAttributes = attributes - }; - - // Shares the per-iteration bag lazily; it is only allocated if something reads it. - testSpecificContext.ShareStateBagWith(contextAccessor.Current); - // The instance factory captures this context and may subscribe only at execution. - testSpecificContext.ShareEventsWith(contextAccessor.Current); + var testSpecificContext = contextAccessor.Current.CreateChild(classDataSource ?? contextAccessor.Current.ClassDataSourceAttribute, methodDataSource ?? contextAccessor.Current.DataSourceAttribute, shareFactoryContext: true); var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); diff --git a/src/TUnit.Engine/Services/StaticPropertyHandler.cs b/src/TUnit.Engine/Services/StaticPropertyHandler.cs index 8d7eeed3640..07dfe268ca2 100644 --- a/src/TUnit.Engine/Services/StaticPropertyHandler.cs +++ b/src/TUnit.Engine/Services/StaticPropertyHandler.cs @@ -111,13 +111,8 @@ internal static async Task DisposeStaticPropertiesAsync( ObjectTracker objectTracker, List cleanupExceptions) { - DataRowScopeCollection? scopes; - lock (events) - { - // Detach before awaiting so a reused host cannot retain scopes from earlier sessions. - scopes = events.DataRowScopes; - events.DataRowScopes = null; - } + // Detach before awaiting so a reused host cannot retain scopes from earlier sessions. + var scopes = events.DetachDataRowScopes(); foreach (var staticProperty in staticProperties) { diff --git a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs index 89d9833191f..ac9a78ae3a7 100644 --- a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs +++ b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs @@ -113,7 +113,7 @@ public static async Task ExecuteWithRetry(TestContext testContext, Func { constructorDisposals++; return default; }; + var data = new object?[] { new object() }; + var row = new TestBuilder.UnclaimedClassRow(data, null, original); + // Two rejected method factories share the saved constructor, but register distinct cleanup. + for (var i = 0; i < 2; i++) + { + var rejected = CreateContext(); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse constructor"), rejected); + rejected.Events.OnDispose += (_, _) => { rejectedDisposals++; return default; }; + rejected.Events.OnTestStart += (_, _) => { rejectedStarts++; return default; }; + (rejected.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { scopeDisposals++; return default; })); + row.Return(data, null, rejected.Events); + } + var owner = CreateContext(); + if (failedRow) + row.TransferCleanupTo(owner); + else + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse constructor"), owner); + foreach (var handler in owner.Events.OnDispose!.InvocationList) + await handler.InvokeAsync(this, TestContext.Current!); + if (owner.Events.OnTestStart is { } starts) + foreach (var handler in starts.InvocationList) + await handler.InvokeAsync(this, TestContext.Current!); + await DisposeRow(owner); + await Assert.That(constructorDisposals).IsEqualTo(1); + await Assert.That(rejectedDisposals).IsEqualTo(2); + await Assert.That(scopeDisposals).IsEqualTo(2); + await Assert.That(rejectedStarts).IsEqualTo(0); + } + [Test] [Arguments(false)] [Arguments(true)] diff --git a/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs b/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs index dbef91b51f0..787666f248a 100644 --- a/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs +++ b/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs @@ -5,6 +5,27 @@ namespace TUnit.UnitTests; public class EventReceiverRegistrationTests { + [Test] + public async Task StartDelegateFailurePropagatesOriginalException() + { + var context = CreateContext(new OrdinaryObject(), []); + var failure = new InvalidOperationException("Start handler failed"); + context.InternalEvents.OnTestStart += (_, _) => throw failure; + try + { + var orchestrator = new EventReceiverOrchestrator(null!); + var thrown = await Assert.That(async () => + await orchestrator.InvokeTestStartEventReceiversAsync(context, CancellationToken.None)) + .Throws(); + await Assert.That(thrown).IsSameReferenceAs(failure); + } + finally + { + context.RemoveFromRegistry(); + context.Dispose(); + } + } + [Test] public void OrdinaryObjectsDoNotParticipateInReceiverDeduplication() { From b3435e80a45d5f106f1aa8a03ae160acecdf871e Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:45:45 +0000 Subject: [PATCH 23/27] fix: snapshot lifecycle delegate dispatch for #7308 --- .../Services/EventReceiverOrchestrator.cs | 6 +- .../EventReceiverRegistrationTests.cs | 80 +++++++++++++++++++ 2 files changed, 83 insertions(+), 3 deletions(-) diff --git a/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs b/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs index b64b4979c9d..42578aff947 100644 --- a/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs +++ b/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs @@ -199,7 +199,7 @@ private async ValueTask InvokeTestStartEventReceiversCore(TestContext context, C // Delegate events have no stage; dispatch once, with the default (late) receivers. if (stage != EventReceiverStage.Early && context.InternalEventsIfCreated?.OnTestStart is { } onStart) { - foreach (var handler in onStart.InvocationList) + foreach (var handler in onStart.InvocationList.ToArray()) { await handler.InvokeAsync(context, context); } @@ -319,7 +319,7 @@ private async ValueTask> InvokeTestEndEventReceiversCor if (stage != EventReceiverStage.Early && context.InternalEventsIfCreated?.OnTestEnd is { } onEnd) { - foreach (var handler in onEnd.InvocationList) + foreach (var handler in onEnd.InvocationList.ToArray()) { try { @@ -359,7 +359,7 @@ private async ValueTask InvokeTestSkippedEventReceiversCore(TestContext context, if (context.InternalEventsIfCreated?.OnTestSkipped is { } onSkipped) { - foreach (var handler in onSkipped.InvocationList) + foreach (var handler in onSkipped.InvocationList.ToArray()) { await handler.InvokeAsync(context, context); } diff --git a/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs b/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs index 787666f248a..ea5eceec6c3 100644 --- a/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs +++ b/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs @@ -1,3 +1,4 @@ +using NSubstitute; using TUnit.Core.Interfaces; using TUnit.Engine.Services; @@ -5,6 +6,85 @@ namespace TUnit.UnitTests; public class EventReceiverRegistrationTests { + [Test] + [Arguments("start")] + [Arguments("end")] + [Arguments("skipped")] + public async Task DelegateSubscriptionsDuringDispatchApplyToNextDispatch(string eventName) + { + var context = CreateContext(new OrdinaryObject(), []); + var calls = new List(); + var events = context.InternalEvents; + var selected = eventName switch + { + "start" => events.OnTestStart ??= new(), + "end" => events.OnTestEnd ??= new(), + _ => events.OnTestSkipped ??= new() + }; + selected += (_, _) => + { + calls.Add("first"); + selected += (_, _) => { calls.Add("added"); return ValueTask.CompletedTask; }; + return ValueTask.CompletedTask; + }; + selected += (_, _) => { calls.Add("last"); return ValueTask.CompletedTask; }; + try + { + var orchestrator = new EventReceiverOrchestrator(null!); + async Task Dispatch() + { + if (eventName == "start") + await orchestrator.InvokeTestStartEventReceiversAsync(context, CancellationToken.None); + else if (eventName == "end") + await orchestrator.InvokeTestEndEventReceiversAsync(context, CancellationToken.None); + else + await orchestrator.InvokeTestSkippedEventReceiversAsync(context, CancellationToken.None); + } + + await Dispatch(); + await Assert.That(string.Join(",", calls)).IsEqualTo("first,last"); + calls.Clear(); + await Dispatch(); + await Assert.That(string.Join(",", calls)).IsEqualTo("first,last,added"); + } + finally + { + context.RemoveFromRegistry(); + context.Dispose(); + } + } + + [Test] + public async Task EndDelegateMutationPreservesRemainingHandlersAndCollectedFailures() + { + var context = CreateContext(new OrdinaryObject(), []); + var failure = new InvalidOperationException("End handler failed"); + var lastRan = false; + context.InternalEvents.OnTestEnd += (_, _) => + { + context.InternalEvents.OnTestEnd += (_, _) => ValueTask.CompletedTask; + throw failure; + }; + context.InternalEvents.OnTestEnd += (_, _) => { lastRan = true; return ValueTask.CompletedTask; }; + var options = NSubstitute.Substitute.For(); + options.TryGetOptionArgumentList(NSubstitute.Arg.Any(), out NSubstitute.Arg.Any()!) + .Returns(call => { call[1] = new[] { "None" }; return true; }); + var logger = new TUnit.Engine.Logging.TUnitFrameworkLogger(null!, null!, null!, new LogLevelProvider(options)); + try + { + var orchestrator = new EventReceiverOrchestrator(logger); + var exceptions = await orchestrator.InvokeTestEndEventReceiversAsync(context, CancellationToken.None); + await Assert.That(lastRan).IsTrue(); + await Assert.That(exceptions.Count).IsEqualTo(1); + await Assert.That(exceptions[0]).IsSameReferenceAs(failure); + } + finally + { + context.RemoveFromRegistry(); + context.Dispose(); + } + } + [Test] public async Task StartDelegateFailurePropagatesOriginalException() { From 91a17f7ddb1b6e21e39e64ab5b84a0f45613899b Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 05:48:37 +0000 Subject: [PATCH 24/27] fix: retain rejected method-row cleanup state for #7308 --- src/TUnit.Engine/Building/TestBuilder.cs | 45 ++++++++++++++++--- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 37 +++++++++++---- 2 files changed, 68 insertions(+), 14 deletions(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 614f3a25004..a098bd958ec 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -361,7 +361,7 @@ public async ValueTask> BuildTestsFromMetada { // Skip this data source as it's not compatible with the expected types. // No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current); continue; } } @@ -1130,15 +1130,48 @@ private void ApplySavedContextTo(TestBuilderContext context) /// /// Hands back objects that were taken but that no test ended up holding, so the next test takes them. /// - public void Return(object?[] data, TestDataRowMetadata? metadata, TestContextEvents? rejectedEvents) + public void Return(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rejectedContext) { _data = data; _metadata = metadata; // Only cleanup follows a rejected method row. Its other lifecycle handlers must // never become constructor subscriptions on later compatible rows. - if (rejectedEvents is not null) - { - (_rejectedCleanup ??= new()).AddCleanupFrom(rejectedEvents); + if (rejectedContext.EventsIfCreated is { } rejectedEvents) + { + var cleanup = _rejectedCleanup ??= new(); + if (rejectedEvents.DataRowScopes is { } scopes) + cleanup.AddDataRowScopes(scopes); + + // Constructor callbacks already belong to the saved class row. Bind only + // method-row callbacks to their own state, rather than the next test's bag. + var callbacks = rejectedEvents.OnDispose?.InvocationList + .Where(invocation => _events?.OnDispose?.InvocationList.Contains(invocation) != true + && cleanup.OnDispose?.InvocationList.Contains(invocation) != true) + .ToArray(); + if (callbacks is { Length: > 0 }) + { + var saved = rejectedContext with { StateBag = new(rejectedContext.StateBag) }; + foreach (var callback in callbacks) + { + (cleanup.OnDispose ??= new()).Add(async (_, owner) => + { + // Rejected rows have no executable test. Give their cleanup a + // context with the owning state and the final test's metadata. + var context = new TestContext(owner.TestDetails.TestName, owner.ServiceProvider, + owner.ClassContext, saved, owner.CancellationToken); + context.Metadata.TestDetails = owner.TestDetails; + try + { + await callback.InvokeAsync(context, context); + } + finally + { + context.RemoveFromRegistry(); + context.Dispose(); + } + }, callback.Order); + } + } } } @@ -2523,7 +2556,7 @@ private async Task CreateInstanceForMethodDataSources( if (!IsDataCompatibleWithExpectedTypes(metadata, methodData)) { // Skip incompatible data. No test holds the class row's objects, so the next test takes them. - unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current); return null; } } diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 2f765330369..5600f00e4a7 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -24,22 +24,43 @@ public async Task RejectedMethodRowsRetainCleanupWithoutLifecycleSubscriptions(b { var rejected = CreateContext(); await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse constructor"), rejected); - rejected.Events.OnDispose += (_, _) => { rejectedDisposals++; return default; }; + var resource = new object(); + rejected.StateBag["rejected-resource"] = resource; + rejected.Events.OnDispose += async (_, context) => + { + await Assert.That(context.StateBag.Items["rejected-resource"]).IsSameReferenceAs(resource); + rejectedDisposals++; + }; rejected.Events.OnTestStart += (_, _) => { rejectedStarts++; return default; }; (rejected.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => { scopeDisposals++; return default; })); - row.Return(data, null, rejected.Events); + row.Return(data, null, rejected); } var owner = CreateContext(); + var ownerResource = new object(); + owner.StateBag["rejected-resource"] = ownerResource; if (failedRow) row.TransferCleanupTo(owner); else await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse constructor"), owner); - foreach (var handler in owner.Events.OnDispose!.InvocationList) - await handler.InvokeAsync(this, TestContext.Current!); - if (owner.Events.OnTestStart is { } starts) - foreach (var handler in starts.InvocationList) - await handler.InvokeAsync(this, TestContext.Current!); - await DisposeRow(owner); + var current = TestContext.Current!; + var executableContext = new TestContext("Cleanup owner", current.ServiceProvider, current.ClassContext, + owner, CancellationToken.None); + executableContext.Metadata.TestDetails = current.TestDetails; + try + { + foreach (var handler in owner.Events.OnDispose!.InvocationList) + await handler.InvokeAsync(executableContext, executableContext); + if (owner.Events.OnTestStart is { } starts) + foreach (var handler in starts.InvocationList) + await handler.InvokeAsync(executableContext, executableContext); + await DisposeRow(owner); + await Assert.That(executableContext.StateBag.Items["rejected-resource"]).IsSameReferenceAs(ownerResource); + } + finally + { + executableContext.RemoveFromRegistry(); + executableContext.Dispose(); + } await Assert.That(constructorDisposals).IsEqualTo(1); await Assert.That(rejectedDisposals).IsEqualTo(2); await Assert.That(scopeDisposals).IsEqualTo(2); From eafd1f36f12885e030e42d7f620bf21df2c56099 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 07:59:45 +0000 Subject: [PATCH 25/27] fix: allow registration-hold cleanup without a test context (#7308) --- src/TUnit.Core/Tracking/ObjectTracker.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/TUnit.Core/Tracking/ObjectTracker.cs b/src/TUnit.Core/Tracking/ObjectTracker.cs index ee2da0f28c7..f1c973f9127 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -263,7 +263,7 @@ private static void RemoveObjectsNotIn(SortedList>? tracked foreach (var obj in bucket) { - if (testContext.InternalEventsIfCreated?.DataRowScopes is { } scopes) + if (testContext?.InternalEventsIfCreated?.DataRowScopes is { } scopes) { cleanupExceptions = await scopes.ReleaseAsync(obj, cleanupExceptions).ConfigureAwait(false); } From 2f39ed7f8807e653318be9c5978c98c38b1cc801 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 08:49:17 +0000 Subject: [PATCH 26/27] fix: refresh constructor state baseline for refetched rows (#7308) --- src/TUnit.Core/TestContextEvents.cs | 3 +- src/TUnit.Engine/Building/TestBuilder.cs | 7 ++-- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 40 +++++++++++++++++++ 3 files changed, 46 insertions(+), 4 deletions(-) diff --git a/src/TUnit.Core/TestContextEvents.cs b/src/TUnit.Core/TestContextEvents.cs index 21d1eb3fc66..911d4a17924 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -3,7 +3,8 @@ namespace TUnit.Core; /// -/// Test context events container +/// Test context events container. Registration, start and skipped handler failures propagate +/// and stop the remaining handlers. End handler failures are collected with teardown failures. /// public class TestContextEvents : ITestEvents { diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 68987e0f752..0f7e6b0f085 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1055,9 +1055,9 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met private object?[]? _lent; private readonly TestBuilderContext _enumerationContext = enumerationContext ?? rowContext; - // Method enumeration mutates _enumerationContext after this row is saved. - // Compare constructor changes against its original state, never that live context. - private readonly Dictionary? _constructorBaseline = enumerationContext?.HasStateBag == true + // Compare each saved constructor row against its own pre-factory state. + // Method enumeration can change between constructor fetches. + private Dictionary? _constructorBaseline = enumerationContext?.HasStateBag == true ? new(enumerationContext.StateBag) : null; private TestBuilderContext _rowContext = rowContext; @@ -1083,6 +1083,7 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory, TestBuilderContext target) { + _constructorBaseline = target.HasStateBag ? new(target.StateBag) : null; var row = DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); _rowContext = target with { }; target.CopyStateBagTo(_rowContext); diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 5600f00e4a7..32e971ddd98 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -6,6 +6,46 @@ namespace TUnit.UnitTests; public class ClassRowCleanupTests { + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task RefetchedRejectedConstructorReplaysOnlyItsOwnStateChanges(bool initialState) + { + var enumeration = CreateContext(); + if (initialState) + enumeration.StateBag["method-row"] = new object(); + var original = enumeration with { }; + enumeration.CopyStateBagTo(original); + var data = new object?[] { new object() }; + var row = new TestBuilder.UnclaimedClassRow(data, null, original, enumeration); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), CreateContext()); + + var rejected = CreateContext(); + rejected.StateBag["method-row"] = new object(); + rejected.StateBag["removed-by-constructor"] = new object(); + rejected.StateBag["changed-by-constructor"] = new object(); + var constructorValue = new object(); + await row.TakeOrFetchAsync(() => + { + rejected.StateBag["added-by-constructor"] = constructorValue; + rejected.StateBag["changed-by-constructor"] = constructorValue; + rejected.StateBag.TryRemove("removed-by-constructor", out _); + return Task.FromResult(data); + }, rejected); + row.Return(data, null, rejected); + + var compatible = CreateContext(); + var methodValue = new object(); + compatible.StateBag["method-row"] = methodValue; + compatible.StateBag["removed-by-constructor"] = new object(); + compatible.StateBag["changed-by-constructor"] = new object(); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse rejected constructor"), compatible); + await Assert.That(compatible.StateBag["method-row"]).IsSameReferenceAs(methodValue); + await Assert.That(compatible.StateBag["added-by-constructor"]).IsSameReferenceAs(constructorValue); + await Assert.That(compatible.StateBag["changed-by-constructor"]).IsSameReferenceAs(constructorValue); + await Assert.That(compatible.StateBag.ContainsKey("removed-by-constructor")).IsFalse(); + } + [Test] [Arguments(false)] [Arguments(true)] From a454169c58337ad111982da5e4d9a19a321c129f Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 08:57:35 +0000 Subject: [PATCH 27/27] fix: isolate empty constructor state snapshots (#7308) --- src/TUnit.Engine/Building/TestBuilder.cs | 7 ++++- tests/TUnit.UnitTests/ClassRowCleanupTests.cs | 30 +++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 0f7e6b0f085..d57aa173956 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -1086,7 +1086,12 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met _constructorBaseline = target.HasStateBag ? new(target.StateBag) : null; var row = DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); _rowContext = target with { }; - target.CopyStateBagTo(_rowContext); + // Record cloning shares the bag, so even a materialized empty bag must + // be detached before a rejected method factory can mutate the target. + if (target.HasStateBag) + { + _rowContext.StateBag = new ConcurrentDictionary(target.StateBag); + } _events = target.EventsIfCreated?.Clone(); return row; } diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 32e971ddd98..fbee18abc1c 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -6,6 +6,36 @@ namespace TUnit.UnitTests; public class ClassRowCleanupTests { + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task EmptyRefetchedConstructorStateDoesNotCaptureRejectedMethodState(bool removesInheritedKey) + { + var data = new object?[] { new object() }; + var row = new TestBuilder.UnclaimedClassRow(data, null, CreateContext()); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), CreateContext()); + + var rejected = CreateContext(); + if (removesInheritedKey) + rejected.StateBag["removed-by-constructor"] = new object(); + await row.TakeOrFetchAsync(() => + { + // Materialize an empty bag, including the case where the constructor removes its last key. + rejected.StateBag.TryRemove("removed-by-constructor", out _); + return Task.FromResult(data); + }, rejected); + rejected.StateBag["method-row"] = new object(); + row.Return(data, null, rejected); + + var compatible = CreateContext(); + var methodValue = new object(); + compatible.StateBag["method-row"] = methodValue; + compatible.StateBag["removed-by-constructor"] = new object(); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse rejected constructor"), compatible); + await Assert.That(compatible.StateBag["method-row"]).IsSameReferenceAs(methodValue); + await Assert.That(compatible.StateBag.ContainsKey("removed-by-constructor")).IsEqualTo(!removesInheritedKey); + } + [Test] [Arguments(false)] [Arguments(true)]