Add ChainedInterceptor and TestInterceptor for improved request handling

Author: clement911

GraphQLSharp.Tests/ChainedInterceptorTests.cs

@@ -0,0 +1,51 @@
+using System.Net;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace GraphQLSharp.Tests;
+
+[TestClass]
+public class ChainedInterceptorTests
+{
+    [TestMethod]
+    public async Task CallInterceptorsInCorrectOrder()
+    {
+        var query = """
+            {
+                shop
+                {
+                    id
+                }
+            }
+            """;
+
+        var entries = new List<string>();
+        var options = new GraphQLClientOptions
+        {
+            Uri = new Uri("https://example.com/graphql"),
+            Interceptor = new ChainedInterceptor(
+                new TestInterceptor(
+                () => entries.Add("Before1"),
+                () => entries.Add("After1")))
+                .Wrap(new TestInterceptor(
+                    () => entries.Add("Before2"),
+                    () => entries.Add("After2")))
+                    .Wrap(new TestInterceptor(
+                        () => entries.Add("Before3"),
+                        () => entries.Add("After3"))),
+            HttpClient = new HttpClient(new TestHttpMessageHandler(msg =>
+            {
+                return new HttpResponseMessage(HttpStatusCode.OK)
+                {
+                    Content = new StringContent("""{"data":{"shop":{"id":"gid://shopify/Shop/1234567890"}}}""")
+                };
+            }))
+        };
+        var response = await new GraphQLCLient().ExecuteAsync(query, options);
+        Assert.AreEqual(HttpStatusCode.OK, response.HttpResponse.StatusCode);
+        Assert.IsTrue(entries.SequenceEqual(
+        [
+            "Before3", "Before2", "Before1",
+            "After1", "After2", "After3"
+        ]));
+    }
+}

GraphQLSharp.Tests/TestInterceptor.cs

@@ -0,0 +1,28 @@
+using GraphQLSharp;
+
+public class TestInterceptor : IInterceptor
+{
+    private readonly Action _onBeforeExecute;
+    private readonly Action _onAfterExecute;
+
+    public TestInterceptor(Action onBeforeExecute, Action onAfterExecute)
+    {
+        _onBeforeExecute = onBeforeExecute;
+        _onAfterExecute = onAfterExecute;
+    }
+
+    public async Task<GraphQLResponse<TData>> InterceptRequestAsync<TGraphQLRequest, TClientOptions, TData>(
+        TGraphQLRequest request,
+        TClientOptions defaultOptions,
+        TClientOptions options,
+        CancellationToken cancellationToken,
+        Func<TGraphQLRequest, CancellationToken, Task<GraphQLResponse<TData>>> executeAsync)
+        where TGraphQLRequest : GraphQLRequest, new()
+        where TClientOptions : GraphQLClientOptions
+    {
+        _onBeforeExecute?.Invoke();
+        var response = await executeAsync(request, cancellationToken);
+        _onAfterExecute?.Invoke();
+        return response;
+    }
+}

GraphQLSharp/Client/Interception/ChainedInterceptor.cs

@@ -0,0 +1,31 @@
+namespace GraphQLSharp;
+
+public class ChainedInterceptor : IInterceptor
+{
+    private List<IInterceptor> _interceptors = new List<IInterceptor>();
+
+    public ChainedInterceptor(IInterceptor innerMostInterceptor)
+    {
+        this._interceptors.Add(innerMostInterceptor);
+    }
+
+    public ChainedInterceptor Wrap(IInterceptor nextInterceptor)
+    {
+        _interceptors.Add(nextInterceptor);
+        return this;
+    }
+
+    public async Task<GraphQLResponse<TData>> InterceptRequestAsync<TGraphQLRequest, TClientOptions, TData>(TGraphQLRequest request, TClientOptions defaultOptions, TClientOptions options, CancellationToken cancellationToken, Func<TGraphQLRequest, CancellationToken, Task<GraphQLResponse<TData>>> executeAsync)
+        where TGraphQLRequest : GraphQLRequest, new()
+        where TClientOptions : GraphQLClientOptions
+    {
+        foreach (var interceptor in _interceptors)
+        {
+            var capturedInterceptor = interceptor;
+            var capturedExecuteAsync = executeAsync;
+            executeAsync = (req, ct) => capturedInterceptor.InterceptRequestAsync(req, defaultOptions, options, ct, capturedExecuteAsync);
+        }
+
+        return await executeAsync(request, cancellationToken);
+    }
+}