Add flag for throwing on unhandled exceptions (graphql-dotnet#776)

Fixes graphql-dotnet#607

Author: joemcbride

src/GraphQL.Tests/Bugs/Bug68NonNullEnumGraphTypeTests.cs

@@ -13,15 +13,6 @@ public class Bug68NonNullEnumGraphTypeTests
     {
         private readonly IDocumentExecuter _executer = new DocumentExecuter();
 
-        ExecutionResult ExecuteQuery(ISchema schema, string query)
-        {
-            return _executer.ExecuteAsync(_ =>
-            {
-                _.Schema = schema;
-                _.Query = query;
-            }).GetAwaiter().GetResult();
-        }
-
         [Fact]
         public void only_nullable_is_happy()
         {
@@ -40,7 +31,16 @@ public void both_is_happy()
             VerifyIntrospection(new NullableSchema(true, true));
         }
 
-        public void VerifyIntrospection(ISchema schema)
+        private ExecutionResult ExecuteQuery(ISchema schema, string query)
+        {
+            return _executer.ExecuteAsync(_ =>
+            {
+                _.Schema = schema;
+                _.Query = query;
+            }).GetAwaiter().GetResult();
+        }
+
+        private void VerifyIntrospection(ISchema schema)
         {
             var result = ExecuteQuery(schema, SchemaIntrospection.IntrospectionQuery);
             result.ShouldNotBeNull();

src/GraphQL.Tests/Bugs/NullableInputListTests.cs

@@ -8,7 +8,7 @@ namespace GraphQL.Tests.Bugs
     public class NullableInputListTests : QueryTestBase<TestSchema>
     {
         [Fact]
-        public async void Can_Accept_Null_List_From_Literal()
+        public void Can_Accept_Null_List_From_Literal()
         {
             var query = @"
                 query _ {
@@ -22,7 +22,7 @@ query _ {
         }
 
         [Fact]
-        public async void Can_Accept_Null_List_From_Input()
+        public void Can_Accept_Null_List_From_Input()
         {
             var query = @"
                 query _($inputs:[TestInput]) {

src/GraphQL.Tests/Errors/ErrorCodeTests.cs

@@ -68,23 +68,23 @@ public TestQuery()
                 );
                 FieldAsync<StringGraphType>(
                     "firstAsync",
-                    resolve: async _ => throw new FirstException("Exception from asynchronous resolver")
+                    resolve: _ => { throw new FirstException("Exception from asynchronous resolver"); }
                 );
                 Field<StringGraphType>(
                     "secondSync",
                     resolve: _ => throw new SecondTestException("Exception from synchronous resolver")
                 );
                 FieldAsync<StringGraphType>(
                     "secondAsync",
-                    resolve: async _ => throw new SecondTestException("Exception from asynchronous resolver")
+                    resolve: _ => { throw new SecondTestException("Exception from asynchronous resolver"); }
                 );
                 Field<StringGraphType>(
                     "uncodedSync",
                     resolve: _ => throw new Exception("Exception from synchronous resolver")
                 );
                 FieldAsync<StringGraphType>(
                     "uncodedAsync",
-                    resolve: async _ => throw new Exception("Exception from asynchronous resolver")
+                    resolve: _ => { throw new Exception("Exception from asynchronous resolver"); }
                 );
             }
         }

src/GraphQL.Tests/Errors/ErrorExtensionsTests.cs

@@ -64,23 +64,23 @@ public TestQuery()
                 );
                 FieldAsync<StringGraphType>(
                     "firstAsync",
-                    resolve: async _ => throw new FirstException("Exception from asynchronous resolver")
+                    resolve: _ => { throw new FirstException("Exception from asynchronous resolver"); }
                 );
                 Field<StringGraphType>(
                     "secondSync",
                     resolve: _ => throw new SecondTestException("Exception from synchronous resolver")
                 );
                 FieldAsync<StringGraphType>(
                     "secondAsync",
-                    resolve: async _ => throw new SecondTestException("Exception from asynchronous resolver")
+                    resolve: _ => { throw new SecondTestException("Exception from asynchronous resolver"); }
                 );
                 Field<StringGraphType>(
                     "uncodedSync",
                     resolve: _ => throw new Exception("Exception from synchronous resolver")
                 );
                 FieldAsync<StringGraphType>(
                     "uncodedAsync",
-                    resolve: async _ => throw new Exception("Exception from asynchronous resolver")
+                    resolve: _ => { throw new Exception("Exception from asynchronous resolver"); }
                 );
             }
         }

src/GraphQL.Tests/Errors/ErrorLocationTests.cs

@@ -107,7 +107,7 @@ public TestQuery()
 
                 FieldAsync<StringGraphType>(
                     "testasync",
-                    resolve: async _ => throw new Exception("wat"));
+                    resolve: _ => { throw new Exception("wat"); });
 
                 Field<TestSubObject>()
                     .Name("testSub")

src/GraphQL.Tests/Errors/UnhandledExceptionTests.cs

@@ -0,0 +1,40 @@
+using System;
+using GraphQL.Tests.Utilities;
+using Shouldly;
+using Xunit;
+
+namespace GraphQL.Tests.Errors
+{
+    public class UnhandledExceptionTests : SchemaBuilderTestBase
+    {
+        [Fact]
+        public void rethrows_unhandled_exception()
+        {
+            var def = @"
+                type Query {
+                  hello: Int
+                }
+            ";
+
+            Builder.Types.Include<Query>();
+
+            Should.Throw<AggregateException>(() =>
+            {
+                AssertQuery(_ =>
+                {
+                    _.Query = "{ hello }";
+                    _.Definitions = def;
+                    _.ThrowOnUnhandledException = true;
+                });
+            });
+        }
+
+        public class Query
+        {
+            public int Hello()
+            {
+                throw new Exception("arrgh");
+            }
+        }
+    }
+}

src/GraphQL.Tests/Types/SchemaTests.cs

@@ -107,7 +107,7 @@ public void registers_only_root_types()
             DoesNotContainTypeNames(schema, "ASchemaType!");
         }
 
-        public void ContainsTypeNames(ISchema schema, params string[] typeNames)
+        private void ContainsTypeNames(ISchema schema, params string[] typeNames)
         {
             typeNames.Apply(typeName =>
             {
@@ -116,7 +116,7 @@ public void ContainsTypeNames(ISchema schema, params string[] typeNames)
             });
         }
 
-        public void DoesNotContainTypeNames(Schema schema, params string[] typeNames)
+        private void DoesNotContainTypeNames(Schema schema, params string[] typeNames)
         {
             typeNames.Apply(typeName =>
             {

src/GraphQL.Tests/Utilities/SchemaBuilderTestBase.cs

@@ -34,6 +34,8 @@ public ExecutionResult AssertQuery(Action<ExecuteConfig> configure)
                 _.Schema = schema;
                 _.Query = config.Query;
                 _.Inputs = config.Variables.ToInputs();
+                _.Root = config.Root;
+                _.ThrowOnUnhandledException = config.ThrowOnUnhandledException;
             }, queryResult);
         }
 
@@ -75,5 +77,7 @@ public class ExecuteConfig
         public string Query { get; set; }
         public string Variables { get; set; }
         public string ExpectedResult { get; set; }
+        public object Root { get; set; }
+        public bool ThrowOnUnhandledException { get; set; }
     }
 }

src/GraphQL.Tests/Validation/KnownDirectivesTests.cs

@@ -125,8 +125,7 @@ mutation Bar @onQuery {
             });
         }
 
-        // this is not yet supported
-        //[Fact]
+        [Fact]
         public void within_schema_language_well_placed_directives()
         {
             ShouldPassRule(@"
@@ -156,8 +155,7 @@ schema @onSchema {
             ");
         }
 
-        // this is not yet supported
-        //[Fact]
+        [Fact(Skip = "This is not yet supported")]
         public void within_schema_language_with_misplaced_directives()
         {
             ShouldFailRule(_ =>

src/GraphQL/Execution/DocumentExecuter.cs

@@ -185,7 +185,8 @@ await listener.AfterValidationAsync(
                     options.UserContext,
                     options.CancellationToken,
                     metrics,
-                    options.Listeners);
+                    options.Listeners,
+                    options.ThrowOnUnhandledException);
 
                 if (context.Errors.Any())
                 {
@@ -233,6 +234,9 @@ await listener.AfterExecutionAsync(context.UserContext, context.CancellationToke
             }
             catch (Exception ex)
             {
+                if (options.ThrowOnUnhandledException)
+                    throw;
+
                 result = new ExecutionResult
                 {
                     Errors = new ExecutionErrors
@@ -251,7 +255,7 @@ await listener.AfterExecutionAsync(context.UserContext, context.CancellationToke
             return result;
         }
 
-        public ExecutionContext BuildExecutionContext(
+        private ExecutionContext BuildExecutionContext(
             ISchema schema,
             object root,
             Document document,
@@ -260,7 +264,8 @@ public ExecutionContext BuildExecutionContext(
             object userContext,
             CancellationToken cancellationToken,
             Metrics metrics,
-            IEnumerable<IDocumentExecutionListener> listeners)
+            IEnumerable<IDocumentExecutionListener> listeners,
+            bool throwOnUnhandledException)
         {
             var context = new ExecutionContext();
             context.Document = document;
@@ -275,6 +280,7 @@ public ExecutionContext BuildExecutionContext(
 
             context.Metrics = metrics;
             context.Listeners = listeners;
+            context.ThrowOnUnhandledException = throwOnUnhandledException;
 
             return context;
         }

src/GraphQL/Execution/ExecutionContext.cs

@@ -36,5 +36,7 @@ public ExecutionContext()
         public Metrics Metrics { get; set; }
 
         public IEnumerable<IDocumentExecutionListener> Listeners { get; set; } = Enumerable.Empty<IDocumentExecutionListener>();
+
+        public bool ThrowOnUnhandledException { get; set; }
     }
 }

src/GraphQL/Execution/ExecutionOptions.cs

@@ -36,5 +36,6 @@ public class ExecutionOptions
         //Note disabling will increase performance. When true all nodes will have the middleware injected for resolving fields.
         public bool SetFieldMiddleware { get; set; } = true;
 
+        public bool ThrowOnUnhandledException { get; set; } = false;
     }
 }

src/GraphQL/Execution/ExecutionStrategy.cs

@@ -220,6 +220,9 @@ protected virtual async Task<ExecutionNode> ExecuteNodeAsync(ExecutionContext co
             }
             catch (Exception ex)
             {
+                if (context.ThrowOnUnhandledException)
+                    throw;
+
                 var error = new ExecutionError($"Error trying to resolve {node.Name}.", ex);
                 error.AddLocation(node.Field, context.Document);
                 error.Path = node.Path;