Moved to property based exposure of test contexts render tree for better consistancy with Services and JSInterop property

Author: egil

src/bunit.core/ITestContext.cs

@@ -7,7 +7,7 @@ namespace Bunit.RazorTesting
 	/// <summary>
 	/// Represents a component used to define tests in Razor files.
 	/// </summary>
-	public abstract class RazorTestBase : TestContextBase, ITestContext, IComponent
+	public abstract class RazorTestBase : TestContextBase, IComponent
 	{
 		/// <summary>
 		/// Gets the name of the test, which is displayed by the test runner/explorer.

src/bunit.core/RazorTesting/RazorTestBase.cs

@@ -7,11 +7,13 @@ namespace Bunit
 	/// <summary>
 	/// A test context is a factory that makes it possible to create components under tests.
 	/// </summary>
-	public class TestContextBase : ITestContext, IDisposable
+	public abstract class TestContextBase : IDisposable
 	{
 		private ITestRenderer? _testRenderer;
 
-		/// <inheritdoc/>
+		/// <summary>
+		/// Gets the renderer used by the test context.
+		/// </summary>
 		public ITestRenderer Renderer
 		{
 			get
@@ -24,13 +26,16 @@ public ITestRenderer Renderer
 			}
 		}
 
-		/// <inheritdoc/>
+		/// <summary>
+		/// Gets the service collection and service provider that is used when a 
+		/// component is rendered by the test context.
+		/// </summary>
 		public TestServiceProvider Services { get; }
 
 		/// <summary>
-		/// Creates a new instance of the <see cref="ITestContext"/> class.
+		/// Creates a new instance of the <see cref="TestContextBase"/> class.
 		/// </summary>
-		public TestContextBase()
+		protected TestContextBase()
 		{
 			Services = new TestServiceProvider();
 			Services.AddSingleton<ITestRenderer, TestRenderer>();

src/bunit.core/TestContextBase.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.AspNetCore.Components;
+
+namespace Bunit.Rendering
+{
+	/// <summary>
+	/// Represents a root render tree, wherein components under tests will be rendered.
+	/// Components added to the render tree must have either a <c>ChildContent</c> or
+	/// <c>Body</c> parameter.
+	/// </summary>
+	public sealed class RootRenderTree : IReadOnlyCollection<RootRenderTreeRegistration>
+	{
+		private readonly List<RootRenderTreeRegistration> _registrations = new();
+
+		/// <summary>
+		/// Adds a component to the render tree. This method can
+		/// be called multiple times, with each invocation adding a component
+		/// to the render tree. The <typeparamref name="TComponent"/> must have a <c>ChildContent</c>
+		/// or <c>Body</c> parameter.
+		/// </summary>
+		/// <typeparam name="TComponent">The type of the component to add to the render tree.</typeparam>
+		/// <param name="parameterBuilder">An optional parameter builder, used to pass parameters to <typeparamref name="TComponent"/>.</param>
+		public void Add<TComponent>(Action<ComponentParameterCollectionBuilder<TComponent>>? parameterBuilder = null) where TComponent : IComponent
+		{
+			var registration = new RootRenderTreeRegistration(
+				typeof(TComponent),
+				CreateRenderFragmentBuilder<TComponent>(parameterBuilder)
+			);
+			_registrations.Add(registration);
+		}
+
+		/// <summary>
+		/// Try to add a component to the render tree if it has not already been added. This method can
+		/// be called multiple times, with each invocation adding a component
+		/// to the render tree. The <typeparamref name="TComponent"/> must have a <c>ChildContent</c>
+		/// or <c>Body</c> parameter.
+		/// </summary>
+		/// <remarks>
+		/// This method will only add the component to the render tree if it has not already been added.
+		/// Use <see cref="Add{TComponent}(Action{ComponentParameterCollectionBuilder{TComponent}}?)"/> to
+		/// add the same component multiple times.
+		/// </remarks>
+		/// <typeparam name="TComponent">The type of the component to add to the render tree.</typeparam>
+		/// <param name="parameterBuilder">An optional parameter builder, used to pass parameters to <typeparamref name="TComponent"/>.</param>
+		/// <returns>True if component was added, false if it was previously added and not added again.</returns>
+		public bool TryAdd<TComponent>(Action<ComponentParameterCollectionBuilder<TComponent>>? parameterBuilder = null) where TComponent : IComponent
+		{
+			var componentType = typeof(TComponent);
+			if (_registrations.Any(x => x.ComponentType == componentType))
+				return false;
+
+			var registration = new RootRenderTreeRegistration(
+				componentType,
+				CreateRenderFragmentBuilder<TComponent>(parameterBuilder)
+			);
+			_registrations.Add(registration);
+
+			return true;
+		}
+
+		/// <inheritdoc/>
+		public int Count => _registrations.Count;
+
+		/// <inheritdoc/>
+		public IEnumerator<RootRenderTreeRegistration> GetEnumerator() => _registrations.GetEnumerator();
+
+		/// <inheritdoc/>
+		IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+		/// <summary>
+		/// Creates a new <see cref="RenderFragment"/> that wraps <paramref name="target"/>
+		/// inside the components registered in this <see cref="RootRenderTree"/>.
+		/// </summary>
+		/// <param name="target"><see cref="RenderFragment"/> to render inside the render tree.</param>
+		/// <returns>A <see cref="RenderFragment"/> that renders the <paramref name="target"/> inside this <see cref="RootRenderTree"/> render tree.</returns>
+		internal RenderFragment Wrap(RenderFragment target)
+		{
+			// Wrap from the last added to the first added, as we start with the
+			// target and goes from inside to out.
+			var result = target;
+			for (int i = _registrations.Count - 1; i >= 0; i--)
+			{
+				result = _registrations[i].RenderFragmentBuilder(result);
+			}
+			return result;
+		}
+
+		/// <summary>
+		/// Gets the number of registered components of type <typeparamref name="TComponent"/>
+		/// in the render tree.
+		/// </summary>
+		/// <typeparam name="TComponent">Component type to count.</typeparam>
+		/// <returns>Number of components of type <typeparamref name="TComponent"/> in render tree.</returns>
+		internal int GetCountOf<TComponent>() where TComponent : IComponent
+		{
+			var result = 0;
+			var countType = typeof(TComponent);
+
+			for (int i = 0; i < _registrations.Count; i++)
+			{
+				if (countType == _registrations[i].ComponentType)
+					result++;
+			}
+
+			return result;
+		}
+
+		private static RenderFragment<RenderFragment> CreateRenderFragmentBuilder<TComponent>(Action<ComponentParameterCollectionBuilder<TComponent>>? parameterBuilder) where TComponent : IComponent
+		{
+			return rc =>
+			{
+				var builder = new ComponentParameterCollectionBuilder<TComponent>();
+				parameterBuilder?.Invoke(builder);
+
+				var added = builder.TryAdd("ChildContent", rc) || builder.TryAdd("Body", rc);
+				if (!added)
+					throw new ArgumentException($"The {typeof(TComponent)} does not have a ChildContent or Body parameter. Only components with one of these parameters can be added to the root render tree.");
+
+				return builder.Build().ToRenderFragment<TComponent>();
+			};
+		}
+	}
+}

src/bunit.web/Rendering/RootRenderTree.cs

@@ -0,0 +1,32 @@
+using System;
+using Microsoft.AspNetCore.Components;
+
+namespace Bunit.Rendering
+{
+	/// <summary>
+	/// Represents an added component with parameters in an <see cref="RootRenderTree"/>.
+	/// </summary>
+	public sealed class RootRenderTreeRegistration
+	{
+		/// <summary>
+		/// Gets the type of component registered.
+		/// </summary>
+		public Type ComponentType { get; }
+
+		/// <summary>
+		/// Gets the render fragment builder that renders the component of type <see cref="ComponentType"/>
+		/// with the specified parameters and the provided <see cref="RenderFragment"/> passed to its
+		/// ChildContent or Body parameter.
+		/// </summary>
+		public RenderFragment<RenderFragment> RenderFragmentBuilder { get; }
+
+		/// <summary>
+		/// Creates an instance of the <see cref="RootRenderTreeRegistration"/> type.
+		/// </summary>
+		internal RootRenderTreeRegistration(Type componentType, RenderFragment<RenderFragment> renderFragmentBuilder)
+		{
+			ComponentType = componentType;
+			RenderFragmentBuilder = renderFragmentBuilder;
+		}
+	}
+}

src/bunit.web/Rendering/RootRenderTreeRegistration.cs

@@ -1,47 +1,30 @@
 using System;
 using System.Collections.Generic;
 using Bunit.Extensions;
+using Bunit.Rendering;
 using Microsoft.AspNetCore.Components;
 
 namespace Bunit
 {
 	/// <summary>
 	/// A test context is a factory that makes it possible to create components under tests.
 	/// </summary>
-	public class TestContext : TestContextBase, ITestContext
+	public class TestContext : TestContextBase
 	{
-		private readonly List<(Type LayoutType, RenderFragment<RenderFragment> LayoutFragment)> _layouts = new();
-
 		/// <summary>
-		/// Creates a new instance of the <see cref="TestContext"/> class.
+		/// Gets the <see cref="RootRenderTree"/> that all components rendered with the
+		/// <c>RenderComponent&lt;TComponent&gt;()</c> methods, are rendered inside.
 		/// </summary>
-		public TestContext() => Services.AddDefaultTestContextServices();
+		/// <remarks>
+		/// Use this to add default layout- or root-components which a component under test
+		/// should be rendered under.
+		/// </remarks>
+		public RootRenderTree RenderTree { get; } = new RootRenderTree();
 
 		/// <summary>
-		/// Adds a "layout" component to the test context, which components rendered using one of the 
-		/// <c>RenderComponent&lt;TComponent&gt;()</c>> methods will be rendered inside. This method can
-		/// be called multiple times, with each invocation adding a <typeparamref name="TComponent"/>
-		/// to the "layout" render tree. The <typeparamref name="TComponent"/> must have a <c>ChildContent</c>
-		/// or <c>Body</c> parameter.
+		/// Creates a new instance of the <see cref="TestContext"/> class.
 		/// </summary>
-		/// <typeparam name="TComponent">The type of the component to use as a layout component.</typeparam>
-		/// <param name="parameterBuilder">An optional parameter builder, used to pass parameters to <typeparamref name="TComponent"/>.</param>
-		public virtual void AddLayoutComponent<TComponent>(Action<ComponentParameterCollectionBuilder<TComponent>>? parameterBuilder = null) where TComponent : IComponent
-		{
-			RenderFragment<RenderFragment> layoutFragment = rc =>
-			{
-				var builder = new ComponentParameterCollectionBuilder<TComponent>();
-				parameterBuilder?.Invoke(builder);
-
-				var added = builder.TryAdd("ChildContent", rc) || builder.TryAdd("Body", rc);
-				if (!added)
-					throw new ArgumentException($"The {typeof(TComponent)} does not have a ChildContent or Body parameter. Only components with one of these parameters can be used as layout components.");
-
-				return builder.Build().ToRenderFragment<TComponent>();
-			};
-
-			_layouts.Add((typeof(TComponent), layoutFragment));
-		}
+		public TestContext() => Services.AddDefaultTestContextServices();
 
 		/// <summary>
 		/// Instantiates and performs a first render of a component of type <typeparamref name="TComponent"/>.
@@ -73,25 +56,14 @@ private IRenderedComponent<TComponent> RenderComponent<TComponent>(RenderFragmen
 		{
 			// Wrap TComponent in any layout components added to the test context.
 			// If one of the layout components is the same type as TComponent,
-			// make sure to return the rendered component, not the layout compnent.
-			var rcType = typeof(TComponent);
-			var rcInLayoutCount = 0;
-			var wrappedRenderFragment = renderFragment;
-
-			for (int i = 0; i < _layouts.Count; i++)
-			{
-				if (rcType == _layouts[i].LayoutType)
-					rcInLayoutCount++;
-
-				wrappedRenderFragment = _layouts[i].LayoutFragment(wrappedRenderFragment);
-			}
-
-			var resultBase = Renderer.RenderFragment(wrappedRenderFragment);
+			// make sure to return the rendered component, not the layout component.			
+			var resultBase = Renderer.RenderFragment(RenderTree.Wrap(renderFragment));
 
 			// This ensures that the correct component is returned, in case an added layout component
 			// is of type TComponent.
-			var result = rcInLayoutCount > 0
-				? Renderer.FindComponents<TComponent>(resultBase)[rcInLayoutCount]
+			var renderTreeTComponentCount = RenderTree.GetCountOf<TComponent>();
+			var result = renderTreeTComponentCount > 0
+				? Renderer.FindComponents<TComponent>(resultBase)[renderTreeTComponentCount]
 				: Renderer.FindComponent<TComponent>(resultBase);
 
 			return (IRenderedComponent<TComponent>)result;