Big refactor of razor tests

Author: egil

src/bunit.core/Extensions/WaitForExtensions/RenderWaitingHelperExtensions.cs

@@ -66,7 +66,7 @@ public static void WaitForAssertion(this ITestContext testContext, Action assert
         /// <param name="timeout">The maximum time to wait for the desired state.</param>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="renderedFragment"/> is null.</exception>
         /// <exception cref="WaitForStateFailedException">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>
-        public static void WaitForState(this IRenderedFragment renderedFragment, Func<bool> statePredicate, TimeSpan? timeout = null)
+        public static void WaitForState(this IRenderedFragmentCore renderedFragment, Func<bool> statePredicate, TimeSpan? timeout = null)
             => WaitForState(renderedFragment.RenderEvents, statePredicate, timeout);
 
         /// <summary>
@@ -81,7 +81,7 @@ public static void WaitForState(this IRenderedFragment renderedFragment, Func<bo
         /// <param name="timeout">The maximum time to attempt the verification.</param>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="renderedFragment"/> is null.</exception>
         /// <exception cref="WaitForAssertionFailedException">Thrown if the timeout has been reached. See the inner exception to see the captured assertion exception.</exception>
-        public static void WaitForAssertion(this IRenderedFragment renderedFragment, Action assertion, TimeSpan? timeout = null)
+        public static void WaitForAssertion(this IRenderedFragmentCore renderedFragment, Action assertion, TimeSpan? timeout = null)
             => WaitForAssertion(renderedFragment.RenderEvents, assertion, timeout);
 
         private static void WaitForRender(IObservable<RenderEvent> renderEventObservable, Action? renderTrigger = null, TimeSpan? timeout = null)

src/bunit.core/IRenderedComponent.cs src/bunit.core/IRenderedComponentCore.cssrc/bunit.core/IRenderedComponent.cs renamed to src/bunit.core/IRenderedComponentCore.cs

@@ -7,7 +7,7 @@ namespace Bunit
 	/// Represents a rendered component-under-test. 
 	/// </summary>
 	/// <typeparam name="TComponent">The type of the component under test</typeparam>
-	public interface IRenderedComponent<out TComponent> : IRenderedFragment where TComponent : IComponent
+	public interface IRenderedComponentCore<out TComponent> : IRenderedFragmentCore where TComponent : IComponent
     {
         /// <summary>
         /// Gets the component under test

src/bunit.core/IRenderedFragment.cs

@@ -6,7 +6,7 @@ namespace Bunit
 	/// <summary>
 	/// Represents a rendered fragment.
 	/// </summary>
-	public interface IRenderedFragment
+	public interface IRenderedFragmentCore
 	{
 		/// <summary>
 		/// Gets the id of the rendered component or fragment.
@@ -15,7 +15,7 @@ public interface IRenderedFragment
 
 		/// <summary>
 		/// Gets an <see cref="IObservable{RenderEvent}"/> which will provide subscribers with <see cref="RenderEvent"/>s 
-		/// whenever the <see cref="IRenderedFragment"/> is rendered.
+		/// whenever the <see cref="IRenderedFragmentCore"/> is rendered.
 		/// </summary>
 		IObservable<RenderEvent> RenderEvents { get; }
 

src/bunit.core/ITestContext.cs

@@ -1,4 +1,5 @@
 using System;
+using Bunit.Rendering;
 using Bunit.Rendering.RenderEvents;
 
 namespace Bunit
@@ -8,6 +9,11 @@ namespace Bunit
 	/// </summary>
 	public partial interface ITestContext : IDisposable
 	{
+		/// <summary>
+		/// Gets the renderer used by the test context.
+		/// </summary>
+		TestRenderer Renderer { get; }
+
 		/// <summary>
 		/// Gets the service collection and service provider that is used when a 
 		/// component is rendered by the test context.

src/bunit.core/RazorTesting/Fixture.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Bunit.RazorTesting;
+using Bunit.Rendering;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Bunit
+{
+	/// <summary>
+	/// Represents a single fixture in a Razor based test. Used to
+	/// define the <see cref="ComponentUnderTest"/> and any <see cref="Fragment"/>'s
+	/// you might need during testing, and assert against them in the Test methods.
+	/// </summary>
+	public abstract class FixtureBase<TFixture> : RazorTest
+	{
+		/// <summary>
+		/// Gets or sets the child content of the fragment.
+		/// </summary>
+		[Parameter] public RenderFragment ChildContent { get; set; } = default!;
+
+		/// <summary>
+		/// Gets or sets the setup action to perform before the <see cref="Test"/> action,
+		/// <see cref="TestAsync"/> action and <see cref="Tests"/> and <see cref="TestsAsync"/> actions are invoked.
+		/// </summary>
+		[Parameter] public Action<TFixture>? Setup { private get; set; }
+
+		/// <summary>
+		/// Gets or sets the asynchronous setup action to perform before the <see cref="Test"/> action,
+		/// <see cref="TestAsync"/> action and <see cref="Tests"/> and <see cref="TestsAsync"/> actions are invoked.
+		/// </summary>
+		[Parameter] public Func<TFixture, Task>? SetupAsync { private get; set; }
+
+		/// <summary>
+		/// Gets or sets the first test action to invoke, after the <see cref="Setup"/> action has
+		/// executed (if provided).
+		/// 
+		/// Use this to assert against the <see cref="ComponentUnderTest"/> and <see cref="Fragment"/>'s
+		/// defined in the <see cref="FixtureBase"/>.
+		/// </summary>
+		[Parameter] public Action<TFixture>? Test { private get; set; }
+
+		/// <summary>
+		/// Gets or sets the first test action to invoke, after the <see cref="SetupAsync"/> action has
+		/// executed (if provided).
+		/// 
+		/// Use this to assert against the <see cref="ComponentUnderTest"/> and <see cref="Fragment"/>'s
+		/// defined in the <see cref="FixtureBase"/>.
+		/// </summary>
+		[Parameter] public Func<TFixture, Task>? TestAsync { private get; set; }
+
+		/// <summary>
+		/// Gets or sets the test actions to invoke, one at the time, in the order they are placed 
+		/// into the collection, after the <see cref="Setup"/> action and the <see cref="Test"/> action has
+		/// executed (if provided).
+		/// 
+		/// Use this to assert against the <see cref="ComponentUnderTest"/> and <see cref="Fragment"/>'s
+		/// defined in the <see cref="FixtureBase"/>.
+		/// </summary>
+		[Parameter] public IReadOnlyCollection<Action<TFixture>>? Tests { private get; set; }
+
+		/// <summary>
+		/// Gets or sets the test actions to invoke, one at the time, in the order they are placed 
+		/// into the collection, after the <see cref="SetupAsync"/> action and the <see cref="TestAsync"/> action has
+		/// executed (if provided).
+		/// 
+		/// Use this to assert against the <see cref="ComponentUnderTest"/> and <see cref="Fragment"/>'s
+		/// defined in the <see cref="FixtureBase"/>.
+		/// </summary>
+		[Parameter] public IReadOnlyCollection<Func<TFixture, Task>>? TestsAsync { private get; set; }
+
+		/// <inheritdoc/>
+		public override Task SetParametersAsync(ParameterView parameters)
+		{
+			if (parameters.TryGetValue<RenderFragment>(nameof(ChildContent), out RenderFragment childContent))
+				ChildContent = childContent;
+			else
+				throw new InvalidOperationException($"No {nameof(ChildContent)} specified in the {GetType().Name} component.");
+
+			Setup = parameters.GetValueOrDefault<Action<TFixture>>(nameof(Setup));
+			SetupAsync = parameters.GetValueOrDefault<Func<TFixture, Task>>(nameof(SetupAsync));
+			Test = parameters.GetValueOrDefault<Action<TFixture>>(nameof(Test));
+			TestAsync = parameters.GetValueOrDefault<Func<TFixture, Task>>(nameof(TestAsync));
+			Tests = parameters.GetValueOrDefault<IReadOnlyCollection<Action<TFixture>>>(nameof(Tests));
+			TestsAsync = parameters.GetValueOrDefault<IReadOnlyCollection<Func<TFixture, Task>>>(nameof(TestsAsync));
+
+			return base.SetParametersAsync(parameters);
+		}
+
+		/// <inheritdoc/>
+		protected virtual async Task Run(TFixture self)
+		{
+			if (Setup is { })
+				TryRun(Setup, self);
+
+			if (SetupAsync is { })
+				await TryRunAsync(SetupAsync, self).ConfigureAwait(false);
+
+			if (Test is { })
+				TryRun(Test, self);
+
+			if (TestAsync is { })
+				await TryRunAsync(TestAsync, self).ConfigureAwait(false);
+
+			foreach (var test in Tests ?? Array.Empty<Action<TFixture>>())
+				TryRun(test, self);
+
+			foreach (var test in TestsAsync ?? Array.Empty<Func<TFixture, Task>>())
+				await TryRunAsync(test, self).ConfigureAwait(false);
+		}
+	}
+}

src/bunit.core/RazorTesting/FixtureBase.cs

@@ -9,16 +9,6 @@ namespace Bunit.RazorTesting
 	/// </summary>
 	public abstract class FragmentBase : IComponent
 	{
-		/// <summary>
-		/// A no-op test method.
-		/// </summary>
-		protected static void NoopTestMethod() { }
-
-		/// <summary>
-		/// A no-op async test method
-		/// </summary>
-		protected static Task NoopTestMethodAsync() => Task.CompletedTask;
-
 		/// <summary>
 		/// Gets or sets the child content of the fragment.
 		/// </summary>

src/bunit.core/RazorTesting/FixtureFailedException.cs

@@ -1,7 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Components;
 
@@ -10,8 +7,13 @@ namespace Bunit.RazorTesting
 	/// <summary>
 	/// Represents a component used to define tests in Razor files.
 	/// </summary>
-	public abstract class RazorTest : FragmentBase
+	public abstract class RazorTest : TestContextBase, ITestContext, IComponent
 	{
+		/// <summary>
+		/// Gets whether the tests is running or not.
+		/// </summary>
+		public bool IsRunning { get; private set; }
+
 		/// <summary>
 		/// A description or name for the test that will be displayed if the test fails.
 		/// </summary>
@@ -25,10 +27,72 @@ public abstract class RazorTest : FragmentBase
 		/// <summary>
 		/// Run the test logic of the <see cref="RazorTest"/>.
 		/// </summary>
+		/// <exception cref="InvalidOperationException">Thrown when called and <see cref="IsRunning"/> is true.</exception>
 		/// <returns></returns>
-		public abstract Task RunTest();
+		public async Task RunTest()
+		{
+			if (IsRunning)
+				throw new InvalidOperationException("The fixture test is already running.");
+
+			IsRunning = true;
+
+			try
+			{
+				await Run().ConfigureAwait(false);
+			}
+			finally
+			{
+				IsRunning = false;
+			}
+		}
 
 		/// <inheritdoc/>
 		public override string ToString() => $"{Description ?? "[no description]"}";
+
+		/// <inheritdoc/>
+		public virtual Task SetParametersAsync(ParameterView parameters)
+		{
+			Skip = parameters.GetValueOrDefault<string>(nameof(Skip));
+			Description = parameters.GetValueOrDefault<string>(nameof(Description));
+			return Task.CompletedTask;
+		}
+
+		/// <inheritdoc/>
+		void IComponent.Attach(RenderHandle renderHandle) { }
+
+		/// <summary>
+		/// Implements the logic for running the test.
+		/// </summary>
+		protected abstract Task Run();
+
+		/// <summary>
+		/// Try to run the <see cref="Action{T}"/>.
+		/// </summary>
+		protected void TryRun<T>(Action<T> action, T input)
+		{
+			try
+			{
+				action(input);
+			}
+			catch (Exception ex)
+			{
+				throw new RazorTestFailedException(Description ?? $"{action.Method.Name} failed:", ex);
+			}
+		}
+
+		/// <summary>
+		/// Try to run the <see cref="Func{T, Task}"/>.
+		/// </summary>
+		protected async Task TryRunAsync<T>(Func<T, Task> action, T input)
+		{
+			try
+			{
+				await action(input).ConfigureAwait(false);
+			}
+			catch (Exception ex)
+			{
+				throw new RazorTestFailedException(Description ?? $"{action.Method.Name} failed:", ex);
+			}
+		}
 	}
 }