Removed explicit catch all logic and generalized around JSRUntimeInvocationHandler. Added ability to query BunitJSInterop for registered handler.

Author: egil

src/bunit.web/JSInterop/BunitJSInterop.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,7 +15,6 @@ public class BunitJSInterop
 	{
 		private readonly Dictionary<string, List<JSRuntimeInvocation>> _invocations = new Dictionary<string, List<JSRuntimeInvocation>>();
 		private readonly Dictionary<string, List<object>> _handlers = new Dictionary<string, List<object>>();
-		private readonly Dictionary<Type, object> _catchAllHandlers = new Dictionary<Type, object>();
 
 		/// <summary>
 		/// Gets a dictionary of all <see cref="List{JSRuntimeInvocation}"/> this mock has observed.
@@ -48,12 +48,12 @@ public BunitJSInterop()
 		/// <see cref="IJSRuntime.InvokeAsync{TValue}(string, object[])"/>.
 		/// </summary>
 		/// <typeparam name="TResult">The result type of the invocation.</typeparam>
-		/// <returns>A <see cref="JSRuntimeCatchAllInvocationHandler{TResult}"/>.</returns>
-		public JSRuntimeCatchAllInvocationHandler<TResult> Setup<TResult>()
+		/// <returns>A <see cref="JSRuntimeInvocationHandler{TResult}"/>.</returns>
+		public JSRuntimeInvocationHandler<TResult> Setup<TResult>()
 		{
-			var result = new JSRuntimeCatchAllInvocationHandler<TResult>();
+			var result = new JSRuntimeInvocationHandler<TResult>(JSRuntimeInvocationHandler<object>.CatchAllIdentifier, _ => true);
 
-			_catchAllHandlers[typeof(TResult)] = result;
+			AddHandler(result);
 
 			return result;
 		}
@@ -118,14 +118,33 @@ public JSRuntimeInvocationHandler SetupVoid(string identifier, params object[] a
 		/// <summary>
 		/// Configure a catch all JSInterop invocation handler, that should not receive any result.
 		/// </summary>
-		/// <returns>A <see cref="JSRuntimeCatchAllInvocationHandler"/>.</returns>
-		public JSRuntimeCatchAllInvocationHandler SetupVoid()
+		/// <returns>A <see cref="JSRuntimeInvocationHandler"/>.</returns>
+		public JSRuntimeInvocationHandler SetupVoid()
 		{
-			var result = new JSRuntimeCatchAllInvocationHandler();
-			_catchAllHandlers[typeof(object)] = result;
+			var result = new JSRuntimeInvocationHandler(JSRuntimeInvocationHandler<object>.CatchAllIdentifier, _ => true);
+
+			AddHandler(result);
+
 			return result;
 		}
 
+		/// <summary>
+		/// Looks through the registered handlers and returns the latest registered that can handle
+		/// the provided <paramref name="identifier"/> and <paramref name="args"/>, and that
+		/// will return <typeparamref name="TResult"/>.
+		/// </summary>
+		/// <returns>Returns the <see cref="JSRuntimeInvocationHandler{TResult}"/> or null if no one is found.</returns>
+		public JSRuntimeInvocationHandler<TResult>? TryGetInvokeHandler<TResult>(string identifier, object?[]? args = null)
+			=> TryGetHandlerFor<TResult>(new JSRuntimeInvocation(identifier, default, args));
+
+		/// <summary>
+		/// Looks through the registered handlers and returns the latest registered that can handle
+		/// the provided <paramref name="identifier"/> and <paramref name="args"/>, and that returns a "void" result.
+		/// </summary>
+		/// <returns>Returns the <see cref="JSRuntimeInvocationHandler"/> or null if no one is found.</returns>
+		public JSRuntimeInvocationHandler? TryGetInvokeVoidHandler(string identifier, object?[]? args = null)
+			=> TryGetHandlerFor<object>(new JSRuntimeInvocation(identifier, default, args), x => x.IsVoidResultHandler) as JSRuntimeInvocationHandler;
+
 		private void AddHandler<TResult>(JSRuntimeInvocationHandler<TResult> handler)
 		{
 			if (!_handlers.ContainsKey(handler.Identifier))
@@ -144,6 +163,23 @@ private void RegisterInvocation(JSRuntimeInvocation invocation)
 			_invocations[invocation.Identifier].Add(invocation);
 		}
 
+		private JSRuntimeInvocationHandler<TResult>? TryGetHandlerFor<TResult>(JSRuntimeInvocation invocation, Predicate<JSRuntimeInvocationHandler<TResult>>? handlerPredicate = null)
+		{
+			handlerPredicate ??= _ => true;
+			JSRuntimeInvocationHandler<TResult>? result = default;
+			if (_handlers.TryGetValue(invocation.Identifier, out var plannedInvocations))
+			{
+				result = plannedInvocations.OfType<JSRuntimeInvocationHandler<TResult>>()
+					.Where(x => handlerPredicate(x) && x.Matches(invocation)).LastOrDefault();
+			}
+
+			if (result is null && _handlers.TryGetValue(JSRuntimeInvocationHandler<TResult>.CatchAllIdentifier, out var catchAllHandlers))
+			{
+				result = catchAllHandlers.OfType<JSRuntimeInvocationHandler<TResult>>().Where(x => handlerPredicate(x)).LastOrDefault();
+			}
+			return result;
+		}
+
 		private class BUnitJSRuntime : IJSRuntime
 		{
 			private readonly BunitJSInterop _jsInterop;
@@ -161,37 +197,19 @@ public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToke
 				var invocation = new JSRuntimeInvocation(identifier, cancellationToken, args);
 				_jsInterop.RegisterInvocation(invocation);
 
-				return TryHandlePlannedInvocation<TValue>(identifier, invocation)
-					?? new ValueTask<TValue>(default(TValue)!);
+				return TryHandlePlannedInvocation<TValue>(invocation) ?? new ValueTask<TValue>(default(TValue)!);
 			}
 
-			private ValueTask<TValue>? TryHandlePlannedInvocation<TValue>(string identifier, JSRuntimeInvocation invocation)
+			private ValueTask<TValue>? TryHandlePlannedInvocation<TValue>(JSRuntimeInvocation invocation)
 			{
 				ValueTask<TValue>? result = default;
-				if (_jsInterop._handlers.TryGetValue(identifier, out var plannedInvocations))
-				{
-					var handler = plannedInvocations.OfType<JSRuntimeInvocationHandlerBase<TValue>>()
-						.Where(x => x.Matches(invocation)).LastOrDefault();
-
-					if (handler is not null)
-					{
-						var task = handler.RegisterInvocation(invocation);
-						return new ValueTask<TValue>(task);
-					}
-				}
 
-				if (_jsInterop._catchAllHandlers.TryGetValue(typeof(TValue), out var catchAllInvocation))
+				if (_jsInterop.TryGetHandlerFor<TValue>(invocation) is JSRuntimeInvocationHandler<TValue> handler)
 				{
-					var planned = catchAllInvocation as JSRuntimeInvocationHandlerBase<TValue>;
-
-					if (planned is not null)
-					{
-						var task = ((JSRuntimeInvocationHandlerBase<TValue>)catchAllInvocation).RegisterInvocation(invocation);
-						return new ValueTask<TValue>(task);
-					}
+					var task = handler.RegisterInvocation(invocation);
+					result = new ValueTask<TValue>(task);
 				}
-
-				if (result is null && _jsInterop.Mode == JSRuntimeMode.Strict)
+				else if (_jsInterop.Mode == JSRuntimeMode.Strict)
 				{
 					throw new JSRuntimeUnhandledInvocationException(invocation);
 				}

src/bunit.web/JSInterop/JSRuntimeCatchAllInvocationHandler.cs

@@ -8,7 +8,7 @@ namespace Bunit
 	/// <summary>
 	/// Represents an invocation of JavaScript via the JSRuntime Mock
 	/// </summary>
-	[SuppressMessage("Design", "CA1068:CancellationToken parameters must come last", Justification = "Following Blazors design")]
+	[SuppressMessage("Design", "CA1068:CancellationToken parameters must come last", Justification = "Following Blazor's API design")]
 	public readonly struct JSRuntimeInvocation : IEquatable<JSRuntimeInvocation>
 	{
 		/// <summary>

src/bunit.web/JSInterop/JSRuntimeInvocation.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace Bunit
 {
@@ -8,28 +9,90 @@ namespace Bunit
 	/// and returns <typeparamref name="TResult"/>.
 	/// </summary>
 	/// <typeparam name="TResult">The expect result type.</typeparam>
-	public class JSRuntimeInvocationHandler<TResult> : JSRuntimeInvocationHandlerBase<TResult>
+	public class JSRuntimeInvocationHandler<TResult>
 	{
 		private readonly Func<IReadOnlyList<object?>, bool> _invocationMatcher;
+		internal const string CatchAllIdentifier = "*";
+
+		private readonly List<JSRuntimeInvocation> _invocations;
+
+		private TaskCompletionSource<TResult> _completionSource;
+
+		/// <summary>
+		/// Gets whether this handler is set up to handle calls to <c>InvokeVoidAsync=(string, object[])</c>.
+		/// </summary>
+		public virtual bool IsVoidResultHandler { get; } = false;
+
+		/// <summary>
+		/// Gets whether this handler will match any invocations that expect a <typeparamref name="TResult"/> as the return type.
+		/// </summary>
+		public bool IsCatchAllHandler { get; }
 
 		/// <summary>
 		/// The expected identifier for the function to invoke.
 		/// </summary>
 		public string Identifier { get; }
 
+		/// <summary>
+		/// Gets the invocations that this <see cref="JSRuntimeInvocationHandler{TResult}"/> has matched with.
+		/// </summary>
+		public IReadOnlyList<JSRuntimeInvocation> Invocations => _invocations.AsReadOnly();
+
+		/// <summary>
+		/// Creates an instance of a <see cref="JSRuntimeInvocationHandler{TResult}"/>.
+		/// </summary>
 		internal JSRuntimeInvocationHandler(string identifier, Func<IReadOnlyList<object?>, bool> matcher)
 		{
 			Identifier = identifier;
+			IsCatchAllHandler = identifier == CatchAllIdentifier;
 			_invocationMatcher = matcher;
+			_invocations = new List<JSRuntimeInvocation>();
+			_completionSource = new TaskCompletionSource<TResult>();
 		}
 
 		/// <summary>
 		/// Sets the <typeparamref name="TResult"/> result that invocations will receive.
 		/// </summary>
 		/// <param name="result"></param>
-		public void SetResult(TResult result) => SetResultBase(result);
+		public void SetResult(TResult result)
+		{
+			if (_completionSource.Task.IsCompleted)
+				_completionSource = new TaskCompletionSource<TResult>();
+
+			_completionSource.SetResult(result);
+		}
 
-		internal override bool Matches(JSRuntimeInvocation invocation)
+		/// <summary>
+		/// Sets the <typeparamref name="TException"/> exception that invocations will receive.
+		/// </summary>
+		/// <param name="exception"></param>
+		public void SetException<TException>(TException exception)
+			where TException : Exception
+		{
+			if (_completionSource.Task.IsCompleted)
+				_completionSource = new TaskCompletionSource<TResult>();
+
+			_completionSource.SetException(exception);
+		}
+
+		/// <summary>
+		/// Marks the <see cref="Task{TResult}"/> that invocations will receive as canceled.
+		/// </summary>
+		public void SetCanceled()
+		{
+			if (_completionSource.Task.IsCompleted)
+				_completionSource = new TaskCompletionSource<TResult>();
+
+			_completionSource.SetCanceled();
+		}
+
+		internal Task<TResult> RegisterInvocation(JSRuntimeInvocation invocation)
+		{
+			_invocations.Add(invocation);
+			return _completionSource.Task;
+		}
+
+		internal bool Matches(JSRuntimeInvocation invocation)
 		{
 			return Identifier.Equals(invocation.Identifier, StringComparison.Ordinal)
 				&& _invocationMatcher(invocation.Arguments);
@@ -41,12 +104,15 @@ internal override bool Matches(JSRuntimeInvocation invocation)
 	/// </summary>
 	public class JSRuntimeInvocationHandler : JSRuntimeInvocationHandler<object>
 	{
+		/// <inheritdoc/>
+		public override bool IsVoidResultHandler { get; } = true;
+
 		internal JSRuntimeInvocationHandler(string identifier, Func<IReadOnlyList<object?>, bool> matcher) : base(identifier, matcher)
 		{ }
 
 		/// <summary>
 		/// Completes the current awaiting void invocation requests.
 		/// </summary>
-		public void SetVoidResult() => SetResultBase(default!);
+		public void SetVoidResult() => SetResult(default!);
 	}
 }