bUnit-dev#361: Allow untyped JSInterop.Setup methods, that matches with any type

Author: jgoday

Diff for: src/bunit.web/JSInterop/BunitJSInteropSetupExtensions.cs

@@ -67,6 +67,40 @@ public static JSRuntimeInvocationHandler<TResult> Setup<TResult>(this BunitJSInt
 		public static JSRuntimeInvocationHandler<TResult> Setup<TResult>(this BunitJSInterop jsInterop)
 			=> Setup<TResult>(jsInterop, _ => true, isCatchAllHandler: true);
 
+		/// <summary>
+		/// Configure an untyped JSInterop invocation handler passing the <paramref name="invocationMatcher"/> test.
+		/// </summary>
+		/// <param name="jsInterop">The bUnit JSInterop to setup the invocation handling with.</param>
+		/// <param name="invocationMatcher">A matcher that is passed an <see cref="JSRuntimeInvocation"/>. If it returns true the invocation is matched.</param>
+		/// <returns>A <see cref="UntypedJSRuntimeInvocationHandler"/>.</returns>
+		public static UntypedJSRuntimeInvocationHandler Setup(this BunitJSInterop jsInterop, InvocationMatcher invocationMatcher)
+		{
+			if (jsInterop is null)
+				throw new ArgumentNullException(nameof(jsInterop));
+			return new UntypedJSRuntimeInvocationHandler(jsInterop, invocationMatcher);
+		}
+
+		/// <summary>
+		/// Configure an untyped JSInterop invocation handler with the <paramref name="identifier"/> and arguments
+		/// passing the <paramref name="invocationMatcher"/> test.
+		/// </summary>
+		/// <param name="jsInterop">The bUnit JSInterop to setup the invocation handling with.</param>
+		/// <param name="identifier">The identifier to setup a response for.</param>
+		/// <param name="invocationMatcher">A matcher that is passed an <see cref="JSRuntimeInvocation"/> associated with  the<paramref name="identifier"/>. If it returns true the invocation is matched.</param>
+		/// <returns>A <see cref="UntypedJSRuntimeInvocationHandler"/>.</returns>
+		public static UntypedJSRuntimeInvocationHandler Setup(this BunitJSInterop jsInterop, string identifier, InvocationMatcher invocationMatcher)
+			=> Setup(jsInterop, inv => identifier.Equals(inv.Identifier, StringComparison.Ordinal) && invocationMatcher(inv));
+
+		/// <summary>
+		/// Configure an untyped JSInterop invocation handler with the <paramref name="identifier"/> and <paramref name="arguments"/>.
+		/// </summary>
+		/// <param name="jsInterop">The bUnit JSInterop to setup the invocation handling with.</param>
+		/// <param name="identifier">The identifier to setup a response for.</param>
+		/// <param name="arguments">The arguments that an invocation to <paramref name="identifier"/> should match.</param>
+		/// <returns>A <see cref="UntypedJSRuntimeInvocationHandler"/>.</returns>
+		public static UntypedJSRuntimeInvocationHandler Setup(this BunitJSInterop jsInterop, string identifier, params object?[]? arguments)
+			=> Setup(jsInterop, identifier, invocation => invocation.Arguments.SequenceEqual(arguments ?? Array.Empty<object?>()));
+
 		/// <summary>
 		/// Configure a JSInterop invocation handler for an <c>InvokeVoidAsync</c> call with arguments
 		/// passing the <paramref name="invocationMatcher"/> test, that should not receive any result.

Diff for: src/bunit.web/JSInterop/InvocationHandlers/JSRuntimeInvocationHandlerFactory.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Bunit.JSInterop.InvocationHandlers
+{
+    internal class JSRuntimeInvocationHandlerFactory<TResult, TException> : JSRuntimeInvocationHandler<TResult>
+        where TException : Exception
+    {
+        private readonly Func<JSRuntimeInvocation, TResult>? resultFactory;
+        private readonly Func<JSRuntimeInvocation, TException>? exceptionFactory;
+
+        public JSRuntimeInvocationHandlerFactory(Func<JSRuntimeInvocation, TResult>? rFactory, Func<JSRuntimeInvocation, TException>? eFactory, InvocationMatcher matcher, bool isCatchAllHandler) : base(matcher, isCatchAllHandler)
+        {
+            resultFactory = rFactory;
+            exceptionFactory = eFactory;
+        }
+
+        protected override internal Task<TResult> HandleAsync(JSRuntimeInvocation invocation)
+		{
+            if (exceptionFactory != null && exceptionFactory.Invoke(invocation) is TException t)
+            {
+                base.SetException<TException>(t);
+            }
+            else if (resultFactory != null && resultFactory.Invoke(invocation) is TResult res)
+            {
+                base.SetResult(res);
+            }
+            return base.HandleAsync(invocation);
+		}
+    }
+}

Diff for: src/bunit.web/JSInterop/InvocationHandlers/UntypedJSRuntimeInvocationHandler.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Bunit.JSInterop.InvocationHandlers
+{
+    /// <summary>
+	/// Represents a handler for an invocation of a JavaScript function with specific arguments
+	/// that can return any type, depending on the SetResult/SetCancelled/SetException invocations.
+	/// </summary>
+    public class UntypedJSRuntimeInvocationHandler : JSRuntimeInvocationHandler
+    {
+        private readonly InvocationMatcher invocationMatcher;
+
+        private readonly BunitJSInterop jsInterop;
+
+        /// <summary>
+		/// Initializes a new instance of the <see cref="UntypedJSRuntimeInvocationHandler"/> class.
+		/// </summary>
+        /// <param name="interop">The bUnit JSInterop to setup the invocation handling with.</param>
+		/// <param name="matcher">An invocation matcher used to determine if the handler should handle an invocation.</param>
+		/// <param name="isCatchAllHandler">Set to true if this handler is a catch all handler, that should only be used if there are no other non-catch all handlers available.</param>
+        public UntypedJSRuntimeInvocationHandler(BunitJSInterop interop, InvocationMatcher matcher, bool isCatchAllHandler = true)
+            : base(matcher, isCatchAllHandler)
+        {
+            jsInterop = interop;
+            invocationMatcher = matcher ?? throw new ArgumentNullException(nameof(matcher));
+        }
+
+		/// <summary>
+		/// Sets the result factory function, that when invoked sets the <typeparamref name="TReturnType"/> result that invocations will receive.
+		/// </summary>
+		/// <param name="resultFactory">The result factory function that creates the handler result.</param>
+		/// <returns>This handler to allow calls to be chained.</returns>
+        public JSRuntimeInvocationHandler<TReturnType> SetResult<TReturnType>(Func<JSRuntimeInvocation, TReturnType> resultFactory)
+        {
+            var handler = new JSRuntimeInvocationHandlerFactory<TReturnType, Exception>(resultFactory, null, invocationMatcher, IsCatchAllHandler);
+
+            jsInterop.AddInvocationHandler<TReturnType>(handler);
+
+            return handler;
+        }
+
+		/// <summary>
+		/// Marks the <see cref="Task"/> that invocations will receive as canceled.
+		/// </summary>
+		/// <returns>This handler to allow calls to be chained.</returns>
+        public JSRuntimeInvocationHandler<TReturnType> SetCanceled<TReturnType>()
+        {
+            var handler = new JSRuntimeInvocationHandler<TReturnType>(invocationMatcher, IsCatchAllHandler);
+            handler.SetCanceled();
+
+            jsInterop.AddInvocationHandler<TReturnType>(handler);
+
+            return handler;
+        }
+
+		/// <summary>
+		/// Sets the exception factory, that when invoked determines the <typeparamref name="TException"/> exception that invocations will receive.
+		/// </summary>
+		/// <param name="exceptionFactory">The exception function factory to set.</param>
+		/// <returns>This handler to allow calls to be chained.</returns>
+        public JSRuntimeInvocationHandler<TReturnType> SetException<TReturnType, TException>(Func<JSRuntimeInvocation, TException> exceptionFactory) where TException : Exception
+        {
+            var handler = new JSRuntimeInvocationHandlerFactory<TReturnType, TException>(null, exceptionFactory, invocationMatcher, IsCatchAllHandler);
+
+            jsInterop.AddInvocationHandler<TReturnType>(handler);
+
+            return handler;
+        }
+    }
+}

Diff for: tests/bunit.web.tests/JSInterop/BunitJSInteropTest.cs

@@ -511,5 +511,49 @@ public void Test046()
 			exception.Invocation.Identifier.ShouldBe(identifier);
 			exception.Invocation.Arguments.ShouldBe(args);
 		}
+
+		[Fact(DisplayName = "Untyped setup can return a typed result from a factory function")]
+		public async Task Test059()
+		{
+			var sut = CreateSut(JSRuntimeMode.Strict);
+			var identifier = "func";
+
+			var jsRuntime = sut.JSRuntime;
+
+			var handler = sut.Setup(i => i.Identifier == identifier);
+			handler.SetResult(_ => false);
+
+			var i1 = await jsRuntime.InvokeAsync<bool>(identifier);
+			i1.ShouldBe(false);
+		}
+
+		[Fact(DisplayName = "Untyped setup can throw an exception from a factory function")]
+		public void Test060()
+		{
+			var sut = CreateSut(JSRuntimeMode.Strict);
+			var identifier = "func";
+
+			var jsRuntime = sut.JSRuntime;
+
+			var handler = sut.Setup(i => i.Identifier == identifier);
+			handler.SetException<bool, NotImplementedException>(_ => throw new NotImplementedException());
+
+			Should.Throw<NotImplementedException>(async () => await jsRuntime.InvokeAsync<bool>(identifier));
+		}
+
+		[Fact(DisplayName = "An untyped invocation handler can be canceled")]
+		public void Test061()
+		{
+			var sut = CreateSut(JSRuntimeMode.Strict);
+			var identifier = "func";
+
+			var jsRuntime = sut.JSRuntime;
+
+			var handler = sut.Setup(i => i.Identifier == identifier);
+			handler.SetCanceled<bool>();
+
+			var res = jsRuntime.InvokeAsync<bool>(identifier);
+			res.IsCanceled.ShouldBeTrue();
+		}
 	}
 }