Add async catch method (#430)

Author: robertcoltheart

src/Machine.Specifications.Specs/CatchSpecs.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 
 namespace Machine.Specifications.Specs
 {
@@ -130,4 +131,49 @@ public class with_a_non_throwing_Action
                 result.ShouldBeNull();
         }
     }
+
+    [Subject(typeof(Catch))]
+    public class when_calling_catch_with_async_methods
+    {
+        static Exception exception;
+
+        [Subject(typeof(Catch))]
+        public class with_a_non_throwing_action
+        {
+            static Task Test() => Task.Run(() => { });
+
+            Because of = async () =>
+                exception = await Catch.ExceptionAsync(Test);
+
+            It should_return_null = () =>
+                exception.ShouldBeNull();
+        }
+
+        [Subject(typeof(Catch))]
+        public class with_a_throwing_action
+        {
+            static Task Test() => Task.Run(() => throw new ArgumentNullException());
+
+            Because of = async () =>
+                exception = await Catch.ExceptionAsync(Test);
+
+            It should_return_exception = () =>
+                exception.ShouldBeOfExactType<ArgumentNullException>();
+        }
+
+        [Subject(typeof(Catch))]
+        public class calling_wrong_catch_method
+        {
+            static Task Test() => Task.Run(() => throw new ArgumentNullException());
+
+            Because of = () =>
+                exception = Catch.Exception(() => Catch.Exception(Test));
+
+            It should_return_exception = () =>
+                exception.ShouldBeOfExactType<InvalidOperationException>();
+
+            It should_contain_message = () =>
+                exception.Message.ShouldEqual("You must use Catch.ExceptionAsync for async methods");
+        }
+    }
 }

src/Machine.Specifications.Specs/CompileContext.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CSharp;
@@ -44,7 +45,8 @@ public string Compile(string code)
             {
                 "Machine.Specifications.dll",
                 "Machine.Specifications.Should.dll",
-                "netstandard.dll"
+                "netstandard.dll",
+                $"{typeof(ValueTask).Assembly.GetName().Name}.dll"
             });
 
             var options = new Dictionary<string, string> {{"CompilerVersion", "v4.0"}};
@@ -53,7 +55,7 @@ public string Compile(string code)
             var results = provider.CompileAssemblyFromSource(parameters, code);
 
             if (results.Errors.Count > 0)
-                throw new InvalidOperationException();
+                throw new InvalidOperationException(results.Errors[0].ErrorText);
 #endif
             return filename;
         }

src/Machine.Specifications.Specs/Fixtures/RandomFixture.cs

@@ -1092,6 +1092,39 @@ public class AsyncSpecifications
         };
     }
 
+    public class AsyncSpecificationsValueTask
+    {
+        public static int establish_value;
+
+        public static int because_value;
+
+        public static int async_it_value;
+
+        public static int sync_it_value;
+
+        public static int cleanup_value;
+
+        public static ValueTask<int> Test()
+        {
+            return new ValueTask<int>(10);
+        }
+
+        Establish context = async () =>
+            establish_value = await Test();
+
+        Because of = async () =>
+            because_value = await Test();
+
+        It should_invoke_sync = () =>
+            sync_it_value = Test().Result;
+
+        It should_invoke_async = async () =>
+            async_it_value = await Test();
+
+        Cleanup after = async () =>
+            cleanup_value = await Test();
+    }
+
     public class AsyncSpecificationsWithExceptions
     {
         Because of = async () =>

src/Machine.Specifications.Specs/Runner/AsyncDelegateRunnerSpecs.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using Machine.Specifications.Factories;
 using Machine.Specifications.Runner;
 using Machine.Specifications.Runner.Impl;
@@ -75,4 +76,39 @@ public class when_running_async_specifications_with_exceptions : RandomRunnerSpe
         It should_have_failures = () =>
             results.ShouldEachConformTo(x => !x.Passed);
     }
+
+    [Subject("Async Delegate Runner")]
+    public class when_running_async_value_task_specifications : RandomRunnerSpecs
+    {
+        static Type specs;
+
+        Establish context = () =>
+        {
+            specs = GetFramework("AsyncSpecificationsValueTask");
+
+            specs.ToDynamic().establish_value = 0;
+            specs.ToDynamic().because_value = 0;
+            specs.ToDynamic().async_it_value = 0;
+            specs.ToDynamic().sync_it_value = 0;
+            specs.ToDynamic().cleanup_value = 0;
+        };
+
+        Because of = () =>
+            Run(specs);
+
+        It should_call_establish = () =>
+            specs.ToDynamic().establish_value.ShouldEqual(10);
+
+        It should_call_because = () =>
+            specs.ToDynamic().because_value.ShouldEqual(10);
+
+        It should_call_async_spec = () =>
+            specs.ToDynamic().async_it_value.ShouldEqual(10);
+
+        It should_call_sync_spec = () =>
+            specs.ToDynamic().sync_it_value.ShouldEqual(10);
+
+        It should_call_cleanup = () =>
+            specs.ToDynamic().cleanup_value.ShouldEqual(10);
+    }
 }

src/Machine.Specifications/Catch.cs

@@ -1,30 +1,61 @@
 using System;
+using System.Threading.Tasks;
 
 namespace Machine.Specifications
 {
     public static class Catch
     {
         public static Exception Exception(Action throwingAction)
         {
-            return Only<Exception>(throwingAction);
+            try
+            {
+                throwingAction();
+            }
+            catch (Exception ex)
+            {
+                return ex;
+            }
+
+            return null;
         }
 
         public static Exception Exception<T>(Func<T> throwingFunc)
         {
+            Task task;
+
             try
             {
-                throwingFunc();
+                task = throwingFunc() as Task;
             }
             catch (Exception exception)
             {
                 return exception;
             }
 
+            if (task != null)
+            {
+                throw new InvalidOperationException("You must use Catch.ExceptionAsync for async methods");
+            }
+
+            return null;
+        }
+
+        public static async Task<Exception> ExceptionAsync(Func<Task> throwingAction)
+        {
+            try
+            {
+                await throwingAction();
+            }
+            catch (Exception ex)
+            {
+                return ex;
+            }
+
             return null;
         }
 
         public static TException Only<TException>(Action throwingAction)
-          where TException : Exception
+            where TException : Exception
         {
             try
             {

src/Machine.Specifications/Machine.Specifications.csproj

@@ -15,4 +15,5 @@
   <ItemGroup>
     <None Include="Resources\Machine.png" Pack="true" PackagePath="\" />
   </ItemGroup>
+
 </Project>