Introduce Cancellation Token support across all public service APIs. (Resolves #238)

ShopifySharp.Experimental/ApplicationCredit.fs

@@ -1,6 +1,7 @@
 namespace ShopifySharp.Experimental
 
 open System.Net.Http
+open System.Threading
 open ShopifySharp
 open ShopifySharp.Infrastructure
 
@@ -62,7 +63,7 @@ module ApplicationCredits =
             let req = base.PrepareRequest "application_credits.json"
             let data = dict [ "application_credit" => data ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<ApplicationCredit>(req, HttpMethod.Post, content, "usage_charge")
+            base.ExecuteRequestAsync<ApplicationCredit>(req, HttpMethod.Post, CancellationToken.None, content, "usage_charge")
             |> mapTask (fun response -> response.Result)
 
         static member NewService domain accessToken = Service(domain, accessToken)

ShopifySharp.Experimental/Charges.fs

@@ -1,6 +1,7 @@
 namespace ShopifySharp.Experimental
 
 open System.Net.Http
+open System.Threading
 open ShopifySharp
 open ShopifySharp.Infrastructure
 
@@ -63,7 +64,7 @@ module Charges =
             let req = base.PrepareRequest "application_charges.json"
             let data = dict [ "application_charge" => data ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<Charge>(req, HttpMethod.Post, content, "application_charge")
+            base.ExecuteRequestAsync<Charge>(req, HttpMethod.Post, CancellationToken.None, content, "application_charge")
             |> mapTask (fun response -> response.Result)
 
         static member NewService domain accessToken = Service(domain, accessToken)

ShopifySharp.Experimental/Orders.fs

@@ -2,6 +2,9 @@
 
 open System.Collections.Generic
 open System.Net.Http
+open System.Threading
+open System.Threading
+open System.Threading
 open ShopifySharp
 open ShopifySharp.Infrastructure
 
@@ -274,21 +277,21 @@ module Orders =
             let req = base.PrepareRequest "orders.json"
             let data = dict [ "order" => order ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<Order>(req, HttpMethod.Post, content, "order")
+            base.ExecuteRequestAsync<Order>(req, HttpMethod.Post, CancellationToken.None, content, "order")
             |> mapTask (fun response -> response.Result)
 
         member x.CreateAsync(order: OrderProperties, options: CreationOptions.CreationOptionProperties) =
             let req = base.PrepareRequest "orders.json"
             let data = dict [ "order", mergeOrderAndCreationOptions order options |> JsonValue.MapPropertyValuesToObjects ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<Order>(req, HttpMethod.Post, content, "order")
+            base.ExecuteRequestAsync<Order>(req, HttpMethod.Post, CancellationToken.None, content, "order")
             |> mapTask (fun response -> response.Result)
 
         member x.UpdateAsync (id: int64, order: OrderProperties) =
             let req = base.PrepareRequest (sprintf "orders/%i.json" id)
             let data = dict [ "order" => order ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<Order>(req, HttpMethod.Put, content, "order")
+            base.ExecuteRequestAsync<Order>(req, HttpMethod.Put, CancellationToken.None, content, "order")
             |> mapTask (fun response -> response.Result)
 
         static member NewService domain accessToken = Service(domain, accessToken)

ShopifySharp.Experimental/RecurringCharges.fs

@@ -1,6 +1,7 @@
 namespace ShopifySharp.Experimental
 
 open System.Net.Http
+open System.Threading
 open ShopifySharp
 open ShopifySharp.Infrastructure
 
@@ -75,7 +76,7 @@ module RecurringCharges =
             let req = base.PrepareRequest "recurring_application_charges.json"
             let data = dict [ "recurring_application_charge" => data ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<RecurringCharge>(req, HttpMethod.Post, content, "recurring_application_charge")
+            base.ExecuteRequestAsync<RecurringCharge>(req, HttpMethod.Post, CancellationToken.None, content, "recurring_application_charge")
             |> mapTask (fun response -> response.Result)
 
         static member NewService domain accessToken = Service(domain, accessToken)

ShopifySharp.Experimental/ScriptTags.fs

@@ -1,6 +1,8 @@
 namespace ShopifySharp.Experimental
 
 open System.Net.Http
+open System.Threading
+open System.Threading
 open ShopifySharp
 open ShopifySharp.Infrastructure
 
@@ -80,14 +82,14 @@ module ScriptTags =
             let req = base.PrepareRequest "script_tags.json"
             let data = dict [ "script_tag" => tag ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<ScriptTag>(req, HttpMethod.Post, content, "script_tag")
+            base.ExecuteRequestAsync<ScriptTag>(req, HttpMethod.Post, CancellationToken.None, content, "script_tag")
             |> mapTask (fun response -> response.Result)
 
         member x.UpdateAsync (id : int64, tag : ScriptTagProperties) =
             let req = base.PrepareRequest (sprintf "script_tags/%i.json" id)
             let data = dict [ "script_tag" => tag ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<ScriptTag>(req, HttpMethod.Put, content, "script_tag")
+            base.ExecuteRequestAsync<ScriptTag>(req, HttpMethod.Put, CancellationToken.None, content, "script_tag")
             |> mapTask (fun response -> response.Result)
 
         static member NewService domain accessToken = Service(domain, accessToken)

ShopifySharp.Experimental/UsageCharges.fs

@@ -1,6 +1,7 @@
 namespace ShopifySharp.Experimental
 
 open System.Net.Http
+open System.Threading
 open ShopifySharp
 open ShopifySharp.Infrastructure
 
@@ -55,7 +56,7 @@ module UsageCharges =
             let req = base.PrepareRequest (sprintf "recurring_application_charges/%i/usage_charges.json" recurringChargeId)
             let data = dict [ "usage_charge" => data ]
             let content = new JsonContent(data)
-            base.ExecuteRequestAsync<UsageCharge>(req, HttpMethod.Post, content, "usage_charge")
+            base.ExecuteRequestAsync<UsageCharge>(req, HttpMethod.Post, CancellationToken.None, content, "usage_charge")
             |> mapTask (fun response -> response.Result)
 
         static member NewService domain accessToken = Service(domain, accessToken)

ShopifySharp.Experimental/Webhooks.fs

@@ -1,6 +1,8 @@
 namespace ShopifySharp.Experimental
 
 open System.Net.Http
+open System.Threading
+open System.Threading
 open System.Threading.Tasks
 open ShopifySharp
 open ShopifySharp.Infrastructure
@@ -82,15 +84,15 @@ module Webhooks =
             let data = dict [ "webhook" => webhook ]
             let content = new JsonContent(data)
 
-            base.ExecuteRequestAsync<Webhook>(req, HttpMethod.Post, content, "webhook")
+            base.ExecuteRequestAsync<Webhook>(req, HttpMethod.Post, CancellationToken.None, content, "webhook")
             |> mapTask (fun response -> response.Result)
 
         member x.UpdateAsync (id: int64, webhook: WebhookProperties) =
             let req = base.PrepareRequest (sprintf "webhooks/%i.json" id)
             let data = dict [ "webhook" => webhook ]
             let content = new JsonContent(data)
 
-            base.ExecuteRequestAsync<Webhook>(req, HttpMethod.Put, content, "webhook")
+            base.ExecuteRequestAsync<Webhook>(req, HttpMethod.Put, CancellationToken.None, content, "webhook")
             |> mapTask (fun response -> response.Result)
 
         static member NewService domain accessToken = Service(domain, accessToken)

ShopifySharp.Tests/ExecuteRequestCancellation_Tests.cs

@@ -0,0 +1,188 @@
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using ShopifySharp.Filters;
+using ShopifySharp.Infrastructure;
+using ShopifySharp.Lists;
+using Xunit;
+
+namespace ShopifySharp.Tests
+{
+    [Trait("Category", "ExecuteRequestCancellation")]
+    public class ExecuteRequestCancellation_Tests
+    {
+        private class TestService : ShopifyService
+        {
+            public TestService() : base("someurl", "sometoken")
+            {
+            }
+
+            // these are what services call to execute their public API requests
+            public new Task<T> ExecuteGetAsync<T>(string path, string resultRootElt, string fields, CancellationToken cancellationToken = default)
+            {
+                return base.ExecuteGetAsync<T>(path, resultRootElt, fields, cancellationToken);
+            }
+
+            public new Task<T> ExecuteGetAsync<T>(string path, string resultRootElt, Parameterizable queryParams = null, CancellationToken cancellationToken = default)
+            {
+                return base.ExecuteGetAsync<T>(path, resultRootElt, queryParams, cancellationToken);
+            }
+
+            public new Task<ListResult<T>> ExecuteGetListAsync<T>(string path, string resultRootElt, ListFilter<T> filter, CancellationToken cancellationToken = default)
+            {
+                return base.ExecuteGetListAsync(path, resultRootElt, filter, cancellationToken);
+            }
+
+            public new Task<T> ExecutePostAsync<T>(string path, string resultRootElt, object jsonContent = null, CancellationToken cancellationToken = default)
+            {
+                return base.ExecutePostAsync<T>(path, resultRootElt, cancellationToken, jsonContent);
+            }
+
+            public new Task<T> ExecutePutAsync<T>(string path, string resultRootElt, object jsonContent = null, CancellationToken cancellationToken = default)
+            {
+                return base.ExecutePutAsync<T>(path, resultRootElt, cancellationToken, jsonContent);
+            }
+
+            public new Task ExecuteDeleteAsync(string path, CancellationToken cancellationToken)
+            {
+                return base.ExecuteDeleteAsync(path, cancellationToken);
+            }
+
+            public new Task<RequestResult<JToken>> ExecuteRequestAsync(RequestUri uri, HttpMethod method, HttpContent content = null, CancellationToken cancellationToken = default)
+            {
+                return base.ExecuteRequestAsync(uri, method, cancellationToken, content);
+            }
+        }
+
+        [Fact]
+        public async Task Cancelling_An_ExecuteGetListAsync_Terminates_HttpRequest()
+        {
+            var service = new TestService();
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = service.ExecuteGetListAsync<object>(string.Empty, string.Empty, null, cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+
+        [Fact]
+        public async Task Cancelling_An_ExecuteGetAsync_Terminates_HttpRequest()
+        {
+            var service = new TestService();
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = service.ExecuteGetAsync<object>(string.Empty, string.Empty, string.Empty, cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+
+        [Fact]
+        public async Task Cancelling_An_ExecuteGetAsyncFilter_Terminates_HttpRequest()
+        {
+            var service = new TestService();
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = service.ExecuteGetAsync<object>(string.Empty, string.Empty, new PageCountFilter(), cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+
+        [Fact]
+        public async Task Cancelling_An_ExecutePutAsync_Terminates_HttpRequest()
+        {
+            var service = new TestService();
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = service.ExecutePutAsync<object>(string.Empty, string.Empty, null, cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+
+        [Fact]
+        public async Task Cancelling_An_ExecutePostAsync_Terminates_HttpRequest()
+        {
+            var service = new TestService();
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = service.ExecutePostAsync<object>(string.Empty, string.Empty, null, cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+
+        [Fact]
+        public async Task Cancelling_An_ExecuteDeleteAsync_Terminates_HttpRequest()
+        {
+            var service = new TestService();
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = service.ExecuteDeleteAsync(string.Empty, cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+
+        [Fact]
+        public async Task Cancelling_An_ExecuteRequestAsync_Terminates_HttpRequest()
+        {
+            var service = new TestService();
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = service.ExecuteRequestAsync(new RequestUri(new Uri("http://unreachable")), HttpMethod.Get, null, cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+
+        private static OrderService OrderService => new OrderService(Utils.MyShopifyUrl, Utils.AccessToken);
+
+        [Fact]
+        public async Task Cancelling_An_OrderService_List_Terminates_HttpRequest()
+        {
+            var cts = new CancellationTokenSource();
+
+            await Assert.ThrowsAsync<TaskCanceledException>(async () =>
+            {
+                var task = OrderService.ListAsync(cancellationToken: cts.Token);
+
+                cts.Cancel();
+
+                await task;
+            });
+        }
+    }
+}

ShopifySharp/Infrastructure/Policies/DefaultRequestExecutionPolicy.cs

@@ -1,12 +1,13 @@
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using ShopifySharp.Infrastructure;
 
 namespace ShopifySharp
 {
     public class DefaultRequestExecutionPolicy : IRequestExecutionPolicy
     {
-        public async Task<RequestResult<T>> Run<T>(CloneableRequestMessage request, ExecuteRequestAsync<T> executeRequestAsync)
+        public async Task<RequestResult<T>> Run<T>(CloneableRequestMessage request, ExecuteRequestAsync<T> executeRequestAsync, CancellationToken cancellationToken)
         {
             var fullResult = await executeRequestAsync(request);
 

ShopifySharp/Infrastructure/Policies/IRequestExecutionPolicy.cs

@@ -1,4 +1,5 @@
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using ShopifySharp.Infrastructure;
 
@@ -14,6 +15,7 @@ public interface IRequestExecutionPolicy
     {
         /// <param name="baseRequest">The base request that was built by a service to execute.</param>
         /// <param name="executeRequestAsync">A delegate that executes the request you pass to it.</param>
-        Task<RequestResult<T>> Run<T>(CloneableRequestMessage requestMessage, ExecuteRequestAsync<T> executeRequestAsync);
+        /// <param name="cancellationToken">Cancellation token</param>
+        Task<RequestResult<T>> Run<T>(CloneableRequestMessage requestMessage, ExecuteRequestAsync<T> executeRequestAsync, CancellationToken cancellationToken);
     }
 }

ShopifySharp/Infrastructure/Policies/RetryExecutionPolicy.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 using ShopifySharp.Infrastructure;
 
@@ -19,7 +20,7 @@ public RetryExecutionPolicy(bool retryOnlyIfLeakyBucketFull = true)
             _retryOnlyIfLeakyBucketFull = retryOnlyIfLeakyBucketFull;
         }
 
-        public async Task<RequestResult<T>> Run<T>(CloneableRequestMessage baseRequest, ExecuteRequestAsync<T> executeRequestAsync)
+        public async Task<RequestResult<T>> Run<T>(CloneableRequestMessage baseRequest, ExecuteRequestAsync<T> executeRequestAsync, CancellationToken cancellationToken)
         {
             while (true)
             {
@@ -36,7 +37,7 @@ public async Task<RequestResult<T>> Run<T>(CloneableRequestMessage baseRequest,
                     //Only retry if breach caused by full bucket
                     //Other limits will bubble the exception because it's not clear how long the program should wait
                     //Even if there is a Retry-After header, we probably don't want the thread to sleep for potentially many hours
-                    await Task.Delay(RETRY_DELAY);
+                    await Task.Delay(RETRY_DELAY, cancellationToken);
                 }
             }
         }