Add a Setup<X>() method to MockJSRuntime (#234)

* Add a Setup<X>() method without parameters and identifier to match all invocations with type X

* Introduce a new abstraction for planned invocations with identifier

* Add a SetupVoid() method without parameters and identifier to match all void invocations

* Removed unneeded type in planned invocation class hierarchy, updated changelog

* Add documentation of the Setup and SetupVoid methods

Co-authored-by: Egil Hansen <[email protected]>

Author: nemesv

CHANGELOG.md

@@ -33,16 +33,18 @@ List of new features.
 
   By [@duracellko](https://github.com/duracellko) in [#101](https://github.com/egil/bUnit/issues/101).
 
-- Added support for registering/adding "layout" components to a test context, which components should be rendered inside. This allows you to simplify the "arrange" step of a test when a component under test requires a certain render tree as its parent, e.g. a cascading value.
+- Added support for registering/adding components to a test context root render tree, which components under test is rendered inside. This allows you to simplify the "arrange" step of a test when a component under test requires a certain render tree as its parent, e.g. a cascading value.
 
   For example, to pass a cascading string value `foo` to all components rendered with the test context, do the following:
 
   ```csharp
-  ctx.AddLayoutComponent<CascadingValue<string>>(parameters => parameters.Add(p => p.Value, "foo"));
+  ctx.RenderTree<CascadingValue<string>>(parameters => parameters.Add(p => p.Value, "foo"));
   var cut = ctx.RenderComponent<ComponentReceivingFoo>();
   ```
 
-  By [@duracellko](https://github.com/duracellko) in [#101](https://github.com/egil/bUnit/issues/101).
+  By [@egil](https://github.com/egil) in [#236](https://github.com/egil/bUnit/pull/236).
+
+- Added "catch-all" `Setup` method to bUnit's mock JS runtime, that allows you to specify only the type when setting up a planned invocation. By [@nemesv](https://github.com/nemesv) in [#234](https://github.com/egil/bUnit/issues/234).
 
 ### Changed
 List of changes in existing functionality.

docs/site/docs/test-doubles/mocking-ijsruntime.md

@@ -40,9 +40,13 @@ var mockJS = ctx.Services.AddMockJSRuntime(JSRuntimeMockMode.Strict);
 
 ## Setting up invocations
 
-Use the `Setup<TResult>(...)` and `SetupVoid(...)` methods to configure the mock to handle calls from the matching `InvokeAsync<TResult>(...)` and `InvokeVoidAsync(...)` methods on `IJSRuntime`.
+Use the `Setup<TResult>(...)` and `SetupVoid(...)` methods to configure the mock to handle calls from the **matching** `InvokeAsync<TResult>(...)` and `InvokeVoidAsync(...)` methods on `IJSRuntime`.
 
-When an invocation is set up through the `Setup<TResult>(...)` and `SetupVoid(...)` methods, a `JSRuntimePlannedInvocation<TResult>` object is returned. This can be used to set a result or an exception, to emulate what can happen during a JavaScript interop call in Blazor.
+Use the parameterless `Setup<TResult>()` method to mock any call to `InvokeAsync<TResult>(...)` with a given return type `TResult` and use the parameterless `SetupVoid()` to mock any call to `InvokeVoidAsync(...)`.
+
+When an invocation is set up through of the `Setup<TResult>(...)` and `SetupVoid(...)` methods, a `JSRuntimePlannedInvocation<TResult>` object is returned. This can be used to set a result or an exception, to emulate what can happen during a JavaScript interop call in Blazor.
+
+Similarly when the parameterless `Setup<TResult>()` and `SetupVoid()` methods are used a `JSRuntimeCatchAllPlannedInvocation<TResult>` object is returned which can be used to set the result of invocation.
 
 Here are two examples:
 

src/bunit.web/TestDoubles/JSInterop/JSRuntimePlannedInvocation.cs

@@ -4,37 +4,84 @@
 namespace Bunit.TestDoubles
 {
 	/// <summary>
-	/// Represents a planned invocation of a JavaScript function which returns nothing, with specific arguments.
+	/// Represents a planned invocation of a JavaScript function with specific arguments.
 	/// </summary>
-	public class JSRuntimePlannedInvocation : JSRuntimePlannedInvocationBase<object>
+	/// <typeparam name="TResult">The expect result type.</typeparam>
+	public class JSRuntimePlannedInvocation<TResult> : JSRuntimePlannedInvocationBase<TResult>
 	{
-		internal JSRuntimePlannedInvocation(string identifier, Func<IReadOnlyList<object?>, bool> matcher) : base(identifier, matcher)
+		private readonly Func<IReadOnlyList<object?>, bool> _invocationMatcher;
+
+		/// <summary>
+		/// The expected identifier for the function to invoke.
+		/// </summary>
+		public string Identifier { get; }
+
+		internal JSRuntimePlannedInvocation(string identifier, Func<IReadOnlyList<object?>, bool> matcher)
 		{
+			Identifier = identifier;
+			_invocationMatcher = matcher;
 		}
 
 		/// <summary>
-		/// Completes the current awaiting void invocation requests.
+		/// Sets the <typeparamref name="TResult"/> result that invocations will receive.
 		/// </summary>
-		public void SetVoidResult()
+		/// <param name="result"></param>
+		public void SetResult(TResult result) => SetResultBase(result);
+
+		internal override bool Matches(JSRuntimeInvocation invocation)
 		{
-			SetResultBase(default!);
+			return Identifier.Equals(invocation.Identifier, StringComparison.Ordinal)
+				&& _invocationMatcher(invocation.Arguments);
 		}
 	}
 
 	/// <summary>
-	/// Represents a planned invocation of a JavaScript function with specific arguments.
+	/// Represents a planned invocation of a JavaScript function which returns nothing, with specific arguments.
 	/// </summary>
-	/// <typeparam name="TResult"></typeparam>
-	public class JSRuntimePlannedInvocation<TResult> : JSRuntimePlannedInvocationBase<TResult>
+	public class JSRuntimePlannedInvocation : JSRuntimePlannedInvocation<object>
 	{
 		internal JSRuntimePlannedInvocation(string identifier, Func<IReadOnlyList<object?>, bool> matcher) : base(identifier, matcher)
-		{
-		}
+		{ }
+
+		/// <summary>
+		/// Completes the current awaiting void invocation requests.
+		/// </summary>
+		public void SetVoidResult() => SetResultBase(default!);
+	}
+
+	/// <summary>
+	/// Represents any planned invocation of a JavaScript function with a specific return type.
+	/// </summary>
+	/// <typeparam name="TResult"></typeparam>
+	public class JSRuntimeCatchAllPlannedInvocation<TResult> : JSRuntimePlannedInvocationBase<TResult>
+	{
+		internal JSRuntimeCatchAllPlannedInvocation()
+		{ }
+
+		internal override bool Matches(JSRuntimeInvocation invocation) => true;
 
 		/// <summary>
 		/// Sets the <typeparamref name="TResult"/> result that invocations will receive.
 		/// </summary>
 		/// <param name="result"></param>
 		public void SetResult(TResult result) => SetResultBase(result);
 	}
+
+	/// <summary>
+	/// Represents any planned invocation of a JavaScript function which returns nothing.
+	/// </summary>
+	public class JSRuntimeCatchAllPlannedInvocation : JSRuntimePlannedInvocationBase<object>
+	{
+		internal JSRuntimeCatchAllPlannedInvocation() { }
+
+		internal override bool Matches(JSRuntimeInvocation invocation)
+		{
+			return true;
+		}
+
+		/// <summary>
+		/// Completes the current awaiting void invocation request.
+		/// </summary>
+		public void SetVoid() => SetResultBase(default!);
+	}
 }

src/bunit.web/TestDoubles/JSInterop/JSRuntimePlannedInvocationBase.cs

@@ -12,15 +12,8 @@ public abstract class JSRuntimePlannedInvocationBase<TResult>
 	{
 		private readonly List<JSRuntimeInvocation> _invocations;
 
-		private Func<IReadOnlyList<object?>, bool> InvocationMatcher { get; }
-
 		private TaskCompletionSource<TResult> _completionSource;
 
-		/// <summary>
-		/// The expected identifier for the function to invoke.
-		/// </summary>
-		public string Identifier { get; }
-
 		/// <summary>
 		/// Gets the invocations that this <see cref="JSRuntimePlannedInvocation{TResult}"/> has matched with.
 		/// </summary>
@@ -29,11 +22,9 @@ public abstract class JSRuntimePlannedInvocationBase<TResult>
 		/// <summary>
 		/// Creates an instance of a <see cref="JSRuntimePlannedInvocationBase{TResult}"/>.
 		/// </summary>
-		protected JSRuntimePlannedInvocationBase(string identifier, Func<IReadOnlyList<object?>, bool> matcher)
+		protected JSRuntimePlannedInvocationBase()
 		{
-			Identifier = identifier;
 			_invocations = new List<JSRuntimeInvocation>();
-			InvocationMatcher = matcher;
 			_completionSource = new TaskCompletionSource<TResult>();
 		}
 
@@ -79,10 +70,6 @@ internal Task<TResult> RegisterInvocation(JSRuntimeInvocation invocation)
 			return _completionSource.Task;
 		}
 
-		internal bool Matches(JSRuntimeInvocation invocation)
-		{
-			return Identifier.Equals(invocation.Identifier, StringComparison.Ordinal)
-				&& InvocationMatcher(invocation.Arguments);
-		}
+		internal abstract bool Matches(JSRuntimeInvocation invocation);
 	}
 }

src/bunit.web/TestDoubles/JSInterop/MockJSRuntimeInvokeHandler.cs

@@ -14,6 +14,7 @@ public class MockJSRuntimeInvokeHandler
 	{
 		private readonly Dictionary<string, List<JSRuntimeInvocation>> _invocations = new Dictionary<string, List<JSRuntimeInvocation>>();
 		private readonly Dictionary<string, List<object>> _plannedInvocations = new Dictionary<string, List<object>>();
+		private readonly Dictionary<Type, object> _catchAllInvocations = new Dictionary<Type, object>();
 
 		/// <summary>
 		/// Gets a dictionary of all <see cref="List{JSRuntimeInvocation}"/> this mock has observed.
@@ -44,6 +45,20 @@ public IJSRuntime ToJSRuntime()
 			return new MockJSRuntime(this);
 		}
 
+		/// <summary>
+		/// Configure a catch all JSInterop invocation for a specific return type.
+		/// </summary>
+		/// <typeparam name="TResult">The result type of the invocation</typeparam>
+		/// <returns>A <see cref="JSRuntimeCatchAllPlannedInvocation{TResult}"/>.</returns>
+		public JSRuntimeCatchAllPlannedInvocation<TResult> Setup<TResult>()
+		{
+			var result = new JSRuntimeCatchAllPlannedInvocation<TResult>();
+
+			_catchAllInvocations[typeof(TResult)] = result;
+
+			return result;
+		}
+
 		/// <summary>
 		/// Configure a planned JSInterop invocation with the <paramref name="identifier"/> and arguments
 		/// passing the <paramref name="argumentsMatcher"/> test.
@@ -101,7 +116,20 @@ public JSRuntimePlannedInvocation SetupVoid(string identifier, params object[] a
 			return SetupVoid(identifier, args => args.SequenceEqual(arguments));
 		}
 
-		private void AddPlannedInvocation<TResult>(JSRuntimePlannedInvocationBase<TResult> planned)
+		/// <summary>
+		/// Configure a catch all JSInterop invocation, that should not receive any result.
+		/// </summary>
+		/// <returns>A <see cref="JSRuntimeCatchAllPlannedInvocation"/>.</returns>
+		public JSRuntimeCatchAllPlannedInvocation SetupVoid()
+		{
+			var result = new JSRuntimeCatchAllPlannedInvocation();
+
+			_catchAllInvocations[typeof(object)] = result;
+
+			return result;
+		}
+
+		private void AddPlannedInvocation<TResult>(JSRuntimePlannedInvocation<TResult> planned)
 		{
 			if (!_plannedInvocations.ContainsKey(planned.Identifier))
 			{
@@ -143,7 +171,6 @@ public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToke
 			private ValueTask<TValue>? TryHandlePlannedInvocation<TValue>(string identifier, JSRuntimeInvocation invocation)
 			{
 				ValueTask<TValue>? result = default;
-
 				if (_handlers._plannedInvocations.TryGetValue(identifier, out var plannedInvocations))
 				{
 					var planned = plannedInvocations.OfType<JSRuntimePlannedInvocationBase<TValue>>()
@@ -152,7 +179,18 @@ public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToke
 					if (planned is not null)
 					{
 						var task = planned.RegisterInvocation(invocation);
-						result = new ValueTask<TValue>(task);
+						return new ValueTask<TValue>(task);
+					}
+				}
+
+				if (_handlers._catchAllInvocations.TryGetValue(typeof(TValue), out var catchAllInvocation))
+				{
+					var planned = catchAllInvocation as JSRuntimePlannedInvocationBase<TValue>;
+
+					if (planned is not null)
+					{
+						var task = ((JSRuntimePlannedInvocationBase<TValue>)catchAllInvocation).RegisterInvocation(invocation);
+						return new ValueTask<TValue>(task);
 					}
 				}
 

tests/bunit.web.tests/TestDoubles/JSInterop/MockJSRuntimeInvokeHandlerTest.cs

@@ -246,5 +246,139 @@ await Should.ThrowAsync<UnplannedJSInvocationException>(
 			invocation.Arguments[0].ShouldBe("bar");
 			invocation.Arguments[1].ShouldBe(42);
 		}
+
+		[Fact(DisplayName = "Empty Setup returns the same result for all matching return type invocation")]
+		public async Task Test015()
+		{
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var plannedInvoke = sut.Setup<Guid>();
+			var jsRuntime = sut.ToJSRuntime();
+
+			var expectedResult1 = Guid.NewGuid();
+			plannedInvoke.SetResult(expectedResult1);
+			var i1 = jsRuntime.InvokeAsync<Guid>("someFunc");
+
+			var i2 = jsRuntime.InvokeAsync<Guid>("otherFunc");
+
+			(await i1).ShouldBe(expectedResult1);
+			(await i2).ShouldBe(expectedResult1);
+		}
+
+		[Fact(DisplayName = "Empty Setup only matches the configured return type")]
+		public void Test016()
+		{
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var planned = sut.Setup<Guid>();
+
+			Should.Throw<UnplannedJSInvocationException>(() => { var _ = sut.ToJSRuntime().InvokeAsync<string>("foo"); });
+
+			planned.Invocations.Count.ShouldBe(0);
+		}
+
+		[Fact(DisplayName = "Empty Setup allows to return different results by return types")]
+		public async Task Test017()
+		{
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var plannedInvoke1 = sut.Setup<Guid>();
+			var plannedInvoke2 = sut.Setup<string>();
+			var jsRuntime = sut.ToJSRuntime();
+
+			var expectedResult1 = Guid.NewGuid();
+			plannedInvoke1.SetResult(expectedResult1);
+			var i1 = jsRuntime.InvokeAsync<Guid>("someFunc");
+
+			var expectedResult2 = "somestring";
+			plannedInvoke2.SetResult(expectedResult2);
+			var i2 = jsRuntime.InvokeAsync<string>("otherFunc");
+
+			(await i1).ShouldBe(expectedResult1);
+			(await i2).ShouldBe(expectedResult2);
+		}
+
+		[Fact(DisplayName = "Empty Setup is only used when there is no handler exist for the invocation identifier")]
+		public async Task Test018()
+		{
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var catchAllplannedInvoke = sut.Setup<Guid>();
+			var jsRuntime = sut.ToJSRuntime();
+
+			var catchAllexpectedResult = Guid.NewGuid();
+			catchAllplannedInvoke.SetResult(catchAllexpectedResult);
+
+			var expectedResult = Guid.NewGuid();
+			var plannedInvoke = sut.Setup<Guid>("func");
+			plannedInvoke.SetResult(expectedResult);
+
+			var i1 = jsRuntime.InvokeAsync<Guid>("someFunc");
+
+			var i2 = jsRuntime.InvokeAsync<Guid>("func");
+
+			(await i1).ShouldBe(catchAllexpectedResult);
+			(await i2).ShouldBe(expectedResult);
+		}
+
+		[Fact(DisplayName = "Empty Setup uses the last set result")]
+		public async Task Test019()
+		{
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var plannedInvoke1 = sut.Setup<Guid>();
+			var plannedInvoke2 = sut.Setup<Guid>();
+			var jsRuntime = sut.ToJSRuntime();
+
+			var expectedResult1 = Guid.NewGuid();
+			var expectedResult2 = Guid.NewGuid();
+
+			plannedInvoke1.SetResult(expectedResult1);
+			plannedInvoke2.SetResult(expectedResult2);
+
+			var i1 = jsRuntime.InvokeAsync<Guid>("someFunc");
+
+			(await i1).ShouldBe(expectedResult2);
+		}
+
+		[Fact(DisplayName = "SetupVoid matches all void invocations")]
+		public async Task Test020()
+		{
+			var identifier = "someFunc";
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var plannedInvoke = sut.SetupVoid();
+
+			Should.Throw<UnplannedJSInvocationException>(() => { var _ = sut.ToJSRuntime().InvokeAsync<string>(identifier); });
+
+			var invocation = sut.ToJSRuntime().InvokeVoidAsync(identifier);
+			plannedInvoke.SetVoid();
+
+			await invocation;
+
+			invocation.IsCompletedSuccessfully.ShouldBeTrue();
+			plannedInvoke.Invocations.Count.ShouldBe(1);
+		}
+
+		[Fact(DisplayName = "Empty Setup is not used for invocation with void return types")]
+		public async Task Test021()
+		{
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var plannedInvoke = sut.Setup<Guid>();
+
+			await Should.ThrowAsync<UnplannedJSInvocationException>(sut.ToJSRuntime().InvokeVoidAsync("someFunc").AsTask());
+		}
+
+		[Fact(DisplayName = "SetupVoid is only used when there is no void handler")]
+		public async Task Test022()
+		{
+			var identifier = "someFunc";
+			var sut = new MockJSRuntimeInvokeHandler(JSRuntimeMockMode.Strict);
+			var plannedInvoke = sut.SetupVoid(identifier);
+			var plannedCatchall = sut.SetupVoid();
+
+			var invocation = sut.ToJSRuntime().InvokeVoidAsync(identifier);
+			plannedInvoke.SetVoidResult();
+
+			await invocation;
+
+			invocation.IsCompletedSuccessfully.ShouldBeTrue();
+			plannedInvoke.Invocations.Count.ShouldBe(1);
+			plannedCatchall.Invocations.Count.ShouldBe(0);
+		}
 	}
 }