Tests for cancellation.

Author: scmccart

src/GraphQL.Tests/Execution/Cancellation/CancellationTests.cs

@@ -0,0 +1,79 @@
+using GraphQL.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Should;
+
+namespace GraphQL.Tests.Execution.Cancellation
+{
+    public class CancellationSchema : Schema
+    {
+        public CancellationSchema()
+        {
+            Query = new CancellationTestType();
+        }
+    }
+
+    public class CancellationTestType : ObjectGraphType
+    {
+        public CancellationTestType()
+        {
+            Name = "CancellationTestType";
+
+            Field<StringGraphType>("one", resolve: GetOne);
+            Field<StringGraphType>("two", resolve: GetTwo);
+        }
+
+        public Task<string> GetOne(ResolveFieldContext context)
+        {
+            if (!context.CancellationToken.CanBeCanceled)
+            {
+                throw new Exception("Should have token!");
+            }
+
+            return Task.FromResult("one");
+        }
+
+        public Task<string> GetTwo(ResolveFieldContext context)
+        {
+            context.CancellationToken.ThrowIfCancellationRequested();
+
+            return Task.FromResult("two");
+        }
+    }
+
+    public class CancellationTests : QueryTestBase<CancellationSchema>
+    {
+        [Test]
+        public void cancellation_token_in_context()
+        {
+            using (var tokenSource = new CancellationTokenSource())
+            {
+                AssertQuerySuccess("{one}", "{one: 'one'}", cancellationToken: tokenSource.Token);
+            }
+        }
+
+        [Test]
+        public void cancellation_is_propagated()
+        {
+            using (var tokenSource = new CancellationTokenSource())
+            {
+                try
+                {
+                    tokenSource.Cancel();
+                    AssertQuerySuccess("{two}", "{two: 'two'}", cancellationToken: tokenSource.Token);
+                }
+                catch(AggregateException aggExc)
+                {
+                    aggExc.InnerException.ShouldBeType<TaskCanceledException>();
+                    return;
+                }
+            }
+
+            throw new Exception("Cancellation did not propagate!");
+        }
+    }
+}

src/GraphQL.Tests/GraphQL.Tests.csproj

@@ -52,6 +52,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Execution\Cancellation\CancellationTests.cs" />
     <Compile Include="Execution\Directives\DirectivesTests.cs" />
     <Compile Include="StarWars\EpisodeEnum.cs" />
     <Compile Include="StarWars\StarWarsIntrospectionTests.cs" />

src/GraphQL.Tests/QueryTestBase.cs

@@ -6,6 +6,8 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Should;
+using System.Threading.Tasks;
+using System.Threading;
 
 namespace GraphQL.Tests
 {
@@ -31,15 +33,15 @@ public QueryTestBase()
 
         public IDocumentWriter Writer { get; private set; }
 
-        public void AssertQuerySuccess(string query, string expected, Inputs inputs = null, object root = null)
+        public void AssertQuerySuccess(string query, string expected, Inputs inputs = null, object root = null, CancellationToken cancellationToken = default(CancellationToken))
         {
             var queryResult = CreateQueryResult(expected);
-            AssertQuery(query, queryResult, inputs, root);
+            AssertQuery(query, queryResult, inputs, root, cancellationToken);
         }
 
-        public void AssertQuery(string query, ExecutionResult executionResult, Inputs inputs, object root)
+        public void AssertQuery(string query, ExecutionResult executionResult, Inputs inputs, object root, CancellationToken cancellationToken = default(CancellationToken))
         {
-            var runResult = Executer.ExecuteAsync(Schema, root, query, null, inputs).Result;
+            var runResult = Executer.ExecuteAsync(Schema, root, query, null, inputs, cancellationToken).Result;
 
             var writtenResult = Writer.Write(runResult);
             var expectedResult = Writer.Write(executionResult);