feat: Add flag to actively wait for async disposal (#1415)

Author: linkdotnet

MIGRATION.md

@@ -79,3 +79,6 @@ Or use the `BunitContext` directly and manage the lifecycle yourself.
 
 ## `TestServiceProvider` renamed to `BunitTestServiceProvider`
 The `TestServiceProvider` class has been renamed to `BunitTestServiceProvider`. If you used `TestServiceProvider`, you should replace it with `BunitTestServiceProvider`.
+
+## `DisposeComponents` is now asynchronous and called `DisposeComponentsAsync`
+`DisposeComponentsAsync` allows to await `DisposeAsync` of components under test. If you used `DisposeComponents`, you should replace it with `DisposeComponentsAsync`.

docs/samples/components/AsyncDisposableComponent.razor

@@ -0,0 +1,10 @@
+@using Microsoft.JSInterop
+@implements IAsyncDisposable
+@inject IJSRuntime JSRuntime
+@code {
+
+  public async ValueTask DisposeAsync()
+  {
+    await JSRuntime.InvokeVoidAsync("dispose");
+  }
+}

docs/samples/tests/xunit/DisposeComponentsTest.cs

@@ -8,37 +8,48 @@ namespace Bunit.Docs.Samples;
 public class DisposeComponentsTest : BunitContext
 {
   [Fact]
-  public void DisposeElements()
+  public async Task DisposeElements()
   {
     var calledTimes = 0;
     var cut = Render<DisposableComponent>(parameters => parameters
       .Add(p => p.LocationChangedCallback, url => calledTimes++)
     );
 
-    DisposeComponents();
+    await DisposeComponentsAsync();
 
     Services.GetRequiredService<NavigationManager>().NavigateTo("newurl");
 
     Assert.Equal(0, calledTimes);
   }
 
   [Fact]
-  public void ShouldCatchExceptionInDispose()
+  public async Task ShouldCatchExceptionInDispose()
   {
     Render<ExceptionInDisposeComponent>();
 
-    var act = DisposeComponents;
+    Func<Task> act = () => DisposeComponentsAsync();
 
-    Assert.Throws<NotSupportedException>(act);
+    await Assert.ThrowsAsync<NotSupportedException>(act);
   }
 
   [Fact]
-  public void ShouldCatchExceptionInDisposeAsync()
+  public async Task ShouldCatchExceptionInDisposeAsync()
   {
     Render<ExceptionInDisposeAsyncComponent>();
 
-    DisposeComponents();
+    await DisposeComponentsAsync();
     var exception = Renderer.UnhandledException.Result;
     Assert.IsType<NotSupportedException>(exception);
   }
+
+  [Fact]
+  public async Task ShouldDisposeJSObject()
+  {
+    JSInterop.SetupVoid("dispose").SetVoidResult();
+    Render<AsyncDisposableComponent>();
+
+    await DisposeComponentsAsync();
+
+    JSInterop.VerifyInvoke("dispose");
+  }
 }

docs/site/docs/interaction/dispose-components.md

@@ -4,22 +4,33 @@ title: Disposing components and their children
 ---
 
 # Disposing components
-To dispose all components rendered with a `BunitContext`, use the [`DisposeComponents`](xref:Bunit.BunitContext.DisposeComponents) method.  Calling this method will dispose all rendered components, calling any `IDisposable.Dispose` or/and `IAsyncDisposable.DisposeAsync` methods they might have, and remove the components from the render tree, starting with the root components and then walking down the render tree to all the child components.
+To dispose all components rendered with a `BunitContext`, use the [`DisposeComponents`](xref:Bunit.BunitContext.DisposeComponentsAsync) method.  Calling this method will dispose all rendered components, calling any `IDisposable.Dispose` or/and `IAsyncDisposable.DisposeAsync` methods they might have, and remove the components from the render tree, starting with the root components and then walking down the render tree to all the child components.
 
 Disposing rendered components enables testing of logic in `Dispose` methods, e.g., event handlers, that should be detached to avoid memory leaks.
 
 The following example of this:
 
-[!code-csharp[](../../../samples/tests/xunit/DisposeComponentsTest.cs#L13-L22)]
+[!code-csharp[DisposeComponentsTest.cs](../../../samples/tests/xunit/DisposeComponentsTest.cs#L13-L22)]
 
 > [!WARNING]
 > For `IAsyncDisposable` (since .net5) relying on [`WaitForState()`](xref:Bunit.RenderedFragmentWaitForHelperExtensions.WaitForState(Bunit.RenderedFragment,System.Func{System.Boolean},System.Nullable{System.TimeSpan})) or [`WaitForAssertion()`](xref:Bunit.RenderedFragmentWaitForHelperExtensions.WaitForAssertion(Bunit.RenderedFragment,System.Action,System.Nullable{System.TimeSpan})) will not work as a disposed component will not trigger a new render cycle.
 
+## Disposing components asynchronously
+If a component implements `IAsyncDisposable`, `DisposeComponentsAsync` can be awaited to wait for all asynchronous `DisposeAsync` methods. Sometimes interacting with JavaScript in Blazor WebAssembly requires disposing or resetting state in `DisposeAsync`.
+
+[!code-csharp[DisposeComponentsTest.cs](../../../samples/tests/xunit/DisposeComponentsTest.cs#L48-L53)]
+
+To omit this behavior, discard the returned task
+
+```csharp
+_ = DisposeComponentsAsync();
+```
+
 ## Checking for exceptions
-`Dispose` as well as `DisposeAsync` can throw exceptions which can be asserted as well. If a component under test throws an exception in `Dispose` the [`DisposeComponents`](xref:Bunit.BunitContext.DisposeComponents) will throw the exception to the user code:
+`Dispose` as well as `DisposeAsync` can throw exceptions which can be asserted as well. If a component under test throws an exception in `Dispose` the [`DisposeComponents`](xref:Bunit.BunitContext.DisposeComponentsAsync) will throw the exception to the user code:
 
-[!code-csharp[](../../../samples/tests/xunit/DisposeComponentsTest.cs#L28-L32)]
+[!code-csharp[DisposeComponentsTest.cs](../../../samples/tests/xunit/DisposeComponentsTest.cs#L28-L32)]
 
 `DisposeAsync` behaves a bit different. The following example will demonstrate how to assert an exception in `DisposeAsync`:
 
-[!code-csharp[](../../../samples/tests/xunit/DisposeComponentsTest.cs#L39-L43)]
+[!code-csharp[DisposeComponentsTest.cs](../../../samples/tests/xunit/DisposeComponentsTest.cs#L38-L42)]

src/bunit/BunitContext.cs

@@ -130,10 +130,7 @@ protected virtual void Dispose(bool disposing)
 	/// <summary>
 	/// Disposes all components rendered via this <see cref="BunitContext"/>.
 	/// </summary>
-	public void DisposeComponents()
-	{
-		Renderer.DisposeComponents();
-	}
+	public Task DisposeComponentsAsync() => Renderer.DisposeComponents();
 
 	/// <summary>
 	/// Instantiates and performs a first render of a component of type <typeparamref name="TComponent"/>.

src/bunit/Rendering/BunitRenderer.cs

@@ -11,6 +11,7 @@ namespace Bunit.Rendering;
 public sealed class BunitRenderer : Renderer
 {
 	private readonly BunitServiceProvider services;
+	private readonly List<Task> disposalTasks = [];
 
 	[UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_isBatchInProgress")]
 	private static extern ref bool GetIsBatchInProgressField(Renderer renderer);
@@ -178,29 +179,32 @@ public IReadOnlyList<RenderedComponent<TComponent>> FindComponents<TComponent>(R
 	/// <summary>
 	/// Disposes all components rendered by the <see cref="BunitRenderer" />.
 	/// </summary>
-	public void DisposeComponents()
+	public Task DisposeComponents()
 	{
 		ObjectDisposedException.ThrowIf(disposed, this);
 
+		Task? returnTask;
+
 		lock (renderTreeUpdateLock)
 		{
-			// The dispatcher will always return a completed task,
-			// when dealing with an IAsyncDisposable.
-			// Therefore checking for a completed task and awaiting it
-			// will only work on IDisposable
-			Dispatcher.InvokeAsync(() =>
+			returnTask = Dispatcher.InvokeAsync(async () =>
 			{
 				ResetUnhandledException();
 
 				foreach (var root in rootComponents)
 				{
 					root.Detach();
 				}
+
+				await Task.WhenAll(disposalTasks).ConfigureAwait(false);
+				disposalTasks.Clear();
 			});
 
 			rootComponents.Clear();
 			AssertNoUnhandledExceptions();
 		}
+
+		return returnTask;
 	}
 
 	/// <inheritdoc/>
@@ -212,6 +216,29 @@ protected override IComponent ResolveComponentForRenderMode(Type componentType,
 		return componentActivator.CreateInstance(componentType);
 	}
 
+	/// <inheritdoc/>
+	protected override void AddPendingTask(ComponentState? componentState, Task task)
+	{
+		if (componentState is null)
+		{
+			ArgumentNullException.ThrowIfNull(task);
+			AddDisposalTaskToQueue();
+		}
+
+		base.AddPendingTask(componentState, task);
+
+		void AddDisposalTaskToQueue()
+		{
+			var t = task;
+			t = task.ContinueWith(_ =>
+			{
+				disposalTasks.Remove(t);
+			}, TaskScheduler.Current);
+
+			disposalTasks.Add(t);
+		}
+	}
+
 	internal Task SetDirectParametersAsync(RenderedFragment renderedComponent, ParameterView parameters)
 	{
 		ObjectDisposedException.ThrowIf(disposed, this);
@@ -412,6 +439,7 @@ protected override void Dispose(bool disposing)
 				}
 
 				renderedComponents.Clear();
+				disposalTasks.Clear();
 				unhandledExceptionTsc.TrySetCanceled();
 			}
 

tests/bunit.testassets/AssertExtensions/TaskAssertionExtensions.cs

@@ -6,46 +6,46 @@ namespace Bunit;
 public class BunitContextTest : BunitContext
 {
 	[Fact(DisplayName = "DisposeComponents disposes rendered components in parent to child order")]
-	public void Test101()
+	public async Task Test101()
 	{
 		var callStack = new List<string>();
 		Render<ParentDispose>(ps => ps.Add(p => p.CallStack, callStack));
 
-		DisposeComponents();
+		await DisposeComponentsAsync();
 
 		callStack.Count.ShouldBe(2);
 		callStack[0].ShouldBe("ParentDispose");
 		callStack[1].ShouldBe("ChildDispose");
 	}
 
 	[Fact(DisplayName = "DisposeComponents disposes multiple rendered components")]
-	public void Test102()
+	public async Task Test102()
 	{
 		var callStack = new List<string>();
 		Render<ChildDispose>(ps => ps.Add(p => p.CallStack, callStack));
 		Render<ChildDispose>(ps => ps.Add(p => p.CallStack, callStack));
 
-		DisposeComponents();
+		await DisposeComponentsAsync();
 
 		callStack.Count.ShouldBe(2);
 	}
 
 	[Fact(DisplayName = "DisposeComponents rethrows exceptions from Dispose methods in components")]
-	public void Test103()
+	public async Task Test103()
 	{
 		Render<ThrowExceptionComponent>();
-		var action = () => DisposeComponents();
+		Func<Task> action = () => DisposeComponentsAsync();
 
-		action.ShouldThrow<NotSupportedException>();
+		await action.ShouldThrowAsync<NotSupportedException>();
 	}
 
 	[Fact(DisplayName = "DisposeComponents disposes components nested in render fragments")]
-	public void Test104()
+	public async Task Test104()
 	{
 		var callStack = new List<string>();
 		Render(DisposeFragments.ChildDisposeAsFragment(callStack));
 
-		DisposeComponents();
+		await DisposeComponentsAsync();
 
 		callStack.Count.ShouldBe(1);
 	}
@@ -171,16 +171,12 @@ public void Test0003()
 	[Fact(DisplayName = "DisposeComponents captures exceptions from DisposeAsync in Renderer.UnhandledException")]
 	public async Task Test201()
 	{
-		var tcs = new TaskCompletionSource();
-		var expected = new NotSupportedException();
-		Render<AsyncThrowExceptionComponent>(
-			ps => ps.Add(p => p.DisposedTask, tcs.Task));
+		Render<AsyncThrowAfterDelayComponent>();
 
-		DisposeComponents();
+		await DisposeComponentsAsync();
 
-		tcs.SetException(expected);
 		var actual = await Renderer.UnhandledException;
-		actual.ShouldBeSameAs(expected);
+		actual.ShouldBeAssignableTo<NotSupportedException>();
 	}
 
 	[Fact(DisplayName = "DisposeComponents calls DisposeAsync on rendered components")]
@@ -189,19 +185,19 @@ public async Task Test202()
 		var cut = Render<AsyncDisposableComponent>();
 		var wasDisposedTask = cut.Instance.DisposedTask;
 
-		DisposeComponents();
+		await DisposeComponentsAsync();
 
-		await wasDisposedTask.ShouldCompleteWithin(TimeSpan.FromSeconds(1));
+		wasDisposedTask.Status.ShouldBe(TaskStatus.RanToCompletion);
 	}
 
 	[Fact(DisplayName = "DisposeComponents should dispose components added via ComponentFactory")]
-	public void Test203()
+	public async Task Test203()
 	{
 		ComponentFactories.Add<ChildDispose, MyChildDisposeStub>();
 		var cut = Render<ParentDispose>(ps => ps.Add(p => p.CallStack, new List<string>()));
 		var instance = cut.FindComponent<MyChildDisposeStub>().Instance;
 
-		DisposeComponents();
+		await DisposeComponentsAsync();
 
 		instance.WasDisposed.ShouldBeTrue();
 	}
@@ -279,15 +275,13 @@ public void Dispose()
 			WasDisposed = true;
 		}
 	}
-
-	private sealed class AsyncThrowExceptionComponent : ComponentBase, IAsyncDisposable
+	
+	private sealed class AsyncThrowAfterDelayComponent : ComponentBase, IAsyncDisposable
 	{
-		[Parameter]
-		public Task DisposedTask { get; set; }
-
 		public async ValueTask DisposeAsync()
 		{
-			await DisposedTask;
+			await Task.Delay(1);
+			throw new NotSupportedException();
 		}
 	}