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/AsyncEvent.cs b/src/TUnit.Core/AsyncEvent.cs index 34cedd51612..22167a52c0f 100644 --- a/src/TUnit.Core/AsyncEvent.cs +++ b/src/TUnit.Core/AsyncEvent.cs @@ -49,6 +49,20 @@ public class AsyncEvent { private List? _handlers; + internal AsyncEvent Clone() => new() + { + _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/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs index 0dcb3efaa38..7486bd92326 100644 --- a/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs +++ b/src/TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs @@ -16,18 +16,9 @@ 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.OnDispose += async (_, _) => - { - 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 dataGeneratorMetadata.MembersToGenerate .Select(m => m switch @@ -41,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..7ad02980e90 --- /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(Helpers.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/Interfaces/ITestEvents.cs b/src/TUnit.Core/Interfaces/ITestEvents.cs index a380b2e9bda..77580cff2eb 100644 --- a/src/TUnit.Core/Interfaces/ITestEvents.cs +++ b/src/TUnit.Core/Interfaces/ITestEvents.cs @@ -34,20 +34,25 @@ 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; } /// - /// 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/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 9ba1587ab67..911d4a17924 100644 --- a/src/TUnit.Core/TestContextEvents.cs +++ b/src/TUnit.Core/TestContextEvents.cs @@ -3,15 +3,65 @@ 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 { + internal TestContextEvents Clone() => new() + { + DataRowScopes = DataRowScopes?.Clone(), + OnDispose = OnDispose?.Clone(), + OnTestRegistered = OnTestRegistered?.Clone(), + OnInitialize = OnInitialize?.Clone(), + OnTestStart = OnTestStart?.Clone(), + OnTestEnd = OnTestEnd?.Clone(), + OnTestSkipped = OnTestSkipped?.Clone(), + 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; } + 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; } + /// + /// 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 6f5a91e9cf0..f1c973f9127 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -52,7 +52,6 @@ internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphPr // TryRemove guards against racing disposals (e.g. a late UntrackObject call) if (!s_trackedObjects.TryRemove(kvp.Key, out _) || IsExternallyOwned(kvp.Key)) { - // An object marked after it was counted belongs to its external owner, which disposes it. continue; } @@ -264,6 +263,11 @@ private static void RemoveObjectsNotIn(SortedList>? tracked foreach (var obj in bucket) { + if (testContext?.InternalEventsIfCreated?.DataRowScopes is { } scopes) + { + cleanupExceptions = await scopes.ReleaseAsync(obj, cleanupExceptions).ConfigureAwait(false); + } + try { var task = UntrackObject(obj, testContext); @@ -337,8 +341,7 @@ private void TrackObject(object? obj) private async ValueTask UntrackObject(object? obj, TestContext? testContext) { - // Every disposable is counted, including externally owned objects. Ownership changes only - // who disposes it, so each test always releases exactly the reference it took. + // Release any count acquired before another source marked the object externally owned. if (obj is not IDisposable and not IAsyncDisposable) { return; @@ -629,7 +632,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; } /// @@ -639,15 +642,19 @@ 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 counts references but leaves disposal to their owner. + // 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(); + // 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; /// - /// Marks as disposed by another owner, so the tracker counts references without disposing 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 71e59717e3b..d57aa173956 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -128,6 +128,8 @@ public async ValueTask> BuildTestsFromMetada } var tests = new List(); + TestBuilderContextAccessor? contextAccessor = null; + UnclaimedClassRow? activeClassRow = null; try { @@ -194,7 +196,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 @@ -209,6 +211,9 @@ public async ValueTask> BuildTestsFromMetada var classDataAttributeIndex = 0; foreach (var classDataSource in await GetDataSourcesAsync(metadata.ClassDataSources, cancellationToken)) { + activeClassRow = null; + contextAccessor.Current = testBuilderContext.CreateChild(classDataSource, null); + var classSourceContext = contextAccessor.Current; classDataAttributeIndex++; var classDataLoopIndex = 0; @@ -225,13 +230,22 @@ public async ValueTask> BuildTestsFromMetada hasAnyClassData = true; classDataLoopIndex++; - var (classData, firstClassRowMetadata, firstClassRowEvents) = await FetchFirstClassRowAsync( - classDataFactory, classDataSource, metadata, contextAccessor); + // Keep the first factory's subscriptions with its saved row, rather than + // leaving them on the previous test's per-row context. + 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 = 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 // 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, firstClassRowEvents); + var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, contextAccessor.Current, classRowEnumerationContext); + contextAccessor.Current = classRowEnumerationContext; + activeClassRow = unclaimedClassRow; #if NET // Register scope for class data objects from the simple path. @@ -245,6 +259,7 @@ public async ValueTask> BuildTestsFromMetada var needsInstanceForMethodDataSources = HasInstanceDataAccessor(metadata.DataSources); + var classEnumerationContext = contextAccessor.Current; object? instanceForMethodDataSources = null; try { @@ -265,7 +280,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; } @@ -292,20 +308,12 @@ 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 - contextAccessor.Current = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - DataSourceAttribute = methodDataSource, - ClassDataSourceAttribute = classDataSource, - InitializedAttributes = testBuilderContext.InitializedAttributes, - ClassConstructor = testBuilderContext.ClassConstructor - }; - - testBuilderContext.CopyStateBagTo(contextAccessor.Current); + contextAccessor.Current = enumerationContext.CreateChild(classDataSource, methodDataSource); var (classDataUnwrapped, classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory, contextAccessor.Current); classData = classDataUnwrapped; @@ -352,9 +360,8 @@ public async ValueTask> BuildTestsFromMetada if (!IsDataCompatibleWithExpectedTypes(metadata, methodData)) { // 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, - // with the events subscribed while this row was fetched. - unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current.EventsIfCreated); + // No test holds the class row's objects, so the next test takes them. + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current); continue; } } @@ -472,21 +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 data sources subscribed on the per-iteration context while this row was - // fetched (a DI scope's disposal, for example); the test raises them (#7205). - testSpecificContext.ShareEventsWith(contextAccessor.Current); + testSpecificContext = contextAccessor.Current.CreateChild(classDataSource, contextAccessor.Current.DataSourceAttribute, shareFactoryContext: true); } var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken); @@ -497,9 +490,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 @@ -510,7 +504,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 classRowEvents = unclaimedClassRow.TakeEvents(); + var skippedRowContext = unclaimedClassRow.CreateEnumerationFailureContext(contextAccessor.Current); unclaimedClassRow.Clear(); Type[] resolvedClassGenericArgs; @@ -530,7 +524,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, skippedRowContext); tests.Add(failedTest); } else @@ -551,21 +545,8 @@ public async ValueTask> BuildTestsFromMetada UnreceivedClassRowObjects = lentClassRowObjects }; - var testSpecificContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - ClassConstructor = testBuilderContext.ClassConstructor, - DataSourceAttribute = methodDataSource, - ClassDataSourceAttribute = classDataSource, - InitializedAttributes = attributes - }; - - testBuilderContext.CopyStateBagTo(testSpecificContext); - - if (classRowEvents is not null) - { - testSpecificContext.Events = classRowEvents; - } + var testSpecificContext = skippedRowContext.CreateChild(classDataSource, methodDataSource); + testSpecificContext.Events = skippedRowContext.EventsIfCreated?.Clone() ?? new(); var test = await BuildTestAsync(metadata, testData, testSpecificContext, cancellationToken: cancellationToken); test.Context.SkipReason = skipReason; @@ -574,9 +555,24 @@ 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); + contextAccessor.Current = classSourceContext; } } @@ -631,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; @@ -670,7 +658,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); + // 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.CreateEnumerationFailureContext(failureContext); + } + var failedTest = CreateFailedTestForDataGenerationError(metadata, ex, new TestDataCombination(), + methodData: activeClassRow?.TakeLentObjects(), rowContext: failureContext); tests.Add(failedTest); return tests; } @@ -1040,47 +1036,6 @@ public ValueTask MoveNextAsync() } } - /// - /// Fetches a class row before its method data sources are evaluated, against a context of its own, - /// so the events the data source subscribes while it creates the row's objects can travel with them - /// to the test that takes them (#7205). The context shares the state bag of the context the fetch used - /// to run against, which is current again once the fetch returns. - /// - private static async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata, TestContextEvents? Events)> FetchFirstClassRowAsync( - Func> classDataFactory, - IDataSourceAttribute classDataSource, - TestMetadata metadata, - TestBuilderContextAccessor contextAccessor) - { - if (classDataSource is NoDataSource) - { - // Yields one empty row and subscribes nothing. - var (emptyRow, emptyRowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); - return (emptyRow, emptyRowMetadata, null); - } - - var previousContext = contextAccessor.Current; - var fetchContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - ClassDataSourceAttribute = classDataSource, - InitializedAttributes = previousContext.InitializedAttributes, - ClassConstructor = previousContext.ClassConstructor - }; - fetchContext.ShareStateBagWith(previousContext); - - contextAccessor.Current = fetchContext; - try - { - var (data, rowMetadata) = DataUnwrapper.UnwrapWithMetadata(await classDataFactory() ?? []); - return (data, rowMetadata, fetchContext.EventsIfCreated); - } - finally - { - contextAccessor.Current = previousContext; - } - } - /// /// The objects of a class data row that were fetched but that no test holds yet. The builder fetches a /// class row once before it evaluates the method data sources, and its tests used to fetch it again, @@ -1092,103 +1047,197 @@ public ValueTask MoveNextAsync() /// from these objects and disposed once the method rows are read, so no test may receive them. They /// are lent to the instance instead, and the next test built from the row tracks them without /// receiving them, so they are still disposed. - /// - /// The events that the data source subscribed on the builder context while the row was first fetched - /// (such as the disposal of a dependency injection scope) travel with these objects, so the test - /// that takes them also raises those events (#7205). Lent objects do not carry their events: see - /// . - /// /// - private sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestContextEvents? events) + 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 TestContextEvents? _events = events; + + private readonly TestBuilderContext _enumerationContext = enumerationContext ?? rowContext; + // 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; + // 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 - /// test already holds them. Any events of the unclaimed objects move to - /// first, the context the row is fetched against, so a new fetch - /// adds its own subscriptions to the same container. + /// test already holds them. /// - public ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> TakeOrFetchAsync( - Func> classDataFactory, - TestBuilderContext builderContext) + public ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> TakeOrFetchAsync(Func> classDataFactory, TestBuilderContext context) { - if (TakeEvents() is { } events) - { - // The context is fresh, so assigning cannot drop a subscription made before the take. Fail - // loudly rather than silently drop subscriptions (a scope's disposal) if that ever changes. - if (builderContext.EventsIfCreated is not null) - { - throw new InvalidOperationException("A class row's events cannot replace events the builder context already has."); - } - - builderContext.Events = events; - } - if (_data is { } data) { + ApplySavedContextTo(context); var row = (data, _metadata); Clear(); return new ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)>(row); } - return FetchAsync(classDataFactory); + return FetchAsync(classDataFactory, context); + + 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 { }; + // 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; + } + } - static async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory) - => DataUnwrapper.UnwrapWithMetadata(await factory() ?? []); + 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(); + } + if (_rejectedCleanup is { } cleanup) + { + context.Events.AddCleanupFrom(cleanup); + } } /// - /// Hands back objects, and the events of the context they were taken against, that no test ended up - /// holding, so the next test takes them. + /// 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, TestBuilderContext rejectedContext) { _data = data; _metadata = metadata; - _events = events; + // Only cleanup follows a rejected method row. Its other lifecycle handlers must + // never become constructor subscriptions on later compatible rows. + 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); + } + } + } } /// - /// Takes the events subscribed while the unclaimed objects were fetched, for the test that holds - /// those objects. + /// Preserves row callbacks and state when a skipped or failed test takes ownership of the row. /// - public TestContextEvents? TakeEvents() + public void TransferCleanupTo(TestBuilderContext target) { - var events = _events; - _events = null; - return events; + if (_data is not null) + { + ApplySavedContextTo(target); + } } - /// - /// Marks the unclaimed objects as held by a test that did not take them through . - /// + 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 { }; + enumerationContext.CopyStateBagTo(failureContext); + failureContext.Events = enumerationContext.EventsIfCreated?.Clone() ?? new(); + failureContext.Events.DataRowScopes = null; + TransferCleanupTo(failureContext); + return failureContext; + } + + /// Marks the unclaimed objects as held by a test. public void Clear() { _data = null; _metadata = null; _lent = null; - _events = null; + _rejectedCleanup = null; } /// /// Marks the unclaimed objects as used by a temporary instance, so no test receives them, but the /// next test tracks them through or . /// - public void LendToTemporaryInstance() + 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?.DataRowScopes is { } scopes) + { + lifetimeContext ??= TestSessionContext.GlobalStaticPropertyContext; + var lifetimeEvents = lifetimeContext.Events; + lifetimeEvents.AddDataRowScopes(scopes); + } + _events = null; _data = null; _metadata = null; - - // The temporary instance also returns the later method rows, which can hold services the lent - // objects' scope resolved, so no single test may raise the lent row's events: the first test's - // OnDispose would dispose that scope under the later tests. Their session-lifetime disposal is - // tracked by #7383; until then they stay unraised, as they were before #7205. - _events = null; } /// @@ -1573,6 +1622,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, @@ -1583,7 +1633,7 @@ private AbstractExecutableTest CreateFailedTestForDataRowError( int repeatIndex, object?[]? classData = null, object?[]? methodData = null, - TestBuilderContext? builderContext = null) + TestBuilderContext? rowContext = null) { return CreateFailedTestForDataGenerationError(metadata, exception, new TestDataCombination { @@ -1592,7 +1642,7 @@ private AbstractExecutableTest CreateFailedTestForDataRowError( MethodDataSourceIndex = methodDataAttributeIndex, MethodLoopIndex = methodDataLoopIndex, RepeatIndex = repeatIndex - }, classData, methodData, builderContext); + }, classData, methodData, rowContext); } /// The test's metadata. @@ -1600,6 +1650,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 @@ -1612,13 +1663,13 @@ private AbstractExecutableTest CreateFailedTestForDataGenerationError( TestDataCombination combination, object?[]? classData = null, object?[]? methodData = null, - TestBuilderContext? builderContext = 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, builderContext); + var context = CreateFailedTestContext(metadata, testDetails, rowContext); var now = DateTimeOffset.UtcNow; return new FailedExecutableTest(exception) @@ -1861,15 +1912,13 @@ private async ValueTask InitializeAttributesCoreAsync(Attribute[] a return attributes; } - private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext = null) + private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext) { var builderContext = new TestBuilderContext { TestMetadata = metadata.MethodMetadata }; if (rowContext is not null) { - // A failed row still owns the scopes created while its factories ran. Keep their - // callbacks even though no test instance receives the row's arguments. - builderContext.ShareEventsWith(rowContext); - builderContext.ShareStateBagWith(rowContext); + rowContext.CopyStateBagTo(builderContext); + builderContext.Events = rowContext.EventsIfCreated?.Clone() ?? new(); } var context = _contextProvider.CreateTestContext( @@ -1883,9 +1932,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) @@ -2258,6 +2307,8 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( var classDataAttributeIndex = 0; foreach (var classDataSource in await GetDataSourcesAsync(metadata.ClassDataSources, cancellationToken)) { + var classSourceContext = baseContext.CreateChild(classDataSource, null); + contextAccessor.Current = classSourceContext; classDataAttributeIndex++; var classDataLoopIndex = 0; @@ -2273,12 +2324,16 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( cancellationToken.ThrowIfCancellationRequested(); classDataLoopIndex++; - var (classData, firstClassRowMetadata, firstClassRowEvents) = await FetchFirstClassRowAsync( - classDataFactory, classDataSource, metadata, contextAccessor); + contextAccessor.Current = classSourceContext.CreateChild(classDataSource, null); + + // Keep constructor-factory state on its saved row, outside the enumeration baseline. + 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 // again, so a non-shared source does not create an extra, untracked instance (#7157). - var unclaimedClassRow = new UnclaimedClassRow(classData, firstClassRowMetadata, firstClassRowEvents); + 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); @@ -2306,8 +2361,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; } @@ -2333,11 +2389,14 @@ 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(); + contextAccessor.Current = enumerationContext.CreateChild(classDataSource, methodDataSource); + // Build and yield single test var test = await BuildSingleTestAsync( metadata, classDataFactory, unclaimedClassRow, methodDataFactory, @@ -2352,12 +2411,16 @@ public async IAsyncEnumerable BuildTestsStreamingAsync( yield return test; } } + + // Keep subsequent rows and repeats independent of each test's factory state. + contextAccessor.Current = enumerationContext; } } } finally { await DisposeInstanceForMethodDataSourcesAsync(instanceForMethodDataSources); + contextAccessor.Current = classSourceContext; } } } @@ -2492,23 +2555,9 @@ private async Task CreateInstanceForMethodDataSources( object?[]? classData = null; object?[]? methodData = null; - // Fetch this test's rows against a context of their own, so the events the data sources subscribe - // reach this test only (#7205). It shares the base context's state bag, as the streaming path always has. - var baseContext = contextAccessor.Current; - var iterationContext = new TestBuilderContext - { - TestMetadata = metadata.MethodMetadata, - DataSourceAttribute = methodDataSource ?? baseContext.DataSourceAttribute, - ClassDataSourceAttribute = classDataSource ?? baseContext.ClassDataSourceAttribute, - InitializedAttributes = baseContext.InitializedAttributes, - ClassConstructor = baseContext.ClassConstructor - }; - iterationContext.ShareStateBagWith(baseContext); - contextAccessor.Current = iterationContext; - try { - (classData, var classRowMetadata) = await unclaimedClassRow.TakeOrFetchAsync(classDataFactory, iterationContext); + (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 @@ -2527,7 +2576,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, iterationContext.EventsIfCreated); + unclaimedClassRow.Return(classData, classRowMetadata, contextAccessor.Current); return null; } } @@ -2567,12 +2616,12 @@ private async Task CreateInstanceForMethodDataSources( } catch (Exception ex) { - return CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), methodData, iterationContext); + 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, iterationContext); + return CreateFailedTestForDataRowError(metadata, ex, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), methodData, contextAccessor.Current); } if (metadata.TestClassType.IsGenericTypeDefinition && resolvedClassGenericArgs.Length == 0) @@ -2617,18 +2666,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); - 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); @@ -2644,11 +2682,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, iterationContext); - } - finally - { - contextAccessor.Current = baseContext; + return CreateFailedTestForDataRowError(metadata, reportedException, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, repeatIndex, unclaimedClassRow.WithLentObjects(classData), rowData ?? methodData, contextAccessor.Current); } } diff --git a/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs b/src/TUnit.Engine/Services/EventReceiverOrchestrator.cs index 8bf554dd6e1..42578aff947 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.ToArray()) + { + 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.ToArray()) + { + 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.ToArray()) + { + await handler.InvokeAsync(context, context); + } } } diff --git a/src/TUnit.Engine/Services/StaticPropertyHandler.cs b/src/TUnit.Engine/Services/StaticPropertyHandler.cs index 271988c5aa5..07dfe268ca2 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,31 @@ 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(); + // Detach before awaiting so a reused host cannot retain scopes from earlier sessions. + var scopes = events.DetachDataRowScopes(); foreach (var staticProperty in staticProperties) { + // Scope-owned values must be released by their scope before tracker disposal is skipped. + if (scopes is not null) + { + await scopes.ReleaseAsync(staticProperty, cleanupExceptions).ConfigureAwait(false); + } try { - await _objectTracker.UntrackObjectAsync(staticProperty).ConfigureAwait(false); + await objectTracker.UntrackObjectAsync(staticProperty).ConfigureAwait(false); } catch (Exception e) { @@ -114,6 +131,12 @@ public async Task DisposeStaticPropertiesAsync(List cleanupExceptions } } + // Also release scopes whose factory failed or whose returned value was not trackable. + if (scopes is not null) + { + await scopes.CompleteAsync(cleanupExceptions).ConfigureAwait(false); + } + if (cleanupExceptions.Count > 0) { throw new AggregateException("Errors occurred while disposing static properties", cleanupExceptions); diff --git a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs index 09af835a7ba..ac9a78ae3a7 100644 --- a/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs +++ b/src/TUnit.Engine/Services/TestExecution/RetryHelper.cs @@ -109,6 +109,27 @@ public static async Task ExecuteWithRetry(TestContext testContext, Func? cleanupExceptions = null; + + // Release roots before their dependencies. Scope cleanup is invoked at the resolved + // 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?.DataRowScopes is { } scopes) + { + cleanupExceptions = await scopes.CompleteAsync(cleanupExceptions).ConfigureAwait(false); + } #if NET // Per-test cleanup has completed. Keep the test activity open for final status diff --git a/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs b/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs index 77d005d1e3b..aacd2f6ede5 100644 --- a/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs +++ b/src/TUnit.Engine/Services/TestExecution/TestOnDisposeRaiser.cs @@ -17,15 +17,15 @@ internal static class TestOnDisposeRaiser /// before they reach the coordinator: a test skipped because a dependency failed, and a test the /// run's cancellation stopped before it started. /// - public static async ValueTask RaiseOnceAsync(AbstractExecutableTest test, TUnitFrameworkLogger logger) + public static async ValueTask RaiseOnceAsync(AbstractExecutableTest test, TUnitFrameworkLogger logger, bool disposeDataRow = true) { var onDispose = test.Context.InternalEventsIfCreated?.OnDispose; - if (onDispose?.InvocationList is not { } invocations || !test.TryClaimOnDispose()) + if (!test.TryClaimOnDispose()) { return; } - foreach (var invocation in invocations) + foreach (var invocation in onDispose?.InvocationList ?? []) { try { @@ -39,5 +39,17 @@ public static async ValueTask RaiseOnceAsync(AbstractExecutableTest test, TUnitF await logger.LogErrorAsync($"Error during OnDispose for {test.TestId}: {disposeEx}").ConfigureAwait(false); } } + // 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?.DataRowScopes is { } scopes) + { + if (await scopes.CompleteAsync().ConfigureAwait(false) is { } exceptions) + { + foreach (var exception in exceptions) + { + await logger.LogErrorAsync($"Error during row cleanup for {test.TestId}: {exception}").ConfigureAwait(false); + } + } + } } } diff --git a/src/TUnit.Engine/Services/TestFilterService.cs b/src/TUnit.Engine/Services/TestFilterService.cs index 783c1a7540a..df65c49485b 100644 --- a/src/TUnit.Engine/Services/TestFilterService.cs +++ b/src/TUnit.Engine/Services/TestFilterService.cs @@ -131,6 +131,28 @@ private async Task RegisterTest(AbstractExecutableTest test, bool isForExecution await InvokeTestRegisteredReceivers(registeredReceivers, registeredContext, invokedReceivers).ConfigureAwait(false); } + HashSet.Invocation>? invokedDelegates = null; + await InvokeRegistrationDelegatesAsync().ConfigureAwait(false); + + async Task InvokeRegistrationDelegatesAsync() + { + if (test.Context.InternalEventsIfCreated?.OnTestRegistered is not { } onRegistered) + { + 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); + } + } + } + // If the test was marked as skipped by an event receiver, skip argument registration entirely. // This avoids initializing expensive shared data sources (e.g., WebApplicationFactory) // for tests that will never execute. @@ -191,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/DelegateLifecycleEventTests.cs b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs new file mode 100644 index 00000000000..ceeed9f5a43 --- /dev/null +++ b/tests/TUnit.TestProject/DelegateLifecycleEventTests.cs @@ -0,0 +1,383 @@ +using TUnit.TestProject.Attributes; + +namespace TUnit.TestProject; + +public class DelegateLifecycleEventTests +{ + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)] + public sealed class SubscribeAttribute : DataSourceGeneratorAttribute + { + public int Rows { get; set; } = 1; + + protected override IEnumerable> GenerateDataSources(DataGeneratorMetadata metadata) + { + for (var i = 0; i < Rows; i++) + { + yield return () => + { + metadata.TestBuilderContext.Current.StateBag["factoryState"] = "preserved"; + 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); + } + } + } +} + +[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["factoryState"]).IsEqualTo("preserved"); + 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 Service? Service; + public void Dispose() + { + DisposeCount++; + Service?.Dispose(); + } + } + + 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) => scope.Service = 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); + 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"); + } + } + + [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); + 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); + } + } +} + +[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() + { + // The temporary discovery instance can supply objects to later method rows. Its scope + // remains alive until session end; the two executable rows release their own scopes here. + await Assert.That(ScopeDataAttribute.Scopes.Count).IsEqualTo(3); + await Assert.That(ScopeDataAttribute.Scopes.Count(x => x.DisposeCount == 0)).IsEqualTo(1); + await Assert.That(ScopeDataAttribute.Scopes.Count(x => x.DisposeCount == 1)).IsEqualTo(2); + foreach (var scope in ScopeDataAttribute.Scopes.Where(x => x.DisposeCount == 1)) + { + if (scope.Service?.Dependency is { } dependency) + await Assert.That(dependency.Disposed).IsTrue(); + } + } +} + +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); + } +} 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.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 new file mode 100644 index 00000000000..ffdc5ac811b --- /dev/null +++ b/tests/TUnit.TestProject/SkippedScopeLifecycleTests.cs @@ -0,0 +1,70 @@ +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(TestSessionContext session) + { + // 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)) + { + return; + } + + await Assert.That(_service).IsNotNull(); + await Assert.That(_service!.DisposeCount).IsEqualTo(1); + } +} 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); + } +} diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs new file mode 100644 index 00000000000..fbee18abc1c --- /dev/null +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -0,0 +1,747 @@ +using TUnit.Core; +using TUnit.Engine.Building; +using TUnit.Engine.Building.Interfaces; + +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)] + 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)] + public async Task RejectedMethodRowsRetainCleanupWithoutLifecycleSubscriptions(bool failedRow) + { + var original = CreateContext(); + var constructorDisposals = 0; + var rejectedDisposals = 0; + var scopeDisposals = 0; + var rejectedStarts = 0; + original.Events.OnDispose += (_, _) => { 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); + 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); + } + 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); + 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); + await Assert.That(rejectedStarts).IsEqualTo(0); + } + + [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() + { + var original = CreateContext(); + var disposals = 0; + (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); + + 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.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + 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 LentRowKeepsScopeUntilSessionCleanupEvenWhenNextFactoryThrows() + { + var original = CreateContext(); + var disposals = 0; + (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); + 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(0); + var later = CreateContext(); + row.TransferCleanupTo(later); + await DisposeRow(later); + await Assert.That(disposals).IsEqualTo(0); + await DisposeRow(session); + 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.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + 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.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.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + disposals++; + return default; + })); + + var failed = row.CreateFailureContext(factoryContext); + await DisposeRow(failed); + await Assert.That(disposals).IsEqualTo(1); + } + + [Test] + [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))!; + var source = new ThrowingClassSource { ThrowAfterRow = !laterSource }; + 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 = emptyMethodSource ? [new EmptySource()] : [], + ClassDataSources = laterSource ? [source, new ThrowingBeforeRowSource()] : [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(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 + { + foreach (var test in tests) + { + test.Context.RemoveFromRegistry(); + test.Context.Dispose(); + } + } + } + + [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.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + 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; } + 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; + public bool ThrowAfterRow = true; + 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.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + Disposals++; + return default; + })); + return Task.FromResult([new object()]); + }; + 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(); + } + } + } + + [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(); + 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"]); + 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"]); + } + 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; + } + 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(); + metadata.TestBuilderContext.Current.StateBag["removed-by-method"] = new object(); + } + else + { + metadata.TestBuilderContext.Current.StateBag.TryRemove("removed-by-method", out _); + } + 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"); + } + if (constructor) + { + state["overwritten"] = value; + state.TryRemove("removed", out _); + state.TryRemove("removed-after-method-update", out _); + } + 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 = []; + 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; + } + } + + private static async Task DisposeTestRow(TestContext context) + { + if (context.InternalEventsIfCreated?.DataRowScopes is { } scopes && + await scopes.CompleteAsync() is { } exceptions) + { + throw new AggregateException(exceptions); + } + } + + private static TestBuilderContext CreateContext() => new() + { + TestMetadata = TestContext.Current!.TestDetails.MethodMetadata + }; + + private static async Task DisposeRow(TestBuilderContext context) + { + if (context.EventsIfCreated?.DataRowScopes is { } scopes && + await scopes.CompleteAsync() is { } exceptions) + { + 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/EventReceiverRegistrationTests.cs b/tests/TUnit.UnitTests/EventReceiverRegistrationTests.cs index dbef91b51f0..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,106 @@ 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() + { + 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() { diff --git a/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs b/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs index 98d3583252f..d4676c409f6 100644 --- a/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs +++ b/tests/TUnit.UnitTests/ExternallyOwnedSingletonTests.cs @@ -15,6 +15,33 @@ namespace TUnit.UnitTests; public class ExternallyOwnedSingletonTests { // Synthetic contexts never reach the engine's cleanup, so each test removes its own from the registry. + [Test] + public async Task Later_Consumers_Do_Not_Release_The_First_Consumers_Reference() + { + var tracker = CreateTracker(); + var singleton = new TrackedDisposable(); + var first = CreateContext(singleton); + tracker.TrackObjects(first); + ObjectTracker.MarkExternallyOwned(singleton); + + var laterConsumers = Enumerable.Range(0, 16).Select(_ => CreateContext(singleton)).ToArray(); + foreach (var context in laterConsumers) + { + tracker.TrackObjects(context); + } + + await Assert.That(ObjectTracker.IsShared(singleton)).IsTrue(); + var errors = await Task.WhenAll(laterConsumers.Select(context => Task.Run(async () => await tracker.UntrackObjects(context)))); + await Assert.That(errors.All(x => x is null)).IsTrue(); + // Later consumers must leave the reference taken before the ownership mark intact. + await Assert.That(IsCounted(singleton)).IsTrue(); + await Assert.That(ObjectTracker.IsShared(singleton)).IsFalse(); + + await tracker.UntrackObjects(first); + await Assert.That(IsCounted(singleton)).IsFalse(); + await Assert.That(singleton.DisposeCount).IsEqualTo(0); + } + private readonly List _contexts = []; [After(Test)] @@ -80,7 +107,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 still balances its reference without disposing it. + // A later source balances its own reference without taking disposal ownership. var laterTest = CreateContext(singleton); tracker.TrackObjects(laterTest); await tracker.UntrackObjects(laterTest); @@ -89,28 +116,22 @@ public async Task Counted_Between_The_Check_And_The_Mark_Is_Released_Without_Bei } [Test] - public async Task Later_Consumers_Do_Not_Release_The_First_Consumers_Reference() + public async Task Consumers_After_Ownership_Mark_Hold_Their_Own_References() { var tracker = CreateTracker(); var singleton = new TrackedDisposable(); - var first = CreateContext(singleton); - tracker.TrackObjects(first); + var earlierTest = CreateContext(singleton); + tracker.TrackObjects(earlierTest); ObjectTracker.MarkExternallyOwned(singleton); + var laterTest = CreateContext(singleton); + tracker.TrackObjects(laterTest); - var laterConsumers = Enumerable.Range(0, 16).Select(_ => CreateContext(singleton)).ToArray(); - foreach (var context in laterConsumers) - { - tracker.TrackObjects(context); - } - + // Both consumers must hold a reference before either can release it. await Assert.That(ObjectTracker.IsShared(singleton)).IsTrue(); - var errors = await Task.WhenAll(laterConsumers.Select(context => Task.Run(async () => await tracker.UntrackObjects(context)))); - await Assert.That(errors.All(x => x is null)).IsTrue(); - // Later consumers must leave the reference taken before the ownership mark intact. - await Assert.That(IsCounted(singleton)).IsTrue(); - await Assert.That(ObjectTracker.IsShared(singleton)).IsFalse(); + await Task.WhenAll( + Task.Run(async () => await tracker.UntrackObjects(earlierTest)), + Task.Run(async () => await tracker.UntrackObjects(laterTest))); - await tracker.UntrackObjects(first); await Assert.That(IsCounted(singleton)).IsFalse(); await Assert.That(singleton.DisposeCount).IsEqualTo(0); } diff --git a/tests/TUnit.UnitTests/ObjectGraphDiscovererPreCheckTests.cs b/tests/TUnit.UnitTests/ObjectGraphDiscovererPreCheckTests.cs index 334d423eb1a..bc5f5c72715 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, null, 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()); 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(); + } +} diff --git a/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs new file mode 100644 index 00000000000..e30f371cdd4 --- /dev/null +++ b/tests/TUnit.UnitTests/StaticScopeCleanupTests.cs @@ -0,0 +1,127 @@ +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); + 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.DataRowScopes).IsNull(); + } + + [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(events.DataRowScopes).IsNull(); + 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"); + } + } +}