feat: Added Async overload of WaitForHelpers (#892)

* feat: Added Async overload of WaitForHelpers

Author: linkdotnet

.github/workflows/verification.yml

@@ -16,10 +16,10 @@ on:
       - reopened
 
   workflow_dispatch:
-  
+
 concurrency:
   group: verification-${{ github.ref }}-1
-  cancel-in-progress: true  
+  cancel-in-progress: true
 
 jobs:
   verify-bunit:
@@ -62,9 +62,12 @@ jobs:
         with:
           files: '["docs/site/*.md", "docs/**/*.md", "docs/**/*.tmpl.partial", "*.csproj", "**/*.csproj"]'
 
-      - name: 🧪 Run unit tests
+      - name: 🧪 Run unit tests (async)
+        run: |
+          dotnet test --filter Category!=sync -c release --blame-hang-timeout 15s --blame-hang-dump-type full --blame-crash-dump-type full
+      - name: 🧪 Run unit tests (sync)
         run: |
-          dotnet test -c release --blame-hang-timeout 15s --blame-hang-dump-type full --blame-crash-dump-type full
+          dotnet test --filter Category!=async -c release --blame-hang-timeout 15s --blame-hang-dump-type full --blame-crash-dump-type full
       - name: 📛 Upload hang- and crash-dumps on test failure
         if: failure()
         uses: actions/upload-artifact@v3

src/bunit.core/Extensions/WaitForHelpers/RenderedFragmentWaitForHelperExtensions.cs

@@ -34,13 +34,29 @@ public static void WaitForState(this IRenderedFragmentBase renderedFragment, Fun
 			{
 				ExceptionDispatchInfo.Capture(aggregateException.InnerExceptions[0]).Throw();
 			}
-			else
-			{
-				ExceptionDispatchInfo.Capture(e).Throw();
-			}
+
+			throw;
 		}
 	}
 
+	/// <summary>
+	/// Wait until the provided <paramref name="statePredicate"/> action returns true,
+	/// or the <paramref name="timeout"/> is reached (default is one second).
+	///
+	/// The <paramref name="statePredicate"/> is evaluated initially, and then each time
+	/// the <paramref name="renderedFragment"/> renders.
+	/// </summary>
+	/// <param name="renderedFragment">The render fragment or component to attempt to verify state against.</param>
+	/// <param name="statePredicate">The predicate to invoke after each render, which must returns <c>true</c> when the desired state has been reached.</param>
+	/// <param name="timeout">The maximum time to wait for the desired state.</param>
+	/// <exception cref="WaitForFailedException">Thrown if the <paramref name="statePredicate"/> throw an exception during invocation, or if the timeout has been reached. See the inner exception for details.</exception>
+	internal static async Task WaitForStateAsync(this IRenderedFragmentBase renderedFragment, Func<bool> statePredicate, TimeSpan? timeout = null)
+	{
+		using var waiter = new WaitForStateHelper(renderedFragment, statePredicate, timeout);
+
+		await waiter.WaitTask;
+	}
+
 	/// <summary>
 	/// Wait until the provided <paramref name="assertion"/> passes (i.e. does not throw an
 	/// exception), or the <paramref name="timeout"/> is reached (default is one second).
@@ -66,10 +82,26 @@ public static void WaitForAssertion(this IRenderedFragmentBase renderedFragment,
 			{
 				ExceptionDispatchInfo.Capture(aggregateException.InnerExceptions[0]).Throw();
 			}
-			else
-			{
-				ExceptionDispatchInfo.Capture(e).Throw();
-			}
+
+			throw;
 		}
 	}
+
+	/// <summary>
+	/// Wait until the provided <paramref name="assertion"/> passes (i.e. does not throw an
+	/// exception), or the <paramref name="timeout"/> is reached (default is one second).
+	///
+	/// The <paramref name="assertion"/> is attempted initially, and then each time the <paramref name="renderedFragment"/> renders.
+	/// </summary>
+	/// <param name="renderedFragment">The rendered fragment to wait for renders from and assert against.</param>
+	/// <param name="assertion">The verification or assertion to perform.</param>
+	/// <param name="timeout">The maximum time to attempt the verification.</param>
+	/// <exception cref="WaitForFailedException">Thrown if the timeout has been reached. See the inner exception to see the captured assertion exception.</exception>
+	[AssertionMethod]
+	internal static async Task WaitForAssertionAsync(this IRenderedFragmentBase renderedFragment, Action assertion, TimeSpan? timeout = null)
+	{
+		using var waiter = new WaitForAssertionHelper(renderedFragment, assertion, timeout);
+
+		await waiter.WaitTask;
+	}
 }

src/bunit.core/InternalsVisibleTo.cs

@@ -1 +1,2 @@
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Bunit.Core.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010001be6b1a2ca57b09b7040e2ab0993e515296ae22aef4031a4fe388a1336fe21f69c7e8610e9935de6ed18d94b5c98429f99ef62ce3d0af28a7088f856239368ea808ad4c448aa2a8075ed581f989f36ed0d0b8b1cfcaf1ff6a4506c8a99b7024b6eb56996d08e3c9c1cf5db59bff96fcc63ccad155ef7fc63aab6a69862437b6")]
+[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Bunit.Web.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010001be6b1a2ca57b09b7040e2ab0993e515296ae22aef4031a4fe388a1336fe21f69c7e8610e9935de6ed18d94b5c98429f99ef62ce3d0af28a7088f856239368ea808ad4c448aa2a8075ed581f989f36ed0d0b8b1cfcaf1ff6a4506c8a99b7024b6eb56996d08e3c9c1cf5db59bff96fcc63ccad155ef7fc63aab6a69862437b6")]

src/bunit.web/Extensions/WaitForHelpers/RenderedFragmentWaitForHelperExtensions.cs

@@ -80,6 +80,77 @@ public static IRefreshableElementCollection<IElement> WaitForElements(this IRend
 	public static IRefreshableElementCollection<IElement> WaitForElements(this IRenderedFragment renderedFragment, string cssSelector, int matchElementCount, TimeSpan timeout)
 		=> WaitForElementsCore(renderedFragment, cssSelector, matchElementCount: matchElementCount, timeout: timeout);
 
+	/// <summary>
+	/// Wait until an element matching the <paramref name="cssSelector"/> exists in the <paramref name="renderedFragment"/>,
+	/// or the timeout is reached (default is one second).
+	/// </summary>
+	/// <param name="renderedFragment">The render fragment or component find the matching element in.</param>
+	/// <param name="cssSelector">The CSS selector to use to search for the element.</param>
+	/// <exception cref="WaitForFailedException">Thrown if no elements is found matching the <paramref name="cssSelector"/> within the default timeout. See the inner exception for details.</exception>
+	/// <returns>The <see cref="IElement"/>.</returns>
+	internal static Task<IElement> WaitForElementAsync(this IRenderedFragment renderedFragment, string cssSelector)
+		=> WaitForElementCoreAsync(renderedFragment, cssSelector, timeout: null);
+
+	/// <summary>
+	/// Wait until an element matching the <paramref name="cssSelector"/> exists in the <paramref name="renderedFragment"/>,
+	/// or the <paramref name="timeout"/> is reached.
+	/// </summary>
+	/// <param name="renderedFragment">The render fragment or component find the matching element in.</param>
+	/// <param name="cssSelector">The CSS selector to use to search for the element.</param>
+	/// <param name="timeout">The maximum time to wait for the element to appear.</param>
+	/// <exception cref="WaitForFailedException">Thrown if no elements is found matching the <paramref name="cssSelector"/> within the default timeout. See the inner exception for details.</exception>
+	/// <returns>The <see cref="IElement"/>.</returns>
+	internal static Task<IElement> WaitForElementAsync(this IRenderedFragment renderedFragment, string cssSelector, TimeSpan timeout)
+		=> WaitForElementCoreAsync(renderedFragment, cssSelector, timeout: timeout);
+
+	/// <summary>
+	/// Wait until exactly <paramref name="matchElementCount"/> element(s) matching the <paramref name="cssSelector"/> exists in the <paramref name="renderedFragment"/>,
+	/// or the timeout is reached (default is one second).
+	/// </summary>
+	/// <param name="renderedFragment">The render fragment or component find the matching element in.</param>
+	/// <param name="cssSelector">The CSS selector to use to search for elements.</param>
+	/// <param name="matchElementCount">The exact number of elements to that the <paramref name="cssSelector"/> should match.</param>
+	/// <exception cref="WaitForFailedException">Thrown if no elements is found matching the <paramref name="cssSelector"/> within the default timeout.</exception>
+	/// <returns>The <see cref="IRefreshableElementCollection{IElement}"/>.</returns>
+	internal static Task<IRefreshableElementCollection<IElement>> WaitForElementsAsync(this IRenderedFragment renderedFragment, string cssSelector, int matchElementCount)
+		=> WaitForElementsCoreAsync(renderedFragment, cssSelector, matchElementCount: matchElementCount, timeout: null);
+
+	/// <summary>
+	/// Wait until at least one element matching the <paramref name="cssSelector"/> exists in the <paramref name="renderedFragment"/>,
+	/// or the <paramref name="timeout"/> is reached.
+	/// </summary>
+	/// <param name="renderedFragment">The render fragment or component find the matching element in.</param>
+	/// <param name="cssSelector">The CSS selector to use to search for elements.</param>
+	/// <param name="timeout">The maximum time to wait for elements to appear.</param>
+	/// <exception cref="WaitForFailedException">Thrown if no elements is found matching the <paramref name="cssSelector"/> within the default timeout.</exception>
+	/// <returns>The <see cref="IRefreshableElementCollection{IElement}"/>.</returns>
+	internal static Task<IRefreshableElementCollection<IElement>> WaitForElementsAsync(this IRenderedFragment renderedFragment, string cssSelector, TimeSpan timeout)
+		=> WaitForElementsCoreAsync(renderedFragment, cssSelector, matchElementCount: null, timeout: timeout);
+
+	/// <summary>
+	/// Wait until exactly <paramref name="matchElementCount"/> element(s) matching the <paramref name="cssSelector"/> exists in the <paramref name="renderedFragment"/>,
+	/// or the <paramref name="timeout"/> is reached.
+	/// </summary>
+	/// <param name="renderedFragment">The render fragment or component find the matching element in.</param>
+	/// <param name="cssSelector">The CSS selector to use to search for elements.</param>
+	/// <param name="matchElementCount">The exact number of elements to that the <paramref name="cssSelector"/> should match.</param>
+	/// <param name="timeout">The maximum time to wait for elements to appear.</param>
+	/// <exception cref="WaitForFailedException">Thrown if no elements is found matching the <paramref name="cssSelector"/> within the default timeout.</exception>
+	/// <returns>The <see cref="IRefreshableElementCollection{IElement}"/>.</returns>
+	internal static Task<IRefreshableElementCollection<IElement>> WaitForElementsAsync(this IRenderedFragment renderedFragment, string cssSelector, int matchElementCount, TimeSpan timeout)
+		=> WaitForElementsCoreAsync(renderedFragment, cssSelector, matchElementCount: matchElementCount, timeout: timeout);
+
+	/// <summary>
+	/// Wait until at least one element matching the <paramref name="cssSelector"/> exists in the <paramref name="renderedFragment"/>,
+	/// or the timeout is reached (default is one second).
+	/// </summary>
+	/// <param name="renderedFragment">The render fragment or component find the matching element in.</param>
+	/// <param name="cssSelector">The CSS selector to use to search for elements.</param>
+	/// <exception cref="WaitForFailedException">Thrown if no elements is found matching the <paramref name="cssSelector"/> within the default timeout.</exception>
+	/// <returns>The <see cref="IRefreshableElementCollection{IElement}"/>.</returns>
+	internal static Task<IRefreshableElementCollection<IElement>> WaitForElementsAsync(this IRenderedFragment renderedFragment, string cssSelector)
+		=> WaitForElementsCoreAsync(renderedFragment, cssSelector, matchElementCount: null, timeout: null);
+
 	private static IElement WaitForElementCore(this IRenderedFragment renderedFragment, string cssSelector, TimeSpan? timeout)
 	{
 		using var waiter = new WaitForElementHelper(renderedFragment, cssSelector, timeout);
@@ -94,16 +165,18 @@ private static IElement WaitForElementCore(this IRenderedFragment renderedFragme
 			{
 				ExceptionDispatchInfo.Capture(aggregateException.InnerExceptions[0]).Throw();
 			}
-			else
-			{
-				ExceptionDispatchInfo.Capture(e).Throw();
-			}
 
-			// Unreachable code. Only here because compiler does not know that ExceptionDispatchInfo throws an exception
 			throw;
 		}
 	}
 
+	private static async Task<IElement> WaitForElementCoreAsync(this IRenderedFragment renderedFragment, string cssSelector, TimeSpan? timeout)
+	{
+		using var waiter = new WaitForElementHelper(renderedFragment, cssSelector, timeout);
+
+		return await waiter.WaitTask;
+	}
+
 	private static IRefreshableElementCollection<IElement> WaitForElementsCore(
 		this IRenderedFragment renderedFragment,
 		string cssSelector,
@@ -122,13 +195,19 @@ private static IRefreshableElementCollection<IElement> WaitForElementsCore(
 			{
 				ExceptionDispatchInfo.Capture(aggregateException.InnerExceptions[0]).Throw();
 			}
-			else
-			{
-				ExceptionDispatchInfo.Capture(e).Throw();
-			}
 
-			// Unreachable code. Only here because compiler does not know that ExceptionDispatchInfo throws an exception
 			throw;
 		}
 	}
+
+	private static async Task<IRefreshableElementCollection<IElement>> WaitForElementsCoreAsync(
+		this IRenderedFragment renderedFragment,
+		string cssSelector,
+		int? matchElementCount,
+		TimeSpan? timeout)
+	{
+		using var waiter = new WaitForElementsHelper(renderedFragment, cssSelector, matchElementCount, timeout);
+
+		return await waiter.WaitTask;
+	}
 }

tests/bunit.core.tests/Rendering/TestRendererTest.cs

@@ -337,7 +337,18 @@ public void Test100()
 	}
 
 	[Fact(DisplayName = "Can render component that awaits yielding task in OnInitializedAsync")]
-	public void Test101()
+	[Trait("Category", "async")]
+	public async Task Test101()
+	{
+		var cut = RenderComponent<AsyncRenderOfSubComponentDuringInit>(parameters =>
+			parameters.Add(p => p.EitherOr, Task.Delay(1)));
+
+		await cut.WaitForAssertionAsync(() => cut.Find("h1").TextContent.ShouldBe("SECOND"));
+	}
+
+	[Fact(DisplayName = "Can render component that awaits yielding task in OnInitializedAsync")]
+	[Trait("Category", "sync")]
+	public void Test101_Sync()
 	{
 		var cut = RenderComponent<AsyncRenderOfSubComponentDuringInit>(parameters =>
 			parameters.Add(p => p.EitherOr, Task.Delay(1)));