diff --git a/src/TUnit.Core/ContextProvider.cs b/src/TUnit.Core/ContextProvider.cs index f90f0579c0d..03a7b8b3e6f 100644 --- a/src/TUnit.Core/ContextProvider.cs +++ b/src/TUnit.Core/ContextProvider.cs @@ -122,7 +122,8 @@ public TestContext CreateTestContext( Type classType, TestBuilderContext testBuilderContext, TestDetails testDetails, - CancellationToken cancellationToken) + CancellationToken cancellationToken, + bool registerAsTest = true) { var classContext = GetOrCreateClassContext(classType); @@ -133,7 +134,8 @@ public TestContext CreateTestContext( TestDetails = testDetails, }; - classContext.AddTest(testContext); + if (registerAsTest) + classContext.AddTest(testContext); return testContext; } diff --git a/src/TUnit.Core/Services/IContextProvider.cs b/src/TUnit.Core/Services/IContextProvider.cs index 512d7bc7c05..b1577bc5333 100644 --- a/src/TUnit.Core/Services/IContextProvider.cs +++ b/src/TUnit.Core/Services/IContextProvider.cs @@ -38,12 +38,14 @@ ClassHookContext GetOrCreateClassContext( /// /// Creates a test context. is assigned before the context /// becomes observable via so hooks never see a - /// partially-built context. + /// partially-built context. Cleanup-only contexts pass as false + /// to stay out of the class and session test lists. /// TestContext CreateTestContext( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)] Type classType, TestBuilderContext testBuilderContext, TestDetails testDetails, - CancellationToken cancellationToken); + CancellationToken cancellationToken, + bool registerAsTest = true); } diff --git a/src/TUnit.Engine/Building/RowCleanupOwner.cs b/src/TUnit.Engine/Building/RowCleanupOwner.cs new file mode 100644 index 00000000000..1214bb39fdf --- /dev/null +++ b/src/TUnit.Engine/Building/RowCleanupOwner.cs @@ -0,0 +1,115 @@ +using System.Collections.Concurrent; +using TUnit.Core; + +namespace TUnit.Engine.Building; + +/// +/// Owns a row's cleanup until one test or the session claims it. A row that never reaches +/// either owner is released by the builder's finally block, including failed factories. +/// +internal sealed class RowCleanupOwner +{ + private readonly TestBuilderContext _context; + private readonly TestContextEvents _cleanup; + private int _claimedOrReleased; + + private RowCleanupOwner(TestBuilderContext context, TestContextEvents events) + { + _context = context with { }; + if (context.HasStateBag) + _context.StateBag = new ConcurrentDictionary(context.StateBag); + _cleanup = new TestContextEvents + { + OnDispose = events.OnDispose?.Clone(), + DataRowScopes = events.DataRowScopes?.Clone() + }; + } + + internal static RowCleanupOwner? Capture(TestBuilderContext context) + => context.EventsIfCreated is { } events && (events.OnDispose is not null || events.DataRowScopes is not null) + ? new(context, events) + : null; + + internal void ClaimTo(TestBuilderContext target, bool bindState = false) + { + if (Interlocked.Exchange(ref _claimedOrReleased, 1) != 0) + return; + + if (_cleanup.DataRowScopes is { } scopes) + target.Events.AddDataRowScopes(scopes); + if (_cleanup.OnDispose is not { } onDispose) + return; + + if (!bindState) + { + (target.Events.OnDispose ??= new()).AddMissingFrom(onDispose); + return; + } + + // A discarded method row's callbacks need its state, while metadata and services + // come from the test that eventually owns cleanup. No lifecycle handlers follow it. + foreach (var callback in onDispose.InvocationList) + { + (target.Events.OnDispose ??= new()).Add(async (_, owner) => + { + var context = new TestContext(owner.TestDetails.TestName, owner.ServiceProvider, + owner.ClassContext, _context, owner.CancellationToken); + context.Metadata.TestDetails = owner.TestDetails; + try + { + await callback.InvokeAsync(context, context); + } + finally + { + context.RemoveFromRegistry(); + context.Dispose(); + } + }, callback.Order); + } + } + + internal void ClaimForSession() + { + if (Interlocked.Exchange(ref _claimedOrReleased, 1) == 0) + TestSessionContext.DeferOnDisposeToSessionEnd(_cleanup); + } + + internal async ValueTask?> ReleaseAsync( + Func createContext, List? exceptions = null) + { + if (Interlocked.Exchange(ref _claimedOrReleased, 1) != 0) + return exceptions; + + if (_cleanup.OnDispose is { } onDispose) + { + TestContext? context = null; + try + { + context = createContext(_context); + foreach (var callback in onDispose.InvocationList) + { + try + { + await callback.InvokeAsync(context, context).ConfigureAwait(false); + } + catch (Exception exception) + { + (exceptions ??= []).Add(exception); + } + } + } + catch (Exception exception) + { + (exceptions ??= []).Add(exception); + } + finally + { + context?.RemoveFromRegistry(); + context?.Dispose(); + } + } + if (_cleanup.DataRowScopes is { } scopes) + exceptions = await scopes.CompleteAsync(exceptions).ConfigureAwait(false); + return exceptions; + } +} diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs index 8cc14cb7680..8556ade57d1 100644 --- a/src/TUnit.Engine/Building/TestBuilder.cs +++ b/src/TUnit.Engine/Building/TestBuilder.cs @@ -332,6 +332,7 @@ public async ValueTask> BuildTestsFromMetada // constraints: fail this row only, as reflection mode does when it resolves // the row's type arguments, and keep building the remaining rows. var (reportedException, rowData) = UnpackConstraintViolation(ex, metadata.MethodMetadata.Parameters); + unclaimedClassRow.ClaimCleanupTo(contextAccessor.Current); tests.Add(CreateFailedTestForDataRowError(metadata, reportedException, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), rowData, contextAccessor.Current)); continue; } @@ -369,6 +370,8 @@ public async ValueTask> BuildTestsFromMetada } } + unclaimedClassRow.ClaimCleanupTo(contextAccessor.Current); + Type[] resolvedClassGenericArgs; Type[] resolvedMethodGenericArgs; @@ -508,7 +511,6 @@ public async ValueTask> BuildTestsFromMetada // and tracks any objects that a temporary instance used. var lentClassRowObjects = unclaimedClassRow.TakeLentObjects(); var skippedRowContext = unclaimedClassRow.CreateEnumerationFailureContext(contextAccessor.Current); - unclaimedClassRow.Clear(); Type[] resolvedClassGenericArgs; Exception? genericResolutionException = null; @@ -565,6 +567,7 @@ public async ValueTask> BuildTestsFromMetada var failureContext = ReferenceEquals(contextAccessor.Current, classEnumerationContext) ? unclaimedClassRow.CreateEnumerationFailureContext(classEnumerationContext) : contextAccessor.Current; + unclaimedClassRow.ClaimCleanupTo(failureContext); contextAccessor.Current = failureContext; var failedTest = CreateFailedTestForDataGenerationError(metadata, ex, new TestDataCombination(), methodData: unclaimedClassRow.TakeLentObjects(), @@ -575,6 +578,9 @@ public async ValueTask> BuildTestsFromMetada finally { await DisposeInstanceForMethodDataSourcesAsync(instanceForMethodDataSources); + if (await unclaimedClassRow.ReleaseAsync(CreateCleanupContext) is { Count: > 0 } cleanupErrors) + tests.Add(CreateFailedTestForDataGenerationError(metadata, new AggregateException(cleanupErrors), + new TestDataCombination { ClassDataSourceIndex = classDataAttributeIndex, ClassLoopIndex = classDataLoopIndex })); contextAccessor.Current = classSourceContext; } } @@ -673,8 +679,19 @@ public async ValueTask> BuildTestsFromMetada tests.Add(failedTest); return tests; } + finally + { + if (activeClassRow is not null && await activeClassRow.ReleaseAsync(CreateCleanupContext) is { Count: > 0 } cleanupErrors) + tests.Add(CreateFailedTestForDataGenerationError(metadata, new AggregateException(cleanupErrors))); + } return tests; + + TestContext CreateCleanupContext(TestBuilderContext rowContext) + { + var details = CreateFailedTestDetails(metadata, TestIdentifierService.GenerateFailedTestId(metadata, new TestDataCombination()), []); + return CreateFailedTestContext(metadata, details, rowContext, registerAsTest: false); + } } private readonly struct BuildContextLease(TestBuildContext buildContext) : IDisposable @@ -1049,7 +1066,8 @@ public ValueTask MoveNextAsync() /// When the row needs a temporary instance for an instance method data source, that instance is built /// 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. + /// receiving them, so they are still disposed. Their cleanup owner is claimed by the session, + /// keeping constructor scopes alive while later method rows still borrow those objects. /// internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rowContext, TestBuilderContext? enumerationContext = null) { @@ -1065,8 +1083,23 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met : null; private TestBuilderContext _rowContext = rowContext; // Snapshot before any method factory can mutate the class subscriptions. - private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone(); - private TestContextEvents? _rejectedCleanup; + private TestContextEvents? _lifecycleEvents = LifecycleEvents(rowContext); + private RowCleanupOwner? _cleanup = RowCleanupOwner.Capture(rowContext); + private List? _rejectedCleanup; + private bool _pending = true; + + private static TestContextEvents? LifecycleEvents(TestBuilderContext context) + { + return context.EventsIfCreated is { } events ? new TestContextEvents + { + OnTestRegistered = events.OnTestRegistered?.Clone(), + OnInitialize = events.OnInitialize?.Clone(), + OnTestStart = events.OnTestStart?.Clone(), + OnTestEnd = events.OnTestEnd?.Clone(), + OnTestSkipped = events.OnTestSkipped?.Clone(), + OnTestRetry = events.OnTestRetry?.Clone() + } : null; + } /// /// Takes the unclaimed objects, or fetches a new row from when a @@ -1078,10 +1111,14 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met { ApplySavedContextTo(context); var row = (data, _metadata); - Clear(); + _data = null; + _metadata = null; return new ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)>(row); } + if (_pending) + throw new InvalidOperationException("The previous class row must be claimed or returned before fetching another row."); + return FetchAsync(classDataFactory, context); async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory, TestBuilderContext target) @@ -1095,7 +1132,13 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met { _rowContext.StateBag = new ConcurrentDictionary(target.StateBag); } - _events = target.EventsIfCreated?.Clone(); + _lifecycleEvents = LifecycleEvents(target); + _cleanup = RowCleanupOwner.Capture(target); + _pending = true; + // Class cleanup stays with its owner until a test claims the row. Method + // factories see the lifecycle subscriptions, but own separate cleanup. + if (target.EventsIfCreated is not null) + target.Events = _lifecycleEvents!.Clone(); return row; } } @@ -1126,14 +1169,10 @@ private void ApplySavedContextTo(TestBuilderContext context) } } } - if (_events is { } savedEvents) + if (_lifecycleEvents is { } savedEvents) { context.Events = savedEvents.Clone(); } - if (_rejectedCleanup is { } cleanup) - { - context.Events.AddCleanupFrom(cleanup); - } } /// @@ -1143,45 +1182,54 @@ public void Return(object?[] data, TestDataRowMetadata? metadata, TestBuilderCon { _data = data; _metadata = metadata; - // Only cleanup follows a rejected method row. Its other lifecycle handlers must - // never become constructor subscriptions on later compatible rows. - if (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); - } - } + if (RowCleanupOwner.Capture(rejectedContext) is { } methodCleanup) + { + (_rejectedCleanup ??= []).Add(methodCleanup); + } + } + + /// Claims class and method cleanup for one executable (including failed) row. + public void ClaimCleanupTo(TestBuilderContext target) + { + if (!_pending) + return; + + // Capture the method's cleanup before adding the class row's subscriptions. + var methodCleanup = RowCleanupOwner.Capture(target); + if (methodCleanup is not null) + { + target.Events.OnDispose = null; + target.Events.DataRowScopes = null; + } + _cleanup?.ClaimTo(target); + if (_rejectedCleanup is not null) + { + foreach (var cleanup in _rejectedCleanup) + cleanup.ClaimTo(target, bindState: true); + _rejectedCleanup = null; + } + methodCleanup?.ClaimTo(target); + _pending = false; + _data = null; + _metadata = null; + } + + /// Releases only rows that no executable test or session claimed. + public async ValueTask?> ReleaseAsync(Func createContext) + { + List? exceptions = null; + if (_cleanup is not null) + exceptions = await _cleanup.ReleaseAsync(createContext, exceptions); + if (_rejectedCleanup is not null) + { + foreach (var cleanup in _rejectedCleanup) + exceptions = await cleanup.ReleaseAsync(createContext, exceptions); + _rejectedCleanup = null; } + _pending = false; + _data = null; + _metadata = null; + return exceptions; } /// @@ -1189,9 +1237,10 @@ public void Return(object?[] data, TestDataRowMetadata? metadata, TestBuilderCon /// public void TransferCleanupTo(TestBuilderContext target) { - if (_data is not null) + if (_pending) { ApplySavedContextTo(target); + ClaimCleanupTo(target); } } @@ -1214,15 +1263,6 @@ internal TestBuilderContext CreateEnumerationFailureContext(TestBuilderContext e return failureContext; } - /// Marks the unclaimed objects as held by a test. - public void Clear() - { - _data = null; - _metadata = null; - _lent = 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 . @@ -1231,15 +1271,12 @@ public void LendToTemporaryInstance(TestBuilderContext? lifetimeContext = null) { _lent = _data; // Method rows share this constructor row until session end. - if (lifetimeContext is not null && _events is not null) - { - lifetimeContext.Events.AddCleanupFrom(_events); - } + if (lifetimeContext is not null) + _cleanup?.ClaimTo(lifetimeContext); else - { - TestSessionContext.DeferOnDisposeToSessionEnd(_events); - } - _events = null; + _cleanup?.ClaimForSession(); + _pending = false; + _lifecycleEvents = null; _data = null; _metadata = null; } @@ -1916,7 +1953,7 @@ private async ValueTask InitializeAttributesCoreAsync(Attribute[] a return attributes; } - private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext) + private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext, bool registerAsTest = true) { var builderContext = new TestBuilderContext { TestMetadata = metadata.MethodMetadata }; if (rowContext is not null) @@ -1929,7 +1966,8 @@ private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails t metadata.TestClassType, builderContext, testDetails, - CancellationToken.None); + CancellationToken.None, + registerAsTest); return context; } diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs index 83c2e2c4627..3d2398cf0b5 100644 --- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs +++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs @@ -14,7 +14,9 @@ public async Task EmptyRefetchedConstructorStateDoesNotCaptureRejectedMethodStat { 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 first = CreateContext(); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), first); + row.ClaimCleanupTo(first); var rejected = CreateContext(); if (removesInheritedKey) @@ -49,7 +51,9 @@ public async Task RefetchedRejectedConstructorReplaysOnlyItsOwnStateChanges(bool 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 first = CreateContext(); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), first); + row.ClaimCleanupTo(first); var rejected = CreateContext(); rejected.StateBag["method-row"] = new object(); @@ -128,6 +132,7 @@ ValueTask RejectedLifecycle(object sender, TestContext context) row.TransferCleanupTo(owner); else await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse constructor"), owner); + row.ClaimCleanupTo(owner); // Neither returning a rejected row nor taking the next one may release its class resource early. await Assert.That(constructorDisposals).IsEqualTo(0); await Assert.That(rejectedDisposals).IsEqualTo(0); @@ -239,6 +244,7 @@ public async Task ClaimedRowDoesNotTransferCleanupToLaterSkippedTest() var row = new TestBuilder.UnclaimedClassRow([new object()], null, original); var runnable = CreateContext(); await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must use saved row"), runnable); + row.ClaimCleanupTo(runnable); var skipped = CreateContext(); row.TransferCleanupTo(skipped); @@ -261,7 +267,6 @@ public async Task UnclaimedRowTransfersCleanupToSkippedTest() 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); } @@ -311,6 +316,7 @@ public async Task EnumerationFailureOnlyDisposesUnclaimedClassScope(bool claimed if (claimed) { await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must use saved row"), runnable); + row.ClaimCleanupTo(runnable); } // MoveNext throws after yielding a row (or before yielding any rows). @@ -437,6 +443,166 @@ public async Task NonRunnableRowsPreservePublicCallbacksAndState(bool factoryThr } } + [Test] + public async Task CleanupOwnerCanOnlyBeClaimedOnce() + { + var original = CreateContext(); + var disposals = 0; + (original.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + disposals++; + return default; + })); + var cleanup = RowCleanupOwner.Capture(original)!; + var first = CreateContext(); + var second = CreateContext(); + cleanup.ClaimTo(first); + cleanup.ClaimTo(second); + await cleanup.ReleaseAsync(_ => throw new InvalidOperationException("Claimed rows cannot release here")); + await DisposeRow(second); + await Assert.That(disposals).IsEqualTo(0); + await DisposeRow(first); + await DisposeRow(first); + await Assert.That(disposals).IsEqualTo(1); + } + + [Test] + public async Task UnclaimedRejectedRowsReleaseEveryCleanupOnceEvenWhenCallbacksThrow() + { + var original = CreateContext(); + var classDisposals = 0; + var methodDisposals = 0; + var callbacks = 0; + (original.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + classDisposals++; + return default; + })); + var data = new object?[] { new object() }; + var row = new TestBuilder.UnclaimedClassRow(data, null, original); + for (var i = 0; i < 2; i++) + { + var rejected = CreateContext(); + await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse class row"), rejected); + var resource = new object(); + rejected.StateBag["resource"] = resource; + rejected.Events.OnDispose += async (_, context) => + { + await Assert.That(context.StateBag.Items["resource"]).IsSameReferenceAs(resource); + callbacks++; + throw new InvalidOperationException("Cleanup failure"); + }; + (rejected.Events.DataRowScopes ??= new()).Register(new CallbackScope(() => + { + methodDisposals++; + return default; + })); + row.Return(data, null, rejected); + } + var errors = await row.ReleaseAsync(CreateCleanupContext); + await Assert.That(errors!.Count).IsEqualTo(2); + await Assert.That(await row.ReleaseAsync(CreateCleanupContext)).IsNull(); + await Assert.That(classDisposals).IsEqualTo(1); + await Assert.That(methodDisposals).IsEqualTo(2); + await Assert.That(callbacks).IsEqualTo(2); + var later = CreateContext(); + row.ClaimCleanupTo(later); + await DisposeRow(later); + await Assert.That(classDisposals).IsEqualTo(1); + } + + [Test] + public async Task EmptyMethodSourceWithoutSkipReleasesUnclaimedClassCallbacks() + { + var current = TestContext.Current!; + var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; + var source = new PublicCleanupSource(); + var metadata = new TestMetadata + { + TestClassType = typeof(ClassRowCleanupTests), + TestMethodName = nameof(EmptyMethodSourceWithoutSkipReleasesUnclaimedClassCallbacks), + TestName = "Unclaimed row cleanup regression", + FilePath = "Unknown", + LineNumber = 0, + AttributeFactory = () => [], + MethodMetadata = current.TestDetails.MethodMetadata, + DataSources = [new EmptySource()], + ClassDataSources = [source], + PropertyDataSources = [], + InstanceFactory = (_, _) => new ClassRowCleanupTests(), + InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask + }; + var tests = (await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))).ToArray(); + await Assert.That(current.ClassContext.Tests.Any(test => test.TestDetails.TestName == metadata.TestName)).IsFalse(); + await Assert.That(tests.Length).IsEqualTo(0); + await Assert.That(source.Callbacks).IsEqualTo(1); + } + + [Test] + public async Task UnclaimedCleanupFailuresHaveDistinctClassRowIds() + { + var current = TestContext.Current!; + var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!; + var metadata = new TestMetadata + { + TestClassType = typeof(ClassRowCleanupTests), + TestMethodName = nameof(UnclaimedCleanupFailuresHaveDistinctClassRowIds), + TestName = "Unclaimed cleanup failure IDs", + FilePath = "Unknown", + LineNumber = 0, + AttributeFactory = () => [], + MethodMetadata = current.TestDetails.MethodMetadata, + DataSources = [new EmptySource()], + ClassDataSources = [new FailingCleanupSource(), new FailingCleanupSource()], + 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(4); + await Assert.That(tests.Select(test => test.Context.TestDetails.TestId).Distinct().Count()).IsEqualTo(4); + } + finally + { + foreach (var test in tests) + { + test.Context.RemoveFromRegistry(); + test.Context.Dispose(); + } + } + } + + private sealed class FailingCleanupSource : Attribute, IDataSourceAttribute + { + public bool SkipIfEmpty { get; set; } + public bool DeferEnumeration { get; set; } + + public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata) + { + await Task.CompletedTask; + for (var i = 0; i < 2; i++) + { + yield return () => + { + metadata.TestBuilderContext.Current.Events.OnDispose += (_, _) => + throw new InvalidOperationException("Class row cleanup failed"); + return Task.FromResult([new object()]); + }; + } + } + } + + private static TestContext CreateCleanupContext(TestBuilderContext builderContext) + { + var current = TestContext.Current!; + var context = new TestContext("Unclaimed cleanup", current.ServiceProvider, current.ClassContext, + builderContext, CancellationToken.None); + context.Metadata.TestDetails = current.TestDetails; + return context; + } + private sealed class PublicCleanupSource : Attribute, IDataSourceAttribute { public readonly object Resource = new(); diff --git a/tests/TUnit.UnitTests/SessionActivityLifecycleTests.cs b/tests/TUnit.UnitTests/SessionActivityLifecycleTests.cs index cc7c2efd00e..b38b1e5c7d3 100644 --- a/tests/TUnit.UnitTests/SessionActivityLifecycleTests.cs +++ b/tests/TUnit.UnitTests/SessionActivityLifecycleTests.cs @@ -364,7 +364,8 @@ public TestContext CreateTestContext( Type classType, TestBuilderContext testBuilderContext, TestDetails testDetails, - CancellationToken cancellationToken) => + CancellationToken cancellationToken, + bool registerAsTest = true) => throw new NotSupportedException(); }