Moved rendering events to core

Author: egil

src/bunit.core/IRenderedFragmentCore.cs

@@ -0,0 +1,27 @@
+using System;
+using Bunit.Rendering.RenderEvents;
+
+namespace Bunit
+{
+	/// <summary>
+	/// Represents a rendered fragment.
+	/// </summary>
+	public interface IRenderedFragment
+	{
+		/// <summary>
+		/// Gets the id of the rendered component or fragment.
+		/// </summary>
+		int ComponentId { get; }
+
+		/// <summary>
+		/// Gets an <see cref="IObservable{RenderEvent}"/> which will provide subscribers with <see cref="RenderEvent"/>s 
+		/// whenever the <see cref="IRenderedFragment"/> is rendered.
+		/// </summary>
+		IObservable<RenderEvent> RenderEvents { get; }
+
+		/// <summary>
+		/// Gets the <see cref="IServiceProvider"/> used when rendering the component.
+		/// </summary>
+		IServiceProvider Services { get; }
+	}
+}

…web/Components/FixtureFailedException.cs …e/RazorTesting/FixtureFailedException.cssrc/bunit.web/Components/FixtureFailedException.cs renamed to src/bunit.core/RazorTesting/FixtureFailedException.cs src/bunit.web/Components/FixtureFailedException.cs renamed to src/bunit.core/RazorTesting/FixtureFailedException.cs

@@ -39,6 +39,19 @@ public async Task<IReadOnlyList<RazorTest>> GetRazorTestsFromComponent(Type comp
 			return GetRazorTests<RazorTest>(componentId);
 		}
 
+		/// <summary>
+		/// Renders the provided <paramref name="renderFragment"/>.
+		/// </summary>
+		/// <typeparam name="TComponent">The type of components to find in the render tree after renderinger.</typeparam>
+		/// <param name="renderFragment">The <see cref="RenderFragment"/> to render.</param>
+		/// <returns>A list of <typeparamref name="TComponent"/> found in the <paramref name="renderFragment"/>'s render tree.</returns>
+		public async Task<IReadOnlyList<TComponent>> RenderAndGetTestComponents<TComponent>(RenderFragment renderFragment)
+			where TComponent : FragmentBase
+		{
+			var componentId = await RenderFragmentInsideWrapper(renderFragment);
+			return GetRazorTests<TComponent>(componentId);
+		}
+
 		private async Task<int> RenderComponent(Type componentType)
 		{
 			var component = InstantiateComponent(componentType);
@@ -47,13 +60,6 @@ private async Task<int> RenderComponent(Type componentType)
 			return componentId;
 		}
 
-		public async Task<IReadOnlyList<TComponent>> RenderAndGetTestComponents<TComponent>(RenderFragment renderFragment)
-			where TComponent : FragmentBase
-		{
-			var componentId = await RenderFragmentInsideWrapper(renderFragment);
-			return GetRazorTests<TComponent>(componentId);
-		}
-
 		private async Task<int> RenderFragmentInsideWrapper(RenderFragment renderFragment)
 		{
 			var wrapper = new WrapperComponent();

src/bunit.core/Rendering/RazorTestRenderer.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Bunit.Rendering.RenderEvents
+{
+	/// <inheritdoc/>
+	public sealed class ComponentChangeEventSubscriber : ConcurrentRenderEventSubscriber
+	{
+		private readonly int _targetComponentId;
+
+		/// <summary>
+		/// Creates an instance of the <see cref="ComponentChangeEventSubscriber"/>.
+		/// </summary>
+		public ComponentChangeEventSubscriber(IRenderedFragment testTarget, Action<RenderEvent>? onChange = null, Action? onCompleted = null)
+			: base((testTarget ?? throw new ArgumentNullException(nameof(testTarget))).RenderEvents, onChange, onCompleted)
+		{
+			_targetComponentId = testTarget.ComponentId;
+		}
+
+		/// <inheritdoc/>
+		public override void OnNext(RenderEvent value)
+		{
+			if (value.HasChangesTo(_targetComponentId))
+				base.OnNext(value);
+		}
+	}
+}

src/bunit.core/Rendering/RenderEventPublisher.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Threading;
+
+namespace Bunit.Rendering.RenderEvents
+{
+	/// <summary>
+	/// Represents a subscriber to <see cref="RenderEvent"/>s, published by
+	/// the <see cref="TestRenderer"/>.
+	/// </summary>
+	public class ConcurrentRenderEventSubscriber : IObserver<RenderEvent>
+	{
+		private readonly IDisposable _unsubscriber;
+		private readonly Action<RenderEvent>? _onRender;
+		private readonly Action? _onCompleted;
+		private int _renderCount;
+		private bool _isCompleted;
+		private RenderEvent? _latestRenderEvent;
+
+		/// <summary>
+		/// Gets the number of renders that have occurred since subscribing.
+		/// </summary>
+		public int RenderCount => Volatile.Read(ref _renderCount);
+
+		/// <summary>
+		/// Gets whether the <see cref="TestRenderer"/> is disposed an no more
+		/// renders will happen.
+		/// </summary>
+		public bool IsCompleted => Volatile.Read(ref _isCompleted);
+
+		/// <summary>
+		/// Gets the latests <see cref="RenderEvent"/> received by the <see cref="TestRenderer"/>.
+		/// </summary>
+		public RenderEvent? LatestRenderEvent => Volatile.Read(ref _latestRenderEvent);
+
+		/// <summary>
+		/// Creates an instance of the <see cref="ConcurrentRenderEventSubscriber"/>, and
+		/// subscribes to the provided <paramref name="observable"/>.
+		/// </summary>
+		/// <param name="observable">The observable to observe.</param>
+		/// <param name="onRender">A callback to invoke when a <see cref="RenderEvent"/> is received.</param>
+		/// <param name="onCompleted">A callback to invoke when no more renders will happen.</param>
+		public ConcurrentRenderEventSubscriber(IObservable<RenderEvent> observable, Action<RenderEvent>? onRender = null, Action? onCompleted = null)
+		{
+			if (observable is null)
+				throw new ArgumentNullException(nameof(observable));
+			_onRender = onRender;
+			_onCompleted = onCompleted;
+			_unsubscriber = observable.Subscribe(this);
+		}
+
+		/// <summary>
+		/// Unsubscribes from the observable.
+		/// </summary>
+		public void Unsubscribe()
+		{
+			_unsubscriber.Dispose();
+		}
+
+		/// <inheritdoc/>
+		public virtual void OnNext(RenderEvent value)
+		{
+			Interlocked.Increment(ref _renderCount);
+			Volatile.Write(ref _latestRenderEvent, value);
+			_onRender?.Invoke(value);
+		}
+
+		/// <inheritdoc/>
+		public virtual void OnCompleted()
+		{
+			Volatile.Write(ref _isCompleted, true);
+			_onCompleted?.Invoke();
+		}
+
+		/// <inheritdoc/>
+		public virtual void OnError(Exception exception)
+			=> throw new AggregateException("The renderer throw an error", exception);
+	}
+}

src/bunit.core/Rendering/RenderEvents/ComponentChangeEventSubscriber.cs

@@ -1,10 +1,10 @@
 using System;
 using Microsoft.AspNetCore.Components.RenderTree;
 
-namespace Bunit.Rendering
+namespace Bunit.Rendering.RenderEvents
 {
 	/// <summary>
-	/// Represents a render event for a <see cref="IRenderedFragmentCore"/> or generally from the <see cref="TestRendererOld"/>.
+	/// Represents a render event from a <see cref="TestRenderer"/>.
 	/// </summary>
 	public sealed class RenderEvent
 	{
@@ -26,18 +26,18 @@ public RenderEvent(in RenderBatch renderBatch, TestRenderer renderer)
 		}
 
 		/// <summary>
-		/// Checks whether the <paramref name="renderedFragment"/> or one or more of 
+		/// Checks whether the a component with <paramref name="componentId"/> or one or more of 
 		/// its sub components was changed during the <see cref="RenderEvent"/>.
 		/// </summary>
-		/// <param name="renderedFragment">Component to check for updates to.</param>
+		/// <param name="componentId">Id of component to check for updates to.</param>
 		/// <returns>True if <see cref="RenderEvent"/> contains updates to component, false otherwise.</returns>
 		public bool HasChangesTo(int componentId) => HasChangesToRoot(componentId);
 
 		/// <summary>
-		/// Checks whether the <paramref name="renderedFragment"/> or one or more of 
+		/// Checks whether the a component with <paramref name="componentId"/> or one or more of 
 		/// its sub components was rendered during the <see cref="RenderEvent"/>.
 		/// </summary>
-		/// <param name="renderedFragment">Component to check if rendered.</param>
+		/// <param name="componentId">Id of component to check if rendered.</param>
 		/// <returns>True if the component or a sub component rendered, false otherwise.</returns>
 		public bool DidComponentRender(int componentId) => DidComponentRenderRoot(componentId);
 

src/bunit.core/Rendering/RenderEvents/ConcurrentRenderEventSubscriber.cs

@@ -0,0 +1,69 @@
+using System;
+
+namespace Bunit.Rendering.RenderEvents
+{
+	/// <summary>
+	/// Represents a simple filter for <see cref="RenderEventObservable"/>.
+	/// </summary>
+	public sealed class RenderEventFilter : RenderEventObservable, IObservable<RenderEvent>, IObserver<RenderEvent>
+	{
+		private readonly IObservable<RenderEvent> _source;
+		private readonly Func<RenderEvent, bool> _forwardEvent;
+		private IDisposable? _subscription;
+
+		/// <summary>
+		/// Creates an instance of the <see cref="RenderEventFilter"/>,
+		/// that filters events from <paramref name="source"/> based on the
+		/// <paramref name="forwardEvent"/> predicate.
+		/// </summary>
+		/// <param name="source">Source to filter.</param>
+		/// <param name="forwardEvent">Filter to apply to <see cref="RenderEvent"/>.</param>
+		public RenderEventFilter(IObservable<RenderEvent> source, Func<RenderEvent, bool> forwardEvent)
+		{
+			_source = source;
+			_forwardEvent = forwardEvent;
+		}
+
+		/// <inheritdoc/>
+		public override IDisposable Subscribe(IObserver<RenderEvent> observer)
+		{
+			if (_subscription is null)
+				_subscription = _source.Subscribe(this);
+			return base.Subscribe(observer);
+		}
+
+		/// <inheritdoc/>
+		protected override void RemoveSubscription(IObserver<RenderEvent> observer)
+		{
+			base.RemoveSubscription(observer);
+			if (Observers.Count == 0 && _subscription is { })
+			{
+				_subscription.Dispose();
+				_subscription = null;
+			}
+		}
+
+		/// <inheritdoc/>
+		void IObserver<RenderEvent>.OnCompleted()
+		{
+			foreach (var observer in Observers)
+				observer.OnCompleted();
+		}
+
+		/// <inheritdoc/>
+		void IObserver<RenderEvent>.OnError(Exception error)
+		{
+			foreach (var observer in Observers)
+				observer.OnError(error);
+		}
+
+		/// <inheritdoc/>
+		void IObserver<RenderEvent>.OnNext(RenderEvent renderEvent)
+		{
+			if (!_forwardEvent(renderEvent))
+				return;
+			foreach (var observer in Observers)
+				observer.OnNext(renderEvent);
+		}
+	}
+}