Add SetupVoid and SetVoidResult capabilities to JsRuntime mock (#35)

* Moved MockJsRuntime to its own namespace

* Add SetupVoid() and SetVoidResult() to PlannedInvocation and Mock

* Updates to template and sample

Author: egil

sample/tests/Tests/Components/FocussingInputTest.cs

@@ -4,6 +4,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Egil.RazorComponents.Testing.Asserting;
+using Egil.RazorComponents.Testing.Mocking.JSInterop;
 using Egil.RazorComponents.Testing.SampleApp.Components;
 using Egil.RazorComponents.Testing.Mocking.JSInterop;
 using Xunit;
@@ -25,6 +26,7 @@ public void Test001()
             // Assert
             // that there is a single call to document.body.focus.call
             var invocation = jsRtMock.VerifyInvoke("document.body.focus.call");
+
             // Assert that the invocation received a single argument
             // and that it was a reference to the input element.
             var expectedReferencedElement = cut.Find("input");

sample/tests/Tests/Components/TodoListTest.cs

@@ -1,6 +1,7 @@
 using Shouldly;
 using AngleSharp.Dom;
 using Egil.RazorComponents.Testing.Asserting;
+using Egil.RazorComponents.Testing.Mocking.JSInterop;
 using Egil.RazorComponents.Testing.EventDispatchExtensions;
 using Egil.RazorComponents.Testing.Mocking.JSInterop;
 using Egil.RazorComponents.Testing.SampleApp.Components;

sample/tests/_Imports.razor

@@ -4,6 +4,7 @@
 @using Egil.RazorComponents.Testing.EventDispatchExtensions
 @using Egil.RazorComponents.Testing.Mocking.JSInterop
 @using Egil.RazorComponents.Testing.Asserting
+@using Egil.RazorComponents.Testing.Mocking.JSInterop
 
 @using Egil.RazorComponents.Testing.SampleApp
 @using Egil.RazorComponents.Testing.SampleApp.Data

src/Mocking/JSInterop/JsRuntimePlannedInvocation.cs

@@ -5,16 +5,55 @@
 
 namespace Egil.RazorComponents.Testing.Mocking.JSInterop
 {
+    /// <summary>
+    /// Represents a planned invocation of a JavaScript function which returns nothing, with specific arguments.
+    /// </summary>
+    public class JsRuntimePlannedInvocation : JsRuntimePlannedInvocationBase<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()
+        {
+            base.SetResultBase(default!);
+        }
+    }
+
+    /// <summary>
+    /// Represents a planned invocation of a JavaScript function with specific arguments.
+    /// </summary>
+    /// <typeparam name="TResult"></typeparam>
+    public class JsRuntimePlannedInvocation<TResult> : JsRuntimePlannedInvocationBase<TResult>
+    {
+        internal JsRuntimePlannedInvocation(string identifier, Func<IReadOnlyList<object>, bool> matcher) : base(identifier, matcher)
+        {
+        }
+
+        /// <summary>
+        /// Sets the <typeparamref name="TResult"/> result that invocations will receive.
+        /// </summary>
+        /// <param name="result"></param>
+        public void SetResult(TResult result)
+        {
+            base.SetResultBase(result);
+        }
+    }
+
     /// <summary>
     /// Represents a planned invocation of a JavaScript function with specific arguments.
     /// </summary>
     /// <typeparam name="TResult"></typeparam>
-    [SuppressMessage("Performance", "CA1815:Override equals and operator equals on value types", Justification = "<Pending>")]
-    public readonly struct JsRuntimePlannedInvocation<TResult>
+    public abstract class JsRuntimePlannedInvocationBase<TResult>
     {
         private readonly List<JsRuntimeInvocation> _invocations;
+
         private Func<IReadOnlyList<object>, bool> InvocationMatcher { get; }
-        internal TaskCompletionSource<TResult> CompletionSource { get; }
+
+        private TaskCompletionSource<TResult> _completionSource;
 
         /// <summary>
         /// The expected identifier for the function to invoke.
@@ -26,36 +65,52 @@ public readonly struct JsRuntimePlannedInvocation<TResult>
         /// </summary>
         public IReadOnlyList<JsRuntimeInvocation> Invocations => _invocations.AsReadOnly();
 
-        internal JsRuntimePlannedInvocation(string identifier, Func<IReadOnlyList<object>, bool> matcher)
+        /// <summary>
+        /// Creates an instance of a <see cref="JsRuntimePlannedInvocationBase{TResult}"/>.
+        /// </summary>
+        protected JsRuntimePlannedInvocationBase(string identifier, Func<IReadOnlyList<object>, bool> matcher)
         {
             Identifier = identifier;
             _invocations = new List<JsRuntimeInvocation>();
             InvocationMatcher = matcher;
-            CompletionSource = new TaskCompletionSource<TResult>();
+            _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) => CompletionSource.SetResult(result);
+        protected void SetResultBase(TResult result)
+        {
+            _completionSource.SetResult(result);
+        }
 
         /// <summary>
         /// Sets the <typeparamref name="TException"/> exception that invocations will receive.
         /// </summary>
         /// <param name="exception"></param>
-        public void SetException<TException>(TException exception) 
+        public void SetException<TException>(TException exception)
             where TException : Exception
-            => CompletionSource.SetException(exception);
+        {
+            _completionSource.SetException(exception);
+        }
 
         /// <summary>
         /// Marks the <see cref="Task{TResult}"/> that invocations will receive as canceled.
         /// </summary>
-        public void SetCanceled() => CompletionSource.SetCanceled();
+        public void SetCanceled()
+        {
+            _completionSource.SetCanceled();
+        }
 
-        internal void AddInvocation(JsRuntimeInvocation invocation)
+        internal Task<TResult> RegisterInvocation(JsRuntimeInvocation invocation)
         {
+            if (_completionSource.Task.IsCompleted)
+                _completionSource = new TaskCompletionSource<TResult>();
+
             _invocations.Add(invocation);
+
+            return _completionSource.Task;
         }
 
         internal bool Matches(JsRuntimeInvocation invocation)

src/Mocking/JSInterop/MockJsRuntimeInvokeHandler.cs

@@ -52,7 +52,7 @@ public IJSRuntime ToJsRuntime()
         /// <typeparam name="TResult">The result type of the invocation</typeparam>
         /// <param name="identifier">The identifier to setup a response for</param>
         /// <param name="argumentsMatcher">A matcher that is passed arguments received in invocations to <paramref name="identifier"/>. If it returns true the invocation is matched.</param>
-        /// <returns>A <see cref="TaskCompletionSource{TResult}"/> whose <see cref="Task"/> is returned when the <paramref name="identifier"/> is invoked.</returns>
+        /// <returns>A <see cref="JsRuntimePlannedInvocation{TResult}"/>.</returns>
         public JsRuntimePlannedInvocation<TResult> Setup<TResult>(string identifier, Func<IReadOnlyList<object>, bool> argumentsMatcher)
         {
             var result = new JsRuntimePlannedInvocation<TResult>(identifier, argumentsMatcher);
@@ -68,13 +68,41 @@ public JsRuntimePlannedInvocation<TResult> Setup<TResult>(string identifier, Fun
         /// <typeparam name="TResult"></typeparam>
         /// <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="TaskCompletionSource{TResult}"/> whose <see cref="Task"/> is returned when the <paramref name="identifier"/> is invoked.</returns>
+        /// <returns>A <see cref="JsRuntimePlannedInvocation{TResult}"/>.</returns>
         public JsRuntimePlannedInvocation<TResult> Setup<TResult>(string identifier, params object[] arguments)
         {
             return Setup<TResult>(identifier, args => Enumerable.SequenceEqual(args, arguments));
         }
 
-        private void AddPlannedInvocation<TResult>(JsRuntimePlannedInvocation<TResult> planned)
+        /// <summary>
+        /// Configure a planned JSInterop invocation with the <paramref name="identifier"/> and arguments
+        /// passing the <paramref name="argumentsMatcher"/> test, that should not receive any result.
+        /// </summary>
+        /// <param name="identifier">The identifier to setup a response for</param>
+        /// <param name="argumentsMatcher">A matcher that is passed arguments received in invocations to <paramref name="identifier"/>. If it returns true the invocation is matched.</param>
+        /// <returns>A <see cref="JsRuntimePlannedInvocation"/>.</returns>
+        public JsRuntimePlannedInvocation SetupVoid(string identifier, Func<IReadOnlyList<object>, bool> argumentsMatcher)
+        {
+            var result = new JsRuntimePlannedInvocation(identifier, argumentsMatcher);
+
+            AddPlannedInvocation(result);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Configure a planned JSInterop invocation with the <paramref name="identifier"/> 
+        /// and <paramref name="arguments"/>, that should not receive any result.
+        /// </summary>
+        /// <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="JsRuntimePlannedInvocation"/>.</returns>
+        public JsRuntimePlannedInvocation SetupVoid(string identifier, params object[] arguments)
+        {
+            return SetupVoid(identifier, args => Enumerable.SequenceEqual(args, arguments));
+        }
+
+        private void AddPlannedInvocation<TResult>(JsRuntimePlannedInvocationBase<TResult> planned)
         {
             if (!_plannedInvocations.ContainsKey(planned.Identifier))
             {
@@ -119,15 +147,13 @@ public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToke
 
                 if (_handlers._plannedInvocations.TryGetValue(identifier, out var plannedInvocations))
                 {
-                    var planned = plannedInvocations.OfType<JsRuntimePlannedInvocation<TValue>>()
+                    var planned = plannedInvocations.OfType<JsRuntimePlannedInvocationBase<TValue>>()
                         .SingleOrDefault(x => x.Matches(invocation));
 
-                    // TODO: Should we check the CancellationToken at this point and automatically call
-                    // TrySetCanceled(CancellationToken) on the TaskCompletionSource? (https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.taskcompletionsource-1.trysetcanceled?view=netcore-3.0#System_Threading_Tasks_TaskCompletionSource_1_TrySetCanceled_System_Threading_CancellationToken_)
                     if (planned is { })
                     {
-                        planned.AddInvocation(invocation);
-                        result = new ValueTask<TValue>(planned.CompletionSource.Task);
+                        var task = planned.RegisterInvocation(invocation);
+                        result = new ValueTask<TValue>(task);
                     }
                 }
 

src/Mocking/JSInterop/UnplannedJsInvocationException.cs

@@ -25,14 +25,25 @@ public class UnplannedJsInvocationException : Exception
         /// </summary>
         /// <param name="invocation">The unplanned invocation.</param>
         public UnplannedJsInvocationException(JsRuntimeInvocation invocation)
-            : base($"The invocation of '{invocation.Identifier} with arguments '[{PrintArguments(invocation.Arguments)}]")
+            : base($"The invocation of '{invocation.Identifier}' {PrintArguments(invocation.Arguments)} was not expected.")
         {
             Invocation = invocation;
         }
 
         private static string PrintArguments(IReadOnlyList<object> arguments)
         {
-            return string.Join(", ", arguments.Select(x => x.ToString()));
+            if (arguments.Count == 0)
+            {
+                return "without arguments";
+            }
+            else if (arguments.Count == 1)
+            { 
+                return $"with the argument [{arguments[0].ToString()}]";
+            }
+            else
+            {
+                return $"with arguments [{string.Join(", ", arguments.Select(x => x.ToString()))}]";
+            }                
         }
     }
 }

template/template/Component1Test.cs

@@ -3,6 +3,7 @@
 using Egil.RazorComponents.Testing;
 using Egil.RazorComponents.Testing.Diffing;
 using Egil.RazorComponents.Testing.Asserting;
+using Egil.RazorComponents.Testing.Mocking.JSInterop;
 using Egil.RazorComponents.Testing.EventDispatchExtensions;
 
 namespace Company.RazorTests1

template/template/_Imports.razor

@@ -3,4 +3,5 @@
 @using Egil.RazorComponents.Testing.Diffing
 @using Egil.RazorComponents.Testing.Asserting
 @using Egil.RazorComponents.Testing.EventDispatchExtensions
+@using Egil.RazorComponents.Testing.Mocking.JSInterop
 @using Xunit