Add unit tests for throwing async commands

Author: Sergio0694

tests/CommunityToolkit.Mvvm.UnitTests/CommunityToolkit.Mvvm.UnitTests.csproj

@@ -5,6 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Dbs.Signed3.Nito.AsyncEx.Context" Version="5.0.0" />
     <PackageReference Include="MSTest.TestAdapter" Version="2.2.8" />
     <PackageReference Include="MSTest.TestFramework" Version="2.2.8" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />

tests/CommunityToolkit.Mvvm.UnitTests/Test_AsyncRelayCommand.cs

@@ -10,6 +10,7 @@
 using CommunityToolkit.Mvvm.Input;
 using CommunityToolkit.Mvvm.UnitTests.Helpers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Nito.AsyncEx;
 
 namespace CommunityToolkit.Mvvm.UnitTests;
 
@@ -320,6 +321,43 @@ private static async Task Test_AsyncRelayCommand_AllowConcurrentExecutions_TestL
         Assert.AreSame(args.Item2, EventArgs.Empty);
     }
 
+    // See https://github.com/CommunityToolkit/dotnet/pull/251
+    [TestMethod]
+    public async Task Test_AsyncRelayCommand_EnsureExceptionThrown()
+    {
+        const int delay = 500;
+
+        Exception? executeException = null;
+        Exception? executeAsyncException = null;
+
+        AsyncRelayCommand command = new(async () =>
+        {
+            await Task.Delay(delay);
+
+            throw new Exception(nameof(Test_AsyncRelayCommand_EnsureExceptionThrown));
+        });
+
+        try
+        {
+            // Use AsyncContext to test async void methods https://stackoverflow.com/a/14207615/5953643
+            AsyncContext.Run(async () =>
+            {
+                command.Execute(null);
+
+                await Task.Delay(delay * 2); // Ensure we don't escape `AsyncContext` before command throws Exception
+            });
+        }
+        catch (Exception e)
+        {
+            executeException = e;
+        }
+
+        executeAsyncException = await Assert.ThrowsExceptionAsync<Exception>(() => command.ExecuteAsync(null));
+
+        Assert.AreEqual(nameof(Test_AsyncRelayCommand_EnsureExceptionThrown), executeException?.Message);
+        Assert.AreEqual(nameof(Test_AsyncRelayCommand_EnsureExceptionThrown), executeAsyncException?.Message);
+    }
+
     [TestMethod]
     public async Task Test_AsyncRelayCommand_ThrowingTaskBubblesToUnobservedTaskException()
     {
@@ -332,7 +370,7 @@ static async Task TestMethodAsync(Action action)
 
         async void TestCallback(Action throwAction, Action completeAction)
         {
-            AsyncRelayCommand command = new(() => TestMethodAsync(throwAction));
+            AsyncRelayCommand command = new(() => TestMethodAsync(throwAction), AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler);
 
             command.Execute(null);
 

tests/CommunityToolkit.Mvvm.UnitTests/Test_AsyncRelayCommand{T}.cs

@@ -10,6 +10,7 @@
 using CommunityToolkit.Mvvm.Input;
 using CommunityToolkit.Mvvm.UnitTests.Helpers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Nito.AsyncEx;
 
 namespace CommunityToolkit.Mvvm.UnitTests;
 
@@ -241,6 +242,58 @@ private static async Task Test_AsyncRelayCommandOfT_AllowConcurrentExecutions_Te
         _ = Assert.ThrowsException<InvalidCastException>(() => command.Execute(new object()));
     }
 
+    // See https://github.com/CommunityToolkit/dotnet/pull/251
+    [TestMethod]
+    public async Task Test_AsyncRelayCommandOfT_EnsureExceptionThrown()
+    {
+        const int delay = 500;
+
+        Exception? executeException = null;
+        Exception? executeTException = null;
+        Exception? executeAsyncException = null;
+
+        AsyncRelayCommand<int> command = new(async delay =>
+        {
+            await Task.Delay(delay);
+
+            throw new Exception(nameof(Test_AsyncRelayCommandOfT_EnsureExceptionThrown));
+        });
+
+        try
+        {
+            AsyncContext.Run(async () =>
+            {
+                command.Execute((object)delay);
+
+                await Task.Delay(delay * 2);
+            });
+        }
+        catch (Exception e)
+        {
+            executeException = e;
+        }
+
+        try
+        {
+            AsyncContext.Run(async () =>
+            {
+                command.Execute(delay);
+
+                await Task.Delay(delay * 2);
+            });
+        }
+        catch (Exception e)
+        {
+            executeTException = e;
+        }
+
+        executeAsyncException = await Assert.ThrowsExceptionAsync<Exception>(() => command.ExecuteAsync(delay));
+
+        Assert.AreEqual(nameof(Test_AsyncRelayCommandOfT_EnsureExceptionThrown), executeException?.Message);
+        Assert.AreEqual(nameof(Test_AsyncRelayCommandOfT_EnsureExceptionThrown), executeTException?.Message);
+        Assert.AreEqual(nameof(Test_AsyncRelayCommandOfT_EnsureExceptionThrown), executeAsyncException?.Message);
+    }
+
     [TestMethod]
     public async Task Test_AsyncRelayCommandOfT_ThrowingTaskBubblesToUnobservedTaskException()
     {
@@ -253,7 +306,7 @@ static async Task TestMethodAsync(Action action)
 
         async void TestCallback(Action throwAction, Action completeAction)
         {
-            AsyncRelayCommand<string> command = new(s => TestMethodAsync(throwAction));
+            AsyncRelayCommand<string> command = new(s => TestMethodAsync(throwAction), AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler);
 
             command.Execute(null);