From 041f327f87e4cca4ba49f6c37d0a7bfa303ca2de Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 20 Nov 2018 22:12:48 +0100
Subject: [PATCH 001/455] Observable Subscriptions (#80)

* create observable subscription

* create integration test server and test project

* fix debug output

* create basic unit test for subscription

* make unit test politically correct

* make sure all ClientWebSockets are disposed on disposing the GraphQlHttpClient

* fix comment

* Modified GraphQL.Client.csproj
---
 GraphQL.Client.sln                            |  16 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |   5 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  37 ++-
 .../Http/GraphQLHttpObservableSubscription.cs | 268 ++++++++++++++++++
 .../Http/GraphQLHttpSubscriptionResult.cs     |   8 +-
 .../Http/HttpClientExtensions.cs              |  10 +
 src/GraphQL.Client/IGraphQLClient.cs          |   2 +
 .../Response/GraphQLSubscriptionResponse.cs   |   2 +-
 .../GraphQL.Client.Tests.csproj               |   4 +-
 .../GraphQL.Integration.Tests.csproj          |  28 ++
 .../GraphQLClientExtensions.cs                |  34 +++
 .../ObservableTester.cs                       | 151 ++++++++++
 .../Properties/launchSettings.json            |  27 ++
 .../SubscriptionsTest.cs                      | 114 ++++++++
 .../WebApplicationFactoryExtensions.cs        |  19 ++
 .../ChatSchema/ChatMutation.cs                |  31 ++
 .../ChatSchema/ChatQuery.cs                   |  13 +
 .../ChatSchema/ChatSchema.cs                  |  14 +
 .../ChatSchema/ChatSubscriptions.cs           |  74 +++++
 .../IntegrationTestServer/ChatSchema/IChat.cs |  79 ++++++
 .../ChatSchema/Message.cs                     |  15 +
 .../ChatSchema/MessageFrom.cs                 |   9 +
 .../ChatSchema/MessageFromType.cs             |  13 +
 .../ChatSchema/MessageType.cs                 |  21 ++
 .../ChatSchema/ReceivedMessage.cs             |  13 +
 .../IntegrationTestServer.csproj              |  22 ++
 tests/IntegrationTestServer/Program.cs        |  17 ++
 .../Properties/launchSettings.json            |  28 ++
 tests/IntegrationTestServer/Startup.cs        |  69 +++++
 29 files changed, 1127 insertions(+), 16 deletions(-)
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
 create mode 100644 tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
 create mode 100644 tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
 create mode 100644 tests/GraphQL.Integration.Tests/ObservableTester.cs
 create mode 100644 tests/GraphQL.Integration.Tests/Properties/launchSettings.json
 create mode 100644 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/IChat.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/Message.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageType.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
 create mode 100644 tests/IntegrationTestServer/IntegrationTestServer.csproj
 create mode 100644 tests/IntegrationTestServer/Program.cs
 create mode 100644 tests/IntegrationTestServer/Properties/launchSettings.json
 create mode 100644 tests/IntegrationTestServer/Startup.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 45a422a5..722a7d85 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -43,7 +43,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".circleci", ".circleci", "{
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{9413EC62-CDDE-4E77-9784-E1136EA5D1EE}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests", "tests\GraphQL.Integration.Tests\GraphQL.Integration.Tests.csproj", "{86BC3878-6549-4EF1-9672-B7C15A3FDF46}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -71,6 +75,14 @@ Global
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Release|Any CPU.Build.0 = Release|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -83,6 +95,8 @@ Global
 		{6326E0E2-3F48-4BAF-80D3-47AED5EB647C} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 		{C1406F03-650F-4633-887D-312943251919} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 		{B21E97C3-F328-473F-A054-A4BF272B63F0} = {9413EC62-CDDE-4E77-9784-E1136EA5D1EE}
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 99a24460..200758df 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -1,11 +1,11 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
 		<Description>A GraphQL Client</Description>
-		<TargetFrameworks>netstandard1.3;netstandard2.0</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -14,6 +14,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
 	<!-- Allow method ReadAsAsync<T>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 58da72ee..fe8f4710 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -40,6 +41,7 @@ public GraphQLHttpClientOptions Options {
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
+		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		/// <summary>
 		/// Initializes a new instance
@@ -117,23 +119,44 @@ public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, Cancell
 			this.SendSubscribeAsync(new GraphQLRequest { Query = query }, cancellationToken);
 
 		[Obsolete("EXPERIMENTAL API")]
-		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			GraphQLHttpSubscriptionResult graphQLSubscriptionResult = _createSubscription(request, cancellationToken);
+			return Task.FromResult<IGraphQLSubscriptionResult>(graphQLSubscriptionResult);
+		}
+
+		private GraphQLHttpSubscriptionResult _createSubscription(GraphQLRequest request, CancellationToken cancellationToken)
+		{
 			if (request == null) { throw new ArgumentNullException(nameof(request)); }
 			if (request.Query == null) { throw new ArgumentNullException(nameof(request.Query)); }
 
-			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
-			var webSocketUri = new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
-			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(webSocketUri, request);
+			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), request);
 			graphQLSubscriptionResult.StartAsync(cancellationToken);
-			return Task.FromResult<IGraphQLSubscriptionResult>(graphQLSubscriptionResult);
+			return graphQLSubscriptionResult;
+		}
+
+		private Uri _getWebSocketUri()
+		{
+			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
+			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
+		}
+
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
+		{
+			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token);
+			return observable;
 		}
 
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
-		public void Dispose() =>
+		public void Dispose()
+		{
 			this.graphQLHttpHandler.Dispose();
-
+			_cancellationTokenSource.Cancel();
+			_cancellationTokenSource.Dispose();
+		}
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
new file mode 100644
index 00000000..d3f71990
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -0,0 +1,268 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http {
+
+	/// <summary>
+	/// Represents the result of a subscription query
+	/// </summary>
+	[Obsolete("EXPERIMENTAL API")]
+	public class GraphQLHttpObservableSubscription : IDisposable {
+
+		private readonly ClientWebSocket clientWebSocket = new ClientWebSocket();
+		private readonly Uri webSocketUri;
+		private readonly GraphQLRequest graphQLRequest;
+		private readonly byte[] buffer = new byte[1024 * 1024];
+		private readonly ArraySegment<byte> arraySegment;
+		private readonly CancellationTokenSource _cancellationTokenSource;
+
+		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default) {
+			_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+			_cancellationTokenSource.Token.Register(Dispose);
+			this.webSocketUri = webSocketUri;
+			this.graphQLRequest = graphQLRequest;
+			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+			arraySegment = new ArraySegment<byte>(buffer);
+		}
+
+		public async Task ConnectAsync(CancellationToken token)
+		{
+			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
+			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
+		}
+
+		public async Task<GraphQLResponse> ReceiveResultAsync()
+		{
+			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
+			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+			switch (webSocketResponse.Type)
+			{
+				case GQLWebSocketMessageType.GQL_COMPLETE:
+					Debug.WriteLine($"received 'complete' message on subscription {this.GetHashCode()}");
+					Dispose();
+					break;
+				case GQLWebSocketMessageType.GQL_ERROR:
+					Debug.WriteLine($"received 'error' message on subscription {this.GetHashCode()}");
+					throw new GQLSubscriptionException(webSocketResponse.Payload);
+				default:
+					Debug.WriteLine($"received payload on subscription {this.GetHashCode()}");
+					break;
+			}
+
+			return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
+		}
+
+		public async Task CloseAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
+			if (this.clientWebSocket.State == WebSocketState.Open) {
+				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
+			}
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+		}
+
+		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
+			var webSocketRequest = new GraphQLSubscriptionRequest
+			{
+				Id = "1",
+				Type = GQLWebSocketMessageType.GQL_START,
+				Payload = this.graphQLRequest
+			};
+			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
+		}
+
+		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
+			var webSocketRequest = new GraphQLSubscriptionRequest
+			{
+				Id = "1",
+				Type = GQLWebSocketMessageType.GQL_STOP,
+				Payload = this.graphQLRequest
+			};
+			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
+		}
+
+		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default)
+		{
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
+		}
+
+		#region IDisposable
+
+		public void Dispose()
+		{
+			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+			if(Disposed == null) Disposed = DisposeAsync();
+		}
+
+		public Task Disposed { get; private set; }
+
+		private async Task DisposeAsync()
+		{
+			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
+			if(!_cancellationTokenSource.IsCancellationRequested)
+				_cancellationTokenSource.Cancel();
+			await CloseAsync().ConfigureAwait(false);
+			clientWebSocket?.Dispose();
+			_cancellationTokenSource.Dispose();
+			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
+		}
+
+		#endregion
+
+		#region Static Factories
+
+		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
+		{
+			return Observable.Using(
+				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
+				InitializeSubscription
+				).Publish().RefCount();
+		}
+
+
+		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
+		{
+			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
+			return Task.FromResult(subscription);
+		}
+
+		private static async Task<IObservable<GraphQLResponse>> InitializeSubscription(GraphQLHttpObservableSubscription observableSubscription, CancellationToken cancelToken)
+		{
+			await observableSubscription.ConnectAsync(cancelToken).ConfigureAwait(false);
+			await observableSubscription.SendInitialMessageAsync(cancelToken).ConfigureAwait(false);
+			return Observable.Defer(() => observableSubscription.ReceiveResultAsync().ToObservable()).Repeat();
+		}
+
+		#endregion
+
+		[Serializable]
+		public class GQLSubscriptionException : Exception
+		{
+			//
+			// For guidelines regarding the creation of new exception types, see
+			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+			// and
+			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+			//
+
+			public GQLSubscriptionException()
+			{
+			}
+
+			public GQLSubscriptionException(object error) : base(error.ToString())
+			{
+			}
+
+			protected GQLSubscriptionException(
+				SerializationInfo info,
+				StreamingContext context) : base(info, context)
+			{
+			}
+		}
+
+		public static class GQLWebSocketMessageType
+		{
+
+			/// <summary>
+			///     Client sends this message after plain websocket connection to start the communication with the server
+			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+			///     to this message.
+			///     payload: Object : optional parameters that the client specifies in connectionParams
+			/// </summary>
+			public const string GQL_CONNECTION_INIT = "connection_init";
+
+			/// <summary>
+			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+			///     the connection.
+			/// </summary>
+			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+
+			/// <summary>
+			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+			///     the connection.
+			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+			///     client, just ignore the message).
+			///     payload: Object: the server side error
+			/// </summary>
+			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+
+			/// <summary>
+			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+			///     client connection alive.
+			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+			///     server.
+			///     <remarks>
+			///         NOTE: This one here don't follow the standard due to connection optimization
+			///     </remarks>
+			/// </summary>
+			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+
+			/// <summary>
+			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+			///     id: string : operation id
+			/// </summary>
+			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+
+			/// <summary>
+			///     Client sends this message to execute GraphQL operation
+			///     id: string : The id of the GraphQL operation to start
+			///     payload: Object:
+			///     query: string : GraphQL operation as string or parsed GraphQL document node
+			///     variables?: Object : Object with GraphQL variables
+			///     operationName?: string : GraphQL operation name
+			/// </summary>
+			public const string GQL_START = "start";
+
+			/// <summary>
+			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+			///     is a response for GQL_START message.
+			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+			///     id: string : ID of the operation that was successfully set up
+			///     payload: Object :
+			///     data: any: Execution result
+			///     errors?: Error[] : Array of resolvers errors
+			/// </summary>
+			public const string GQL_DATA = "data"; // Server -> Client
+
+			/// <summary>
+			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+			///     payload: Error : payload with the error attributed to the operation failing on the server
+			///     id: string : operation ID of the operation that failed on the server
+			/// </summary>
+			public const string GQL_ERROR = "error"; // Server -> Client
+
+			/// <summary>
+			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+			///     specific operation.
+			///     id: string : operation ID of the operation that completed
+			/// </summary>
+			public const string GQL_COMPLETE = "complete"; // Server -> Client
+
+			/// <summary>
+			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+			///     id: string : operation id
+			/// </summary>
+			public const string GQL_STOP = "stop"; // Client -> Server
+		}
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
index c916f82e..e0c2dc6d 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
@@ -39,9 +39,11 @@ public async void StartAsync(CancellationToken cancellationToken = default) {
 					var webSocketReceiveResult = await this.clientWebSocket.ReceiveAsync(arraySegment, cancellationToken);
 					var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
 					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
-					if (webSocketResponse != null) {
-						this.LastResponse = webSocketResponse.Payload;
-						this.OnReceive?.Invoke(webSocketResponse.Payload);
+					if (webSocketResponse != null)
+					{
+						var response = (GraphQLResponse) webSocketResponse.Payload;
+						this.LastResponse = response;
+						this.OnReceive?.Invoke(response);
 					}
 				}
 			}
diff --git a/src/GraphQL.Client/Http/HttpClientExtensions.cs b/src/GraphQL.Client/Http/HttpClientExtensions.cs
index c0fb4b49..1d7ca0e4 100644
--- a/src/GraphQL.Client/Http/HttpClientExtensions.cs
+++ b/src/GraphQL.Client/Http/HttpClientExtensions.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Net.Http;
 
 namespace GraphQL.Client.Http {
@@ -16,6 +17,15 @@ public static class HttpClientExtensions {
 		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
 			new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
 
+		/// <summary>
+		/// Creates a <see cref="GraphQLHttpClient"/> from a <see cref="HttpClient"/>
+		/// </summary>
+		/// <param name="httpClient"></param>
+		/// <param name="endPoint"></param>
+		/// <returns></returns>
+		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
+			new GraphQLHttpClient(new GraphQLHttpClientOptions { EndPoint = endPoint }, httpClient);
+
 	}
 
 }
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 108762f7..3343da14 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -36,6 +36,8 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
 	}
 
 }
diff --git a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs b/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
index 3ba69331..71c47c72 100644
--- a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
+++ b/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
@@ -22,7 +22,7 @@ public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionRespons
 		/// <summary>
 		/// The Payload of the Response
 		/// </summary>
-		public GraphQLResponse Payload { get; set; }
+		public dynamic Payload { get; set; }
 
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionResponse);
diff --git a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
index e8584d6d..cef55529 100644
--- a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
+++ b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../tests.props" />
 
 	<PropertyGroup>
-		<TargetFrameworks>netcoreapp1.0;netcoreapp1.1;netcoreapp2.0;netcoreapp2.1</TargetFrameworks>
+		<TargetFrameworks>netcoreapp2.0;netcoreapp2.1</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
new file mode 100644
index 00000000..5fc195bc
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.5" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="2.1.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
+    <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
new file mode 100644
index 00000000..e8b4babf
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class GraphQLClientExtensions
+	{
+		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
+		{
+			var graphQLRequest = new GraphQLRequest
+			{
+				Query = @"
+				mutation($input: MessageInputType){
+				  addMessage(message: $input){
+				    content
+				  }
+				}",
+				Variables = new
+				{
+					input = new
+					{
+						fromId = "me",
+						content = message,
+						sentAt = DateTime.Now
+					}
+				}
+			};
+			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
new file mode 100644
index 00000000..e7993a36
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+	public class ObservableTester<T> : IDisposable
+	{
+		private readonly IDisposable _subscription;
+		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
+		private ManualResetEventSlim _completed { get; } = new ManualResetEventSlim();
+		private ManualResetEventSlim _error { get; } = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool UpdateReceived => _updateReceived.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		public Exception Error { get; private set; }
+
+		/// <summary>
+		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
+		/// </summary>
+		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
+		public ObservableTester(IObservable<T> observable)
+		{
+			_subscription = observable.Subscribe(
+				obj => {
+					LastPayload = obj;
+					_updateReceived.Set();
+				},
+				ex =>
+				{
+					Error = ex;
+					_error.Set();
+				},
+				() => _completed.Set()
+			);
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
+		{
+			try
+			{
+				if (!_updateReceived.Wait(Timeout))
+					Assert.True(false, "no update received!");
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
+		{
+			try
+			{
+				if (_updateReceived.Wait(100))
+					Assert.True(false, "update was inadvertently pushed!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		public void ShouldHaveCompleted()
+		{
+			try
+			{
+				if (!_completed.Wait(Timeout))
+					Assert.True(false, "subscription did not complete!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		public void ShouldHaveThrownError(Action<Exception> assertError = null)
+		{
+			try
+			{
+				if (!_error.Wait(Timeout))
+					Assert.True(false, "subscription did not throw an error!");
+
+				assertError?.Invoke(Error);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset()
+		{
+			if (_completed.IsSet)
+				throw new InvalidOperationException(
+					"the subscription sequence has completed. this tester instance cannot be reused");
+
+			LastPayload = default(T);
+			_updateReceived.Reset();
+		}
+
+		/// <inheritdoc />
+		public void Dispose()
+		{
+			_subscription?.Dispose();
+		}
+	}
+
+	public static class ObservableExtensions
+	{
+		public static ObservableTester<T> SubscribeTester<T>(this IObservable<T> observable)
+		{
+			return new ObservableTester<T>(observable);
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/Properties/launchSettings.json b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
new file mode 100644
index 00000000..f8fea71b
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
@@ -0,0 +1,27 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:51432/",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "GraphQL.Integration.Tests": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:51433/"
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
new file mode 100644
index 00000000..f8a66760
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+
+namespace GraphQL.Integration.Tests
+{
+	public class SubscriptionsTest
+	{
+		public static IWebHost CreateServer(int port)
+		{
+			var configBuilder = new ConfigurationBuilder();
+			configBuilder.AddInMemoryCollection();
+			var config = configBuilder.Build();
+			config["server.urls"] = $"http://localhost:{port}";
+
+			var host = new WebHostBuilder()
+				.ConfigureLogging((ctx, logging) => logging.AddDebug())
+				.UseConfiguration(config)
+				.UseKestrel()
+				.UseStartup<IntegrationTestServer.Startup>()
+				.Build();
+
+			host.Start();
+
+			return host;
+		}
+
+		private readonly IWebHost _server;
+
+		public SubscriptionsTest()
+		{}
+
+		private GraphQLHttpClient GetGraphQLClient(int port)
+			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
+
+
+		[Fact]
+		public async void AssertTestingHarness()
+		{
+			var port = 5001;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				const string message = "some random testing message";
+				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
+
+				Assert.Equal(message, (string)response.Data.addMessage.content);
+			}
+		}
+
+		[Fact]
+		public async void CanCreateObservableSubscription()
+		{
+			var port = 5002;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+				var graphQLRequest = new GraphQLRequest
+				{
+					Query = @"
+					subscription {
+					  messageAdded{
+					    content
+					  }
+					}"
+				};
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				const string message1 = "Hello World";
+
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string) response.Data.addMessage.content);
+
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				tester.Reset();
+
+				const string message2 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				tester.Reset();
+
+				// disposing the client should throw a TaskCanceledException on the subscription
+				client.Dispose();
+				tester.ShouldHaveThrownError(exception =>
+				{
+					Assert.True(exception is TaskCanceledException,
+							$"exception is of unexpected type {exception.GetType().Name}");
+				});
+			}
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
new file mode 100644
index 00000000..32b32e61
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -0,0 +1,19 @@
+using System;
+using GraphQL.Client.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class WebApplicationFactoryExtensions
+	{
+		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
+			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint: class
+		{
+			var httpClient = factory.CreateClient();
+			var uriBuilder = new UriBuilder(httpClient.BaseAddress);
+			uriBuilder.Path = graphQlSchemaUrl;
+			uriBuilder.Scheme = urlScheme;
+			return httpClient.AsGraphQLClient(uriBuilder.Uri);
+		}
+	}
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
new file mode 100644
index 00000000..7c2a2333
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -0,0 +1,31 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatMutation : ObjectGraphType<object>
+    {
+        public ChatMutation(IChat chat)
+        {
+            Field<MessageType>("addMessage",
+                arguments: new QueryArguments(
+                    new QueryArgument<MessageInputType> {Name = "message"}
+                ),
+                resolve: context =>
+                {
+                    var receivedMessage = context.GetArgument<ReceivedMessage>("message");
+                    var message = chat.AddMessage(receivedMessage);
+                    return message;
+                });
+        }
+    }
+
+    public class MessageInputType : InputObjectGraphType
+    {
+        public MessageInputType()
+        {
+            Field<StringGraphType>("fromId");
+            Field<StringGraphType>("content");
+            Field<DateGraphType>("sentAt");
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
new file mode 100644
index 00000000..579c364f
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
@@ -0,0 +1,13 @@
+using System.Linq;
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatQuery : ObjectGraphType
+    {
+        public ChatQuery(IChat chat)
+        {
+            Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
new file mode 100644
index 00000000..904623a2
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
@@ -0,0 +1,14 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatSchema : Schema
+    {
+        public ChatSchema(IChat chat) 
+        {
+            Query = new ChatQuery(chat);
+            Mutation = new ChatMutation(chat);
+            Subscription = new ChatSubscriptions(chat);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
new file mode 100644
index 00000000..3c8c9624
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Security.Claims;
+using GraphQL;
+using GraphQL.Resolvers;
+using GraphQL.Server.Transports.Subscriptions.Abstractions;
+using GraphQL.Subscription;
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatSubscriptions : ObjectGraphType<object>
+    {
+        private readonly IChat _chat;
+
+        public ChatSubscriptions(IChat chat)
+        {
+            _chat = chat;
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAdded",
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(Subscribe)
+            });
+
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAddedByUser",
+                Arguments = new QueryArguments(
+                    new QueryArgument<NonNullGraphType<StringGraphType>> {Name = "id"}
+                ),
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(SubscribeById)
+            });
+        }
+
+        private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            var messages = _chat.Messages(sub);
+
+            var id = context.GetArgument<string>("id");
+            return messages.Where(message => message.From.Id == id);
+        }
+
+        private Message ResolveMessage(ResolveFieldContext context)
+        {
+            var message = context.Source as Message;
+
+            return message;
+        }
+
+        private IObservable<Message> Subscribe(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            return _chat.Messages(sub);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
new file mode 100644
index 00000000..68c8e86b
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Concurrent;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public interface IChat
+    {
+        ConcurrentStack<Message> AllMessages { get; }
+
+        Message AddMessage(Message message);
+
+        IObservable<Message> Messages(string user);
+
+        Message AddMessage(ReceivedMessage message);
+    }
+
+    public class Chat : IChat
+    {
+        private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+
+        public Chat()
+        {
+            AllMessages = new ConcurrentStack<Message>();
+            Users = new ConcurrentDictionary<string, string>
+            {
+                ["1"] = "developer",
+                ["2"] = "tester"
+            };
+        }
+
+        public ConcurrentDictionary<string, string> Users { get; set; }
+
+        public ConcurrentStack<Message> AllMessages { get; }
+
+        public Message AddMessage(ReceivedMessage message)
+        {
+            if (!Users.TryGetValue(message.FromId, out var displayName))
+            {
+                displayName = "(unknown)";
+            }
+
+            return AddMessage(new Message
+            {
+                Content = message.Content,
+                SentAt = message.SentAt,
+                From = new MessageFrom
+                {
+                    DisplayName = displayName,
+                    Id = message.FromId
+                }
+            });
+        }
+
+        public Message AddMessage(Message message)
+        {
+            AllMessages.Push(message);
+            _messageStream.OnNext(message);
+            return message;
+        }
+
+        public IObservable<Message> Messages(string user)
+        {
+            return _messageStream
+                .Select(message =>
+                {
+                    message.Sub = user;
+                    return message;
+                })
+                .AsObservable();
+        }
+
+        public void AddError(Exception exception)
+        {
+            _messageStream.OnError(exception);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/Message.cs b/tests/IntegrationTestServer/ChatSchema/Message.cs
new file mode 100644
index 00000000..f3b90cb1
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/Message.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class Message
+    {
+        public MessageFrom From { get; set; }
+
+        public string Sub { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime SentAt { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
new file mode 100644
index 00000000..5346cb6b
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
@@ -0,0 +1,9 @@
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageFrom
+    {
+        public string Id { get; set; }
+
+        public string DisplayName { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
new file mode 100644
index 00000000..98830475
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
@@ -0,0 +1,13 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageFromType : ObjectGraphType<MessageFrom>
+    {
+        public MessageFromType()
+        {
+            Field(o => o.Id);
+            Field(o => o.DisplayName);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageType.cs b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
new file mode 100644
index 00000000..320f5b55
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
@@ -0,0 +1,21 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageType : ObjectGraphType<Message>
+    {
+        public MessageType()
+        {
+            Field(o => o.Content);
+            Field(o => o.SentAt);
+            Field(o => o.Sub);
+            Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
+        }
+
+        private MessageFrom ResolveFrom(ResolveFieldContext<Message> context)
+        {
+            var message = context.Source;
+            return message.From;
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
new file mode 100644
index 00000000..0f1a409a
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ReceivedMessage
+    {
+        public string FromId { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime SentAt { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
new file mode 100644
index 00000000..179554ff
--- /dev/null
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.2.0" />
+    <PackageReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
new file mode 100644
index 00000000..fd8448a8
--- /dev/null
+++ b/tests/IntegrationTestServer/Program.cs
@@ -0,0 +1,17 @@
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+
+namespace IntegrationTestServer
+{
+	public class Program
+	{
+		public static void Main(string[] args)
+		{
+			CreateWebHostBuilder(args).Build().Run();
+		}
+
+		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+			WebHost.CreateDefaultBuilder(args)
+				.UseStartup<Startup>();
+	}
+}
diff --git a/tests/IntegrationTestServer/Properties/launchSettings.json b/tests/IntegrationTestServer/Properties/launchSettings.json
new file mode 100644
index 00000000..cd6aedd6
--- /dev/null
+++ b/tests/IntegrationTestServer/Properties/launchSettings.json
@@ -0,0 +1,28 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:55069/ui/graphiql/",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IntegrationTestServer": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "ui/graphiql",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:5005/"
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
new file mode 100644
index 00000000..0161c739
--- /dev/null
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -0,0 +1,69 @@
+using GraphQL.Server;
+using GraphQL.Server.Ui.GraphiQL;
+using GraphQL.Server.Ui.Voyager;
+using IntegrationTestServer.ChatSchema;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace IntegrationTestServer
+{
+	public class Startup
+	{
+		public Startup(IConfiguration configuration, IHostingEnvironment environment)
+		{
+			Configuration = configuration;
+			Environment = environment;
+		}
+
+		public IConfiguration Configuration { get; }
+		public IHostingEnvironment Environment { get; }
+
+		// This method gets called by the runtime. Use this method to add services to the container.
+		// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+		public void ConfigureServices(IServiceCollection services)
+		{
+			services.AddSingleton<IChat, Chat>();
+			services.AddSingleton<ChatSchema.ChatSchema>();
+			services.AddSingleton<ChatQuery>();
+			services.AddSingleton<ChatMutation>();
+			services.AddSingleton<ChatSubscriptions>();
+			services.AddSingleton<MessageType>();
+			services.AddSingleton<MessageInputType>();
+
+			services.AddGraphQL(options =>
+				{
+					options.EnableMetrics = true;
+					options.ExposeExceptions = Environment.IsDevelopment();
+				})
+				.AddWebSockets();
+
+			services.AddMvc();
+		}
+
+		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+		public void Configure(IApplicationBuilder app, IHostingEnvironment env)
+		{
+			if (env.IsDevelopment())
+			{
+				app.UseDeveloperExceptionPage();
+			}
+
+			app.UseWebSockets();
+			app.UseGraphQLWebSockets<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphQL<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphiQLServer(new GraphiQLOptions
+			{
+				GraphiQLPath = "/ui/graphiql",
+				GraphQLEndPoint = "/graphql"
+			});
+			app.UseGraphQLVoyager(new GraphQLVoyagerOptions()
+			{
+				GraphQLEndPoint = "/graphql",
+				Path = "/ui/voyager"
+			});
+			app.UseMvc();
+		}
+	}
+}

From 546b304efee3e0b1eabeb5267319921f157d2580 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 08:42:53 +0100
Subject: [PATCH 002/455] add StringEnumConverter to JsonSerializerSettings

---
 src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 9ff6b091..73a00430 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.Http {
@@ -20,7 +22,11 @@ public class GraphQLHttpClientOptions {
 		/// The <see cref="Newtonsoft.Json.JsonSerializerSettings"/> that is going to be used
 		/// </summary>
 		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver()
+			ContractResolver = new CamelCasePropertyNamesContractResolver(),
+			Converters = new List<JsonConverter>
+			{
+				new StringEnumConverter()
+			}
 		};
 
 		/// <summary>

From a8cff74aa083e663c50fc83999c06f6ad33f0ecf Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 09:40:24 +0100
Subject: [PATCH 003/455] fix dependencies

---
 src/GraphQL.Client/GraphQL.Client.csproj     | 6 ++++++
 src/GraphQL.Client/Http/GraphQLHttpClient.cs | 1 -
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 200758df..97a78f0e 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -17,6 +17,12 @@
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <Reference Include="System.Reactive">
+	    <HintPath>C:\Users\arose\.nuget\packages\system.reactive\4.1.2\lib\netstandard2.0\System.Reactive.dll</HintPath>
+	  </Reference>
+	</ItemGroup>
+
 	<!-- Allow method ReadAsAsync<T>
 	<ItemGroup>
 		<PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.4" />
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index fe8f4710..cfc966b7 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;

From e3a2154b3d318e1d275698d69d56f6e911af8846 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 09:43:34 +0100
Subject: [PATCH 004/455] change version

---
 root.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/root.props b/root.props
index e2fc2d0c..88283610 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.3</Version>
+		<Version>2.0.0-subscriptions-api.4</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 

From eca5d24b40a9017b7ad3aa6c97e637220b904fff Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 29 Nov 2018 09:47:49 +0100
Subject: [PATCH 005/455] fix version

---
 root.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 88283610..32db78cf 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-subscriptions-api.4</Version>
+		<Version>2.0.0-alpha.subscriptions-api.4</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 

From 29113452fa0092078171793d2a402b21448fc4cb Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 3 Dec 2018 17:59:59 +0100
Subject: [PATCH 006/455] fix CloseAsync

---
 .../Http/GraphQLHttpObservableSubscription.cs | 10 ++-
 .../ObservableTester.cs                       | 26 +++----
 .../SubscriptionsTest.cs                      | 69 ++++++++++++++-----
 3 files changed, 73 insertions(+), 32 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index d3f71990..fa77239c 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -67,6 +67,12 @@ public async Task<GraphQLResponse> ReceiveResultAsync()
 
 		public async Task CloseAsync(CancellationToken cancellationToken = default)
 		{
+			// don't attempt to close the websocket if it is in a failed state
+			if (this.clientWebSocket.State != WebSocketState.Open &&
+			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
+			    this.clientWebSocket.State != WebSocketState.CloseSent)
+				return;
+
 			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
 			if (this.clientWebSocket.State == WebSocketState.Open) {
 				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
@@ -135,7 +141,9 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUr
 			return Observable.Using(
 				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
 				InitializeSubscription
-				).Publish().RefCount();
+				)
+				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
+				.Publish().RefCount();
 		}
 
 
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index e7993a36..7bcf8522 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -20,7 +20,7 @@ public class ObservableTester<T> : IDisposable
 		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
 		/// <summary>
-		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// Indicates that an update has been received since the last <see cref="_reset"/>
 		/// </summary>
 		public bool UpdateReceived => _updateReceived.IsSet;
 		/// <summary>
@@ -51,7 +51,7 @@ public ObservableTester(IObservable<T> observable)
 		}
 
 		/// <summary>
-		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>.
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
@@ -66,12 +66,12 @@ public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
 		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
@@ -83,12 +83,12 @@ public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		public void ShouldHaveCompleted()
 		{
@@ -99,12 +99,12 @@ public void ShouldHaveCompleted()
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		public void ShouldHaveThrownError(Action<Exception> assertError = null)
 		{
@@ -117,18 +117,18 @@ public void ShouldHaveThrownError(Action<Exception> assertError = null)
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
-		public void Reset()
+		private void _reset()
 		{
-			if (_completed.IsSet)
-				throw new InvalidOperationException(
-					"the subscription sequence has completed. this tester instance cannot be reused");
+			//if (_completed.IsSet)
+			//	throw new InvalidOperationException(
+			//		"the subscription sequence has completed. this tester instance cannot be reused");
 
 			LastPayload = default(T);
 			_updateReceived.Reset();
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index f8a66760..3b404f23 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -57,6 +57,17 @@ public async void AssertTestingHarness()
 			}
 		}
 
+		private const string SubscriptionQuery = @"
+			subscription {
+			  messageAdded{
+			    content
+			  }
+			}";
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
+		{
+			Query = SubscriptionQuery
+		};
+
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
@@ -64,18 +75,8 @@ public async void CanCreateObservableSubscription()
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
-				var graphQLRequest = new GraphQLRequest
-				{
-					Query = @"
-					subscription {
-					  messageAdded{
-					    content
-					  }
-					}"
-				};
-
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -89,8 +90,6 @@ public async void CanCreateObservableSubscription()
 					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				tester.Reset();
-
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
 				Assert.Equal(message2, (string)response.Data.addMessage.content);
@@ -99,15 +98,49 @@ public async void CanCreateObservableSubscription()
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				tester.Reset();
-
 				// disposing the client should throw a TaskCanceledException on the subscription
 				client.Dispose();
-				tester.ShouldHaveThrownError(exception =>
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		[Fact]
+		public async void CanReconnectWithSameObservable()
+		{
+			var port = 5003;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				const string message1 = "Hello World";
+
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
+
+				Debug.WriteLine("creating new subscription...");
+				tester = observable.SubscribeTester();
+				const string message2 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.True(exception is TaskCanceledException,
-							$"exception is of unexpected type {exception.GetType().Name}");
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
 			}
 		}
 	}

From af78196058c8511aaa3617fecee80e7e5069a378 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 3 Dec 2018 18:01:01 +0100
Subject: [PATCH 007/455] lock dispose

---
 .../Http/GraphQLHttpObservableSubscription.cs          | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index fa77239c..04adb611 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -112,15 +112,17 @@ private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSu
 		}
 
 		#region IDisposable
-
+		public Task Disposed { get; private set; }
+		private object _disposedLocker = new object();
 		public void Dispose()
 		{
 			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			if(Disposed == null) Disposed = DisposeAsync();
+			lock (_disposedLocker)
+			{
+				if (Disposed == null) Disposed = DisposeAsync();
+			}
 		}
 
-		public Task Disposed { get; private set; }
-
 		private async Task DisposeAsync()
 		{
 			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");

From 43cb3ddb04a63f2c117e7dec7553f9a966f686bf Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 09:36:46 +0100
Subject: [PATCH 008/455] implement external exception handling for
 subscription streams

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 23 ++++++++
 .../Http/GraphQLHttpObservableSubscription.cs | 53 ++++++++++++++++---
 src/GraphQL.Client/IGraphQLClient.cs          | 34 ++++++++++++
 3 files changed, 104 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index cfc966b7..4de48c2f 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -140,6 +141,7 @@ private Uri _getWebSocketUri()
 			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
 		}
 
+		/// <inheritdoc />
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
@@ -147,6 +149,27 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			return observable;
 		}
 
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		{
+			return CreateSubscriptionStream(request, e =>
+			{
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		{
+			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token, exceptionHandler);
+			return observable;
+		}
+
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 04adb611..f742b698 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -138,17 +138,58 @@ private async Task DisposeAsync()
 
 		#region Static Factories
 
-		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
+		public static IObservable<GraphQLResponse> GetSubscriptionStream(
+			Uri webSocketUri,
+			GraphQLRequest graphQLRequest,
+			CancellationToken cancellationToken = default,
+			Action<Exception> onException = null)
 		{
-			return Observable.Using(
-				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-				InitializeSubscription
-				)
+			return Observable
+				// create deferred observable using a GraphQLHttpObservableSubscription instance
+				.Defer(
+					() =>
+						Observable.Using(
+							token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
+							InitializeSubscription
+				))
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// if the external handler is not set, propagate all exceptions (default behaviour without Retry())
+						if (onException == null) throw e;
+
+						// invoke external handler
+						// exceptions thrown by the handler will propagate to OnError()
+						onException(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return cancellationToken.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the subscription stream for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+					t.Item2 == null
+						? Observable.Return(t.Item1)
+						: Observable.Throw<GraphQLResponse>(t.Item2))
+				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
 
-
 		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
 		{
 			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 3343da14..60af36ab 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Common.Request;
@@ -36,8 +37,41 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// The stream must be recreated completely after an error has occured within its logic (i.e. a <see cref="WebSocketException"/>)
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }

From f1deb7f01a0347c01e5886c0f81e4ce71034608b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 09:40:42 +0100
Subject: [PATCH 009/455] fix doc comment

---
 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index f742b698..77397fb8 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -161,7 +161,7 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(
 				{
 					try
 					{
-						// if the external handler is not set, propagate all exceptions (default behaviour without Retry())
+						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
 						if (onException == null) throw e;
 
 						// invoke external handler

From 1a28d69b640cfa7c11ed4ec0741bbf5563259572 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 10:37:08 +0100
Subject: [PATCH 010/455] add back-off delay for automatic reconnects

---
 root.props                                    |  2 +-
 .../Http/GraphQLHttpObservableSubscription.cs | 35 +++++++++++++++----
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/root.props b/root.props
index 32db78cf..d6d65e56 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.4</Version>
+		<Version>2.0.0-alpha.subscriptions-api.6</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 77397fb8..70b307fd 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -144,14 +144,21 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(
 			CancellationToken cancellationToken = default,
 			Action<Exception> onException = null)
 		{
+			int reconnectionAttempt = 0;
+
 			return Observable
 				// create deferred observable using a GraphQLHttpObservableSubscription instance
 				.Defer(
 					() =>
-						Observable.Using(
+					{
+						var observable = Observable.Using(
 							token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-							InitializeSubscription
-				))
+							InitializeSubscription);
+
+						// when reconnecting, apply the delay computed by the BackOffStrategy
+						return (++reconnectionAttempt == 1) ? observable : observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1)) ;
+					}
+				)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
 				// wrap results
@@ -183,13 +190,29 @@ public static IObservable<GraphQLResponse> GetSubscriptionStream(
 				.Retry()
 				// unwrap and push results or throw wrapped exceptions
 				.SelectMany(t =>
-					t.Item2 == null
-						? Observable.Return(t.Item1)
-						: Observable.Throw<GraphQLResponse>(t.Item2))
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLResponse>(t.Item2);
+
+					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
+					reconnectionAttempt = 1;
+					return Observable.Return(t.Item1);
+				})
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
 
+		/// <summary>
+		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public static Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
+
 		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
 		{
 			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);

From 7b19ab57a3dd0d218c6d759959357e14574a32a5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 15:16:28 +0100
Subject: [PATCH 011/455] create GraphQLHttpWebSocket class

---
 root.props                                    |   2 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |   4 +
 .../Http/GraphQLHttpObservableSubscription.cs |  98 +--------
 .../Http/GraphQLHttpSubscriptionResult.cs     |  98 +--------
 .../Http/GraphQLHttpWebSocket.cs              | 192 ++++++++++++++++++
 src/GraphQL.Common/GQLWebSocketMessageType.cs |  93 +++++++++
 ...nRequest.cs => GraphQLWebSocketRequest.cs} |  10 +-
 ...esponse.cs => GraphQLWebSocketResponse.cs} |  10 +-
 8 files changed, 313 insertions(+), 194 deletions(-)
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
 create mode 100644 src/GraphQL.Common/GQLWebSocketMessageType.cs
 rename src/GraphQL.Common/Request/{GraphQLSubscriptionRequest.cs => GraphQLWebSocketRequest.cs} (73%)
 rename src/GraphQL.Common/Response/{GraphQLSubscriptionResponse.cs => GraphQLWebSocketResponse.cs} (72%)

diff --git a/root.props b/root.props
index d6d65e56..20595010 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.6</Version>
+		<Version>2.0.0-alpha.subscriptions-api.7</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 4de48c2f..fb1982fb 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -41,6 +41,7 @@ public GraphQLHttpClientOptions Options {
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
+		internal readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		/// <summary>
@@ -76,6 +77,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
 		}
 
 		/// <summary>
@@ -90,6 +92,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -100,6 +103,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 70b307fd..d4d5678a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -7,6 +7,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
@@ -33,6 +34,7 @@ private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graph
 			this.webSocketUri = webSocketUri;
 			this.graphQLRequest = graphQLRequest;
 			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
 			arraySegment = new ArraySegment<byte>(buffer);
 		}
 
@@ -47,7 +49,7 @@ public async Task<GraphQLResponse> ReceiveResultAsync()
 		{
 			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
 			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 			switch (webSocketResponse.Type)
 			{
 				case GQLWebSocketMessageType.GQL_COMPLETE:
@@ -83,7 +85,7 @@ public async Task CloseAsync(CancellationToken cancellationToken = default)
 		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
 		{
 			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
+			var webSocketRequest = new GraphQLWebSocketRequest
 			{
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_START,
@@ -95,7 +97,7 @@ private Task SendInitialMessageAsync(CancellationToken cancellationToken = defau
 		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
 		{
 			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
+			var webSocketRequest = new GraphQLWebSocketRequest
 			{
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_STOP,
@@ -104,9 +106,9 @@ private Task SendCloseMessageAsync(CancellationToken cancellationToken = default
 			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
 		}
 
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default)
+		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default)
 		{
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
 		}
@@ -252,91 +254,5 @@ protected GQLSubscriptionException(
 			{
 			}
 		}
-
-		public static class GQLWebSocketMessageType
-		{
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-		}
 	}
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
index e0c2dc6d..34ab6f0a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
@@ -3,6 +3,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
@@ -38,7 +39,7 @@ public async void StartAsync(CancellationToken cancellationToken = default) {
 				while (this.clientWebSocket.State == WebSocketState.Open) {
 					var webSocketReceiveResult = await this.clientWebSocket.ReceiveAsync(arraySegment, cancellationToken);
 					var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 					if (webSocketResponse != null)
 					{
 						var response = (GraphQLResponse) webSocketResponse.Payload;
@@ -62,7 +63,7 @@ public void Dispose() {
 		}
 
 		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_START,
 				Payload = this.graphQLRequest
@@ -71,7 +72,7 @@ private Task SendInitialMessageAsync(CancellationToken cancellationToken = defau
 		}
 
 		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_STOP,
 				Payload = this.graphQLRequest
@@ -79,98 +80,11 @@ private Task SendCloseMessageAsync(CancellationToken cancellationToken = default
 			return this.SendGraphQLSubscriptionRequest(webSocketRequest);
 		}
 
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default) {
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default) {
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
 		}
-
-		private static class GQLWebSocketMessageType {
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-
-		}
-
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
new file mode 100644
index 00000000..b307487b
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -0,0 +1,192 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Reactive.Threading.Tasks;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http
+{
+	internal class GraphQLHttpWebSocket: IDisposable
+	{
+		private readonly Uri webSocketUri;
+		private readonly byte[] buffer = new byte[1024 * 1024];
+		private readonly ArraySegment<byte> arraySegment;
+		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+
+		private ClientWebSocket clientWebSocket = null;
+
+		public GraphQLHttpWebSocket(Uri webSocketUri)
+		{
+			this.webSocketUri = webSocketUri;
+			arraySegment = new ArraySegment<byte>(buffer);
+		}
+
+		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			if (clientWebSocket == null)
+			{
+				throw new InvalidOperationException("websocket not connected! subscribe to the response stream before sending a request!");
+			}
+			var webSocketRequestString = JsonConvert.SerializeObject(request);
+			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
+		}
+
+		public IObservable<GraphQLWebSocketResponse> ResponseStream
+		{
+			get
+			{
+				int reconnectionAttempt = 0;
+
+				return Observable
+					// create deferred observable using a GraphQLHttpObservableSubscription instance
+					.Defer(
+						() =>
+						{
+							var observable = Observable.Using(
+								token => _createClientWebsocket(),
+								(_, cancellationToken) => _initializeWebSocketConnection(cancellationToken));
+
+							// when reconnecting, apply the delay computed by the BackOffStrategy
+							return (++reconnectionAttempt == 1)
+								? observable
+								: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
+						}
+					)
+					// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+					.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+						Observable.Empty<GraphQLWebSocketResponse>())
+					// wrap results
+					.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
+					// do exception handling
+					.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
+					{
+						try
+						{
+							// exceptions thrown by the handler will propagate to OnError()
+							_handleExceptions(e);
+
+							// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+							return _cancellationTokenSource.Token.IsCancellationRequested
+								? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
+								: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
+						}
+						catch (Exception exception)
+						{
+							// wrap all other exceptions to be propagated behind retry
+							return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
+						}
+					})
+					// attempt to recreate the subscription stream for rethrown exceptions
+					.Retry()
+					// unwrap and push results or throw wrapped exceptions
+					.SelectMany(t =>
+					{
+						// if the result contains an exception, throw it on the observable
+						if (t.Item2 != null)
+							return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
+
+						// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
+						reconnectionAttempt = 1;
+						return Observable.Return(t.Item1);
+					})
+					// transform to hot observable and auto-connect
+					.Publish().RefCount();
+			}
+		}
+
+		/// <summary>
+		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public static Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
+
+		#region Private Methods
+
+		private void _handleExceptions(Exception e)
+		{
+
+		}
+
+		private Task<IDisposable> _createClientWebsocket()
+		{
+			clientWebSocket = new ClientWebSocket();
+			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
+			return Task.FromResult(Disposable.Create(() => clientWebSocket?.Dispose()));
+		}
+
+		private async Task<IObservable<GraphQLWebSocketResponse>> _initializeWebSocketConnection(CancellationToken cancelToken)
+		{
+			await _connectAsync(cancelToken).ConfigureAwait(false);
+			return Observable.Defer(() => _receiveResultAsync().ToObservable()).Repeat();
+		}
+
+		private async Task _connectAsync(CancellationToken token)
+		{
+			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
+			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
+		}
+
+		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
+		{
+			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
+			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+			return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+		}
+
+		private async Task _closeAsync(CancellationToken cancellationToken = default)
+		{
+			// don't attempt to close the websocket if it is in a failed state
+			if (this.clientWebSocket.State != WebSocketState.Open &&
+			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
+			    this.clientWebSocket.State != WebSocketState.CloseSent)
+				return;
+
+			Debug.WriteLine($"closing websocket {this.GetHashCode()}");
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+		}
+
+		#endregion
+
+		#region IDisposable
+
+		private Task Disposed { get; set; }
+		private object _disposedLocker = new object();
+		public void Dispose()
+		{
+			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+			lock (_disposedLocker)
+			{
+				if (Disposed == null) Disposed = DisposeAsync();
+			}
+		}
+
+		private async Task DisposeAsync()
+		{
+			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
+			if (!_cancellationTokenSource.IsCancellationRequested)
+				_cancellationTokenSource.Cancel();
+			await _closeAsync().ConfigureAwait(false);
+			clientWebSocket?.Dispose();
+			_cancellationTokenSource.Dispose();
+			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
+		}
+		#endregion
+	}
+}
diff --git a/src/GraphQL.Common/GQLWebSocketMessageType.cs b/src/GraphQL.Common/GQLWebSocketMessageType.cs
new file mode 100644
index 00000000..1e2fff76
--- /dev/null
+++ b/src/GraphQL.Common/GQLWebSocketMessageType.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Common
+{
+	public static class GQLWebSocketMessageType
+	{
+
+		/// <summary>
+		///     Client sends this message after plain websocket connection to start the communication with the server
+		///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+		///     to this message.
+		///     payload: Object : optional parameters that the client specifies in connectionParams
+		/// </summary>
+		public const string GQL_CONNECTION_INIT = "connection_init";
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+		///     the connection.
+		/// </summary>
+		public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+		///     the connection.
+		///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+		///     client, just ignore the message).
+		///     payload: Object: the server side error
+		/// </summary>
+		public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+
+		/// <summary>
+		///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+		///     client connection alive.
+		///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+		///     server.
+		///     <remarks>
+		///         NOTE: This one here don't follow the standard due to connection optimization
+		///     </remarks>
+		/// </summary>
+		public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+
+		/// <summary>
+		///     Client sends this message to execute GraphQL operation
+		///     id: string : The id of the GraphQL operation to start
+		///     payload: Object:
+		///     query: string : GraphQL operation as string or parsed GraphQL document node
+		///     variables?: Object : Object with GraphQL variables
+		///     operationName?: string : GraphQL operation name
+		/// </summary>
+		public const string GQL_START = "start";
+
+		/// <summary>
+		///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+		///     is a response for GQL_START message.
+		///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+		///     id: string : ID of the operation that was successfully set up
+		///     payload: Object :
+		///     data: any: Execution result
+		///     errors?: Error[] : Array of resolvers errors
+		/// </summary>
+		public const string GQL_DATA = "data"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+		///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+		///     payload: Error : payload with the error attributed to the operation failing on the server
+		///     id: string : operation ID of the operation that failed on the server
+		/// </summary>
+		public const string GQL_ERROR = "error"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+		///     specific operation.
+		///     id: string : operation ID of the operation that completed
+		/// </summary>
+		public const string GQL_COMPLETE = "complete"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_STOP = "stop"; // Client -> Server
+
+	}
+}
diff --git a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
similarity index 73%
rename from src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
rename to src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index a468a0b3..46e14dce 100644
--- a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Request {
 	/// A Subscription Request
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest> {
+	public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest>
 		public GraphQLRequest Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionRequest);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionRequest other) {
+		public bool Equals(GraphQLWebSocketRequest other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => EqualityComparer<GraphQLSubscriptionRequest>.Default.Equals(request1, request2);
+		public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => !(request1 == request2);
+		public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
 
 	}
 
diff --git a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
similarity index 72%
rename from src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
rename to src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
index 71c47c72..cd3fb2f4 100644
--- a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
+++ b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Response {
 	/// A Subscription Response
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionResponse> {
+	public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionRespons
 		public dynamic Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionResponse);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionResponse other) {
+		public bool Equals(GraphQLWebSocketResponse other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => EqualityComparer<GraphQLSubscriptionResponse>.Default.Equals(response1, response2);
+		public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => !(response1 == response2);
+		public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => !(response1 == response2);
 
 	}
 

From ad2c31f9ba1adcde35a10c87c345eaa6d4b2e8a9 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Dec 2018 18:19:40 +0100
Subject: [PATCH 012/455] get single socket working

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  43 ++--
 .../Http/GraphQLHttpObservableSubscription.cs | 112 +++++-----
 .../Http/GraphQLHttpWebSocket.cs              | 194 ++++++++++--------
 src/GraphQL.Client/IGraphQLClient.cs          |  48 ++---
 .../ObservableTester.cs                       |  23 ++-
 .../SubscriptionsTest.cs                      |   9 +-
 6 files changed, 225 insertions(+), 204 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index fb1982fb..67fd0661 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -149,30 +149,30 @@ private Uri _getWebSocketUri()
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token);
+			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request);
 			return observable;
 		}
 
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
-		{
-			return CreateSubscriptionStream(request, e =>
-			{
-				if (e is WebSocketException webSocketException)
-					webSocketExceptionHandler(webSocketException);
-				else
-					throw e;
-			});
-		}
-
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
-		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token, exceptionHandler);
-			return observable;
-		}
+		///// <inheritdoc />
+		//[Obsolete("EXPERIMENTAL API")]
+		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		//{
+		//	return CreateSubscriptionStream(request, e =>
+		//	{
+		//		if (e is WebSocketException webSocketException)
+		//			webSocketExceptionHandler(webSocketException);
+		//		else
+		//			throw e;
+		//	});
+		//}
+
+		///// <inheritdoc />
+		//[Obsolete("EXPERIMENTAL API")]
+		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		//{
+		//	var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request, _cancellationTokenSource.Token, exceptionHandler);
+		//	return observable;
+		//}
 
 		/// <summary>
 		/// Releases unmanaged resources
@@ -180,6 +180,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		public void Dispose()
 		{
 			this.graphQLHttpHandler.Dispose();
+			this.graphQlHttpWebSocket.Dispose();
 			_cancellationTokenSource.Cancel();
 			_cancellationTokenSource.Dispose();
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index d4d5678a..128f316c 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
 using System.Runtime.Serialization;
@@ -140,69 +141,64 @@ private async Task DisposeAsync()
 
 		#region Static Factories
 
-		public static IObservable<GraphQLResponse> GetSubscriptionStream(
-			Uri webSocketUri,
-			GraphQLRequest graphQLRequest,
-			CancellationToken cancellationToken = default,
-			Action<Exception> onException = null)
+		internal static IObservable<GraphQLResponse> GetSubscriptionStream(
+			GraphQLHttpWebSocket webSocket,
+			GraphQLRequest graphQLRequest)
 		{
-			int reconnectionAttempt = 0;
-
-			return Observable
-				// create deferred observable using a GraphQLHttpObservableSubscription instance
-				.Defer(
-					() =>
-					{
-						var observable = Observable.Using(
-							token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-							InitializeSubscription);
-
-						// when reconnecting, apply the delay computed by the BackOffStrategy
-						return (++reconnectionAttempt == 1) ? observable : observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1)) ;
-					}
-				)
-				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-				.Catch<GraphQLResponse, OperationCanceledException>(exception => Observable.Empty<GraphQLResponse>())
-				// wrap results
-				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
-				// do exception handling
-				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
 				{
-					try
+					var startRequest = new GraphQLWebSocketRequest
 					{
-						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
-						if (onException == null) throw e;
-
-						// invoke external handler
-						// exceptions thrown by the handler will propagate to OnError()
-						onException(e);
-
-						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-						return cancellationToken.IsCancellationRequested
-							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
-							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
-					}
-					catch (Exception exception)
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = graphQLRequest
+					};
+					var closeRequest = new GraphQLWebSocketRequest
 					{
-						// wrap all other exceptions to be propagated behind retry
-						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
-					}
-				})
-				// attempt to recreate the subscription stream for rethrown exceptions
-				.Retry()
-				// unwrap and push results or throw wrapped exceptions
-				.SelectMany(t =>
-				{
-					// if the result contains an exception, throw it on the observable
-					if (t.Item2 != null)
-						return Observable.Throw<GraphQLResponse>(t.Item2);
-
-					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
-					reconnectionAttempt = 1;
-					return Observable.Return(t.Item1);
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+
+					var disposable = new CompositeDisposable(
+						Disposable.Create(async () =>
+						{
+							Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+							await webSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+						}),
+						// subscribe to result stream
+						webSocket.ResponseStream
+							.Where(response => response.Id == startRequest.Id)
+							.SelectMany(response =>
+							{
+								switch (response.Type)
+								{
+									case GQLWebSocketMessageType.GQL_COMPLETE:
+										Debug.WriteLine(
+											$"received 'complete' message on subscription {startRequest.Id}");
+										return Observable.Empty<GraphQLResponse>();
+									case GQLWebSocketMessageType.GQL_ERROR:
+										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+										return Observable.Throw<GraphQLResponse>(
+											new GQLSubscriptionException(response.Payload));
+									default:
+										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+										return Observable.Return(((JObject) response?.Payload)
+											?.ToObject<GraphQLResponse>());
+								}
+							})
+							.Subscribe(observer)
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					await webSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+
+					return disposable;
 				})
-				// transform to hot observable and auto-connect
-				.Publish().RefCount();
+			)
+			// transform to hot observable and auto-connect
+			.Publish().RefCount();
 		}
 
 		/// <summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index b307487b..43e41c3a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -3,16 +3,13 @@
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
-using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http
 {
@@ -22,6 +19,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
 
 		private ClientWebSocket clientWebSocket = null;
 
@@ -29,80 +27,15 @@ public GraphQLHttpWebSocket(Uri webSocketUri)
 		{
 			this.webSocketUri = webSocketUri;
 			arraySegment = new ArraySegment<byte>(buffer);
+			ResponseStream = _createResponseStream();
 		}
 
-		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			if (clientWebSocket == null)
-			{
-				throw new InvalidOperationException("websocket not connected! subscribe to the response stream before sending a request!");
-			}
+			await _initializeWebSocket().ConfigureAwait(false);
 			var webSocketRequestString = JsonConvert.SerializeObject(request);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
-		}
-
-		public IObservable<GraphQLWebSocketResponse> ResponseStream
-		{
-			get
-			{
-				int reconnectionAttempt = 0;
-
-				return Observable
-					// create deferred observable using a GraphQLHttpObservableSubscription instance
-					.Defer(
-						() =>
-						{
-							var observable = Observable.Using(
-								token => _createClientWebsocket(),
-								(_, cancellationToken) => _initializeWebSocketConnection(cancellationToken));
-
-							// when reconnecting, apply the delay computed by the BackOffStrategy
-							return (++reconnectionAttempt == 1)
-								? observable
-								: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
-						}
-					)
-					// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-					.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-						Observable.Empty<GraphQLWebSocketResponse>())
-					// wrap results
-					.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
-					// do exception handling
-					.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
-					{
-						try
-						{
-							// exceptions thrown by the handler will propagate to OnError()
-							_handleExceptions(e);
-
-							// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-							return _cancellationTokenSource.Token.IsCancellationRequested
-								? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
-								: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
-						}
-						catch (Exception exception)
-						{
-							// wrap all other exceptions to be propagated behind retry
-							return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
-						}
-					})
-					// attempt to recreate the subscription stream for rethrown exceptions
-					.Retry()
-					// unwrap and push results or throw wrapped exceptions
-					.SelectMany(t =>
-					{
-						// if the result contains an exception, throw it on the observable
-						if (t.Item2 != null)
-							return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
-
-						// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
-						reconnectionAttempt = 1;
-						return Observable.Return(t.Item1);
-					})
-					// transform to hot observable and auto-connect
-					.Publish().RefCount();
-			}
+			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
 		}
 
 		/// <summary>
@@ -117,46 +50,135 @@ public IObservable<GraphQLWebSocketResponse> ResponseStream
 
 		#region Private Methods
 
+		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		{
+			int reconnectionAttempt = 0;
+
+			return Observable.Create<GraphQLWebSocketResponse>(observer =>
+				{
+					var observable = _getReceiveResultStream().GetAwaiter().GetResult();
+					// when reconnecting, apply the delay computed by the BackOffStrategy
+					observable = (++reconnectionAttempt == 1)
+						? observable
+						: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
+					return observable.Subscribe(observer);
+				})
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLWebSocketResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// exceptions thrown by the handler will propagate to OnError()
+						_handleExceptions(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return _cancellationTokenSource.Token.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the subscription stream for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
+
+					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
+					reconnectionAttempt = 1;
+
+					return t.Item1 == null
+						? Observable.Empty<GraphQLWebSocketResponse>()
+						: Observable.Return(t.Item1);
+				})
+				// transform to hot observable and auto-connect
+				.Publish().RefCount();
+		}
+
 		private void _handleExceptions(Exception e)
 		{
 
 		}
 
-		private Task<IDisposable> _createClientWebsocket()
+		private Task _initializeWebSocketTask;
+		private Task _initializeWebSocket()
 		{
+			// do not attempt to initialize if cancellation is requested
+			if(_disposed != null)
+				throw new OperationCanceledException();
+
+			// if an initialization task is already running, return that
+			if(_initializeWebSocketTask != null &&
+			   !_initializeWebSocketTask.IsFaulted &&
+			   !_initializeWebSocketTask.IsCompleted)
+				return _initializeWebSocketTask;
+
+			// if the websocket is open, return a completed task
+			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+				return Task.CompletedTask;
+
+			// else (re-)create websocket and connect
+			clientWebSocket?.Dispose();
 			clientWebSocket = new ClientWebSocket();
 			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-
-			return Task.FromResult(Disposable.Create(() => clientWebSocket?.Dispose()));
+			return _initializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
 
-		private async Task<IObservable<GraphQLWebSocketResponse>> _initializeWebSocketConnection(CancellationToken cancelToken)
+		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
-			await _connectAsync(cancelToken).ConfigureAwait(false);
+			await _initializeWebSocket().ConfigureAwait(false);
 			return Observable.Defer(() => _receiveResultAsync().ToObservable()).Repeat();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
+			Debug.WriteLine($"opening websocket {this.GetHashCode()}");
 			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
+			Debug.WriteLine($"connection established on websocket {this.GetHashCode()}");
 		}
 
 		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
-			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
-			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+			try
+			{
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+				throw;
+			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)
 		{
+			if(clientWebSocket == null)
+				return;
+
 			// don't attempt to close the websocket if it is in a failed state
 			if (this.clientWebSocket.State != WebSocketState.Open &&
 			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
 			    this.clientWebSocket.State != WebSocketState.CloseSent)
+			{
+				Debug.WriteLine($"websocket {this.GetHashCode()} state = {this.clientWebSocket.State}");
 				return;
+			}
 
 			Debug.WriteLine($"closing websocket {this.GetHashCode()}");
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
@@ -166,26 +188,26 @@ private async Task _closeAsync(CancellationToken cancellationToken = default)
 
 		#region IDisposable
 
-		private Task Disposed { get; set; }
+		private Task _disposed;
 		private object _disposedLocker = new object();
 		public void Dispose()
 		{
 			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
 			lock (_disposedLocker)
 			{
-				if (Disposed == null) Disposed = DisposeAsync();
+				if (_disposed == null) _disposed = DisposeAsync();
 			}
 		}
 
 		private async Task DisposeAsync()
 		{
-			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
+			Debug.WriteLine($"disposing websocket {this.GetHashCode()}...");
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
 			await _closeAsync().ConfigureAwait(false);
 			clientWebSocket?.Dispose();
 			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
+			Debug.WriteLine($"websocket {this.GetHashCode()} disposed");
 		}
 		#endregion
 	}
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 60af36ab..b2fa9308 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -47,31 +47,31 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
 
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
-		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
-		/// </summary>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		[Obsolete("EXPERIMENTAL")]
-		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+		///// <summary>
+		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		///// All subscriptions made to this stream share the same hot observable.<br/>
+		///// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		///// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		///// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		///// </summary>
+		///// <param name="request">the GraphQL request for this subscription</param>
+		///// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		///// <returns>an observable stream for the specified subscription</returns>
+		//[Obsolete("EXPERIMENTAL")]
+		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
 
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
-		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
-		/// </summary>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		[Obsolete("EXPERIMENTAL")]
-		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
+		///// <summary>
+		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		///// All subscriptions made to this stream share the same hot observable.<br/>
+		///// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		///// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		///// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		///// </summary>
+		///// <param name="request">the GraphQL request for this subscription</param>
+		///// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		///// <returns>an observable stream for the specified subscription</returns>
+		//[Obsolete("EXPERIMENTAL")]
+		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index 7bcf8522..1569176d 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -55,12 +55,12 @@ public ObservableTester(IObservable<T> observable)
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_updateReceived.Wait(Timeout))
-					Assert.True(false, "no update received!");
+				if (!_updateReceived.Wait(timeout ?? Timeout))
+					Assert.True(false, $"no update received within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertPayload?.Invoke(LastPayload);
 			}
@@ -74,11 +74,12 @@ public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
 		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
+		public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null)
 		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
 			try
 			{
-				if (_updateReceived.Wait(100))
+				if (_updateReceived.Wait(timeout.Value))
 					Assert.True(false, "update was inadvertently pushed!");
 			}
 			finally
@@ -90,12 +91,12 @@ public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
 		/// <summary>
 		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveCompleted()
+		public void ShouldHaveCompleted(TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_completed.Wait(Timeout))
-					Assert.True(false, "subscription did not complete!");
+				if (!_completed.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not complete within {(timeout ?? Timeout).TotalSeconds} s!");
 			}
 			finally
 			{
@@ -106,12 +107,12 @@ public void ShouldHaveCompleted()
 		/// <summary>
 		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveThrownError(Action<Exception> assertError = null)
+		public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_error.Wait(Timeout))
-					Assert.True(false, "subscription did not throw an error!");
+				if (!_error.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not throw an error within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertError?.Invoke(Error);
 			}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 3b404f23..fa0dd4d9 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -45,7 +45,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 		[Fact]
 		public async void AssertTestingHarness()
 		{
-			var port = 5001;
+			var port = 5002;
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -71,7 +71,7 @@ public async void AssertTestingHarness()
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
-			var port = 5002;
+			var port = 5003;
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -107,7 +107,7 @@ public async void CanCreateObservableSubscription()
 		[Fact]
 		public async void CanReconnectWithSameObservable()
 		{
-			var port = 5003;
+			var port = 5004;
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -127,6 +127,7 @@ public async void CanReconnectWithSameObservable()
 				});
 				Debug.WriteLine("disposing subscription...");
 				tester.Dispose();
+				await Task.Delay(TimeSpan.FromSeconds(10));
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
@@ -136,7 +137,7 @@ public async void CanReconnectWithSameObservable()
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				});
+				}, TimeSpan.FromSeconds(10));
 
 				// disposing the client should complete the subscription
 				client.Dispose();

From ae491f2106058c1875a9f407fb7978c93dfb5ec6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 15:48:41 +0100
Subject: [PATCH 013/455] fix subscription test, cleanup code

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  86 ++++--
 .../Http/GraphQLHttpObservableSubscription.cs | 254 ------------------
 .../Http/GraphQLSubscriptionException.cs      |  32 +++
 .../SubscriptionsTest.cs                      |  24 +-
 4 files changed, 113 insertions(+), 283 deletions(-)
 delete mode 100644 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLSubscriptionException.cs

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 67fd0661..2756e71e 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,12 +1,17 @@
 using System;
+using System.Diagnostics;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
+using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http {
 
@@ -149,31 +154,66 @@ private Uri _getWebSocketUri()
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request);
-			return observable;
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
+				{
+					var startRequest = new GraphQLWebSocketRequest
+					{
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var closeRequest = new GraphQLWebSocketRequest
+					{
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+
+					var disposable = new CompositeDisposable(
+						Disposable.Create(async () =>
+						{
+							try
+							{
+								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+							}
+							catch (OperationCanceledException) { }
+						}),
+						// subscribe to result stream
+						graphQlHttpWebSocket.ResponseStream
+							.Where(response => response.Id == startRequest.Id)
+							.SelectMany(response =>
+							{
+								switch (response.Type)
+								{
+									case GQLWebSocketMessageType.GQL_COMPLETE:
+										Debug.WriteLine(
+											$"received 'complete' message on subscription {startRequest.Id}");
+										return Observable.Empty<GraphQLResponse>();
+									case GQLWebSocketMessageType.GQL_ERROR:
+										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+										return Observable.Throw<GraphQLResponse>(
+											new GraphQLSubscriptionException(response.Payload));
+									default:
+										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+										return Observable.Return(((JObject)response?.Payload)
+											?.ToObject<GraphQLResponse>());
+								}
+							})
+							.Subscribe(observer)
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+
+					return disposable;
+				})
+			)
+			// transform to hot observable and auto-connect
+			.Publish().RefCount();
 		}
 
-		///// <inheritdoc />
-		//[Obsolete("EXPERIMENTAL API")]
-		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
-		//{
-		//	return CreateSubscriptionStream(request, e =>
-		//	{
-		//		if (e is WebSocketException webSocketException)
-		//			webSocketExceptionHandler(webSocketException);
-		//		else
-		//			throw e;
-		//	});
-		//}
-
-		///// <inheritdoc />
-		//[Obsolete("EXPERIMENTAL API")]
-		//public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
-		//{
-		//	var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(graphQlHttpWebSocket, request, _cancellationTokenSource.Token, exceptionHandler);
-		//	return observable;
-		//}
-
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
deleted file mode 100644
index 128f316c..00000000
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ /dev/null
@@ -1,254 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Net.WebSockets;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
-using System.Reactive.Threading.Tasks;
-using System.Runtime.Serialization;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Common;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace GraphQL.Client.Http {
-
-	/// <summary>
-	/// Represents the result of a subscription query
-	/// </summary>
-	[Obsolete("EXPERIMENTAL API")]
-	public class GraphQLHttpObservableSubscription : IDisposable {
-
-		private readonly ClientWebSocket clientWebSocket = new ClientWebSocket();
-		private readonly Uri webSocketUri;
-		private readonly GraphQLRequest graphQLRequest;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
-		private readonly CancellationTokenSource _cancellationTokenSource;
-
-		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default) {
-			_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-			_cancellationTokenSource.Token.Register(Dispose);
-			this.webSocketUri = webSocketUri;
-			this.graphQLRequest = graphQLRequest;
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-
-			arraySegment = new ArraySegment<byte>(buffer);
-		}
-
-		public async Task ConnectAsync(CancellationToken token)
-		{
-			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
-		}
-
-		public async Task<GraphQLResponse> ReceiveResultAsync()
-		{
-			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
-			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
-			switch (webSocketResponse.Type)
-			{
-				case GQLWebSocketMessageType.GQL_COMPLETE:
-					Debug.WriteLine($"received 'complete' message on subscription {this.GetHashCode()}");
-					Dispose();
-					break;
-				case GQLWebSocketMessageType.GQL_ERROR:
-					Debug.WriteLine($"received 'error' message on subscription {this.GetHashCode()}");
-					throw new GQLSubscriptionException(webSocketResponse.Payload);
-				default:
-					Debug.WriteLine($"received payload on subscription {this.GetHashCode()}");
-					break;
-			}
-
-			return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
-		}
-
-		public async Task CloseAsync(CancellationToken cancellationToken = default)
-		{
-			// don't attempt to close the websocket if it is in a failed state
-			if (this.clientWebSocket.State != WebSocketState.Open &&
-			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
-			    this.clientWebSocket.State != WebSocketState.CloseSent)
-				return;
-
-			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
-			if (this.clientWebSocket.State == WebSocketState.Open) {
-				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
-			}
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
-		}
-
-		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLWebSocketRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_START,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLWebSocketRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_STOP,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default)
-		{
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
-		}
-
-		#region IDisposable
-		public Task Disposed { get; private set; }
-		private object _disposedLocker = new object();
-		public void Dispose()
-		{
-			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			lock (_disposedLocker)
-			{
-				if (Disposed == null) Disposed = DisposeAsync();
-			}
-		}
-
-		private async Task DisposeAsync()
-		{
-			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
-			if(!_cancellationTokenSource.IsCancellationRequested)
-				_cancellationTokenSource.Cancel();
-			await CloseAsync().ConfigureAwait(false);
-			clientWebSocket?.Dispose();
-			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
-		}
-
-		#endregion
-
-		#region Static Factories
-
-		internal static IObservable<GraphQLResponse> GetSubscriptionStream(
-			GraphQLHttpWebSocket webSocket,
-			GraphQLRequest graphQLRequest)
-		{
-			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse>(async observer =>
-				{
-					var startRequest = new GraphQLWebSocketRequest
-					{
-						Id = Guid.NewGuid().ToString("N"),
-						Type = GQLWebSocketMessageType.GQL_START,
-						Payload = graphQLRequest
-					};
-					var closeRequest = new GraphQLWebSocketRequest
-					{
-						Id = startRequest.Id,
-						Type = GQLWebSocketMessageType.GQL_STOP
-					};
-
-					var disposable = new CompositeDisposable(
-						Disposable.Create(async () =>
-						{
-							Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-							await webSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
-						}),
-						// subscribe to result stream
-						webSocket.ResponseStream
-							.Where(response => response.Id == startRequest.Id)
-							.SelectMany(response =>
-							{
-								switch (response.Type)
-								{
-									case GQLWebSocketMessageType.GQL_COMPLETE:
-										Debug.WriteLine(
-											$"received 'complete' message on subscription {startRequest.Id}");
-										return Observable.Empty<GraphQLResponse>();
-									case GQLWebSocketMessageType.GQL_ERROR:
-										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
-										return Observable.Throw<GraphQLResponse>(
-											new GQLSubscriptionException(response.Payload));
-									default:
-										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-										return Observable.Return(((JObject) response?.Payload)
-											?.ToObject<GraphQLResponse>());
-								}
-							})
-							.Subscribe(observer)
-					);
-
-					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
-					// send subscription request
-					await webSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
-
-					return disposable;
-				})
-			)
-			// transform to hot observable and auto-connect
-			.Publish().RefCount();
-		}
-
-		/// <summary>
-		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
-		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
-		/// </summary>
-		public static Func<int, TimeSpan> BackOffStrategy = n =>
-		{
-			var rnd = new Random();
-			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
-		};
-
-		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
-		{
-			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
-			return Task.FromResult(subscription);
-		}
-
-		private static async Task<IObservable<GraphQLResponse>> InitializeSubscription(GraphQLHttpObservableSubscription observableSubscription, CancellationToken cancelToken)
-		{
-			await observableSubscription.ConnectAsync(cancelToken).ConfigureAwait(false);
-			await observableSubscription.SendInitialMessageAsync(cancelToken).ConfigureAwait(false);
-			return Observable.Defer(() => observableSubscription.ReceiveResultAsync().ToObservable()).Repeat();
-		}
-
-		#endregion
-
-		[Serializable]
-		public class GQLSubscriptionException : Exception
-		{
-			//
-			// For guidelines regarding the creation of new exception types, see
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
-			// and
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
-			//
-
-			public GQLSubscriptionException()
-			{
-			}
-
-			public GQLSubscriptionException(object error) : base(error.ToString())
-			{
-			}
-
-			protected GQLSubscriptionException(
-				SerializationInfo info,
-				StreamingContext context) : base(info, context)
-			{
-			}
-		}
-	}
-}
diff --git a/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
new file mode 100644
index 00000000..7aad64f0
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace GraphQL.Client.Http
+{
+	[Serializable]
+	public class GraphQLSubscriptionException : Exception
+	{
+		//
+		// For guidelines regarding the creation of new exception types, see
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+		// and
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+		//
+
+		public GraphQLSubscriptionException()
+		{
+		}
+
+		public GraphQLSubscriptionException(object error) : base(error.ToString())
+		{
+		}
+
+		protected GraphQLSubscriptionException(
+			SerializationInfo info,
+			StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index fa0dd4d9..8006469d 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -117,27 +117,39 @@ public async void CanReconnectWithSameObservable()
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
-				const string message1 = "Hello World";
 
+				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
 				Assert.Equal(message1, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
 				Debug.WriteLine("disposing subscription...");
 				tester.Dispose();
-				await Task.Delay(TimeSpan.FromSeconds(10));
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
-				const string message2 = "lorem ipsum dolor si amet";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				}, TimeSpan.FromSeconds(10));
+				}, TimeSpan.FromSeconds(3));
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();

From 98190e9919fd85e7de56775dea6c96bc76940dd2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 15:49:09 +0100
Subject: [PATCH 014/455] more code cleanup

---
 src/GraphQL.Client/IGraphQLClient.cs | 26 --------------------------
 1 file changed, 26 deletions(-)

diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index b2fa9308..34fc72ec 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -46,32 +46,6 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
-
-		///// <summary>
-		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		///// All subscriptions made to this stream share the same hot observable.<br/>
-		///// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
-		///// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		///// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
-		///// </summary>
-		///// <param name="request">the GraphQL request for this subscription</param>
-		///// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
-		///// <returns>an observable stream for the specified subscription</returns>
-		//[Obsolete("EXPERIMENTAL")]
-		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
-
-		///// <summary>
-		///// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		///// All subscriptions made to this stream share the same hot observable.<br/>
-		///// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
-		///// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		///// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
-		///// </summary>
-		///// <param name="request">the GraphQL request for this subscription</param>
-		///// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
-		///// <returns>an observable stream for the specified subscription</returns>
-		//[Obsolete("EXPERIMENTAL")]
-		//IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }

From 9aec685d647e9a2d59876076c8f7feefebddcb99 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 16:01:23 +0100
Subject: [PATCH 015/455] add test
 CanConnectMultipleSubscriptionsSimultaneously

---
 .../GraphQLClientExtensions.cs                |  2 +-
 .../SubscriptionsTest.cs                      | 99 ++++++++++++++++---
 2 files changed, 89 insertions(+), 12 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index e8b4babf..c7dd0568 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -22,7 +22,7 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 				{
 					input = new
 					{
-						fromId = "me",
+						fromId = "2",
 						content = message,
 						sentAt = DateTime.Now
 					}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8006469d..b20facde 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -36,7 +36,8 @@ public static IWebHost CreateServer(int port)
 		private readonly IWebHost _server;
 
 		public SubscriptionsTest()
-		{}
+		{
+		}
 
 		private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
@@ -53,7 +54,7 @@ public async void AssertTestingHarness()
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
-				Assert.Equal(message, (string)response.Data.addMessage.content);
+				Assert.Equal(message, (string) response.Data.addMessage.content);
 			}
 		}
 
@@ -63,6 +64,7 @@ public async void AssertTestingHarness()
 			    content
 			  }
 			}";
+
 		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
 		{
 			Query = SubscriptionQuery
@@ -92,10 +94,10 @@ public async void CanCreateObservableSubscription()
 
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				// disposing the client should throw a TaskCanceledException on the subscription
@@ -120,18 +122,18 @@ public async void CanReconnectWithSameObservable()
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				Assert.Equal(message1, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				Debug.WriteLine("disposing subscription...");
@@ -139,21 +141,96 @@ public async void CanReconnectWithSameObservable()
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(
+					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value); },
+					TimeSpan.FromSeconds(3));
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message3, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		private const string SubscriptionQuery2 = @"
+			subscription {
+			  messageAdded{
+			    content
+				from {
+				  displayName
+				}
+			  }
+			}";
+
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
+		{
+			Query = SubscriptionQuery2
+		};
+
+		[Fact]
+		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		{
+			var port = 5005;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = subscription1.SubscribeTester();
+
+				const string message1 = "Hello World";
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2);
+				var tester2 = subscription2.SubscribeTester();
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				}, TimeSpan.FromSeconds(3));
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+				});
+
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
+
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester.ShouldHaveCompleted();
+				tester2.ShouldHaveCompleted();
 			}
 		}
 	}

From 24be6a5fa890beda2f7d20a980278f1a8f901f95 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 16:03:48 +0100
Subject: [PATCH 016/455] dynamically find free ports for integration test

---
 .../GraphQL.Integration.Tests/NetworkHelpers.cs | 17 +++++++++++++++++
 .../SubscriptionsTest.cs                        |  8 ++++----
 2 files changed, 21 insertions(+), 4 deletions(-)
 create mode 100644 tests/GraphQL.Integration.Tests/NetworkHelpers.cs

diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
new file mode 100644
index 00000000..1462767e
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
@@ -0,0 +1,17 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class NetworkHelpers
+	{
+		public static int GetFreeTcpPortNumber()
+		{
+			var l = new TcpListener(IPAddress.Loopback, 0);
+			l.Start();
+			var port = ((IPEndPoint)l.LocalEndpoint).Port;
+			l.Stop();
+			return port;
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index b20facde..4dc1b2b9 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -46,7 +46,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 		[Fact]
 		public async void AssertTestingHarness()
 		{
-			var port = 5002;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -73,7 +73,7 @@ public async void AssertTestingHarness()
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
-			var port = 5003;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -109,7 +109,7 @@ public async void CanCreateObservableSubscription()
 		[Fact]
 		public async void CanReconnectWithSameObservable()
 		{
-			var port = 5004;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -176,7 +176,7 @@ public async void CanReconnectWithSameObservable()
 		[Fact]
 		public async void CanConnectMultipleSubscriptionsSimultaneously()
 		{
-			var port = 5005;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);

From 4189799bd6464da5e3c0a757630d9a9f0a1cd8ac Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Dec 2018 16:14:49 +0100
Subject: [PATCH 017/455] add WebSocketExceptionHandler to clientOptions

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs   |  6 +++---
 .../Http/GraphQLHttpClientOptions.cs           | 18 ++++++++++++++++++
 .../Http/GraphQLHttpWebSocket.cs               | 11 ++++-------
 3 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 2756e71e..99581029 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -82,7 +82,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
 		}
 
 		/// <summary>
@@ -97,7 +97,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -108,7 +108,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri());
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 73a00430..f2fbfe37 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
@@ -39,6 +40,23 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public MediaTypeHeaderValue MediaType { get; set; } = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
+		/// <summary>
+		/// The exception handler for the websocket connection.
+		/// <see cref="Exception"/>s thrown in this handler will bubble down through the reactive websocket stream and cause it to fail.
+		/// All other exceptions will cause the websocket to be closed and to attempt a reconnection.
+		/// </summary>
+		public Action<Exception> WebSocketExceptionHandler { get; set; } =
+			exception =>
+			{
+				if (exception is WebSocketException webSocketException)
+				{
+					Console.Error.WriteLine(webSocketException.ToString());
+				}
+				else
+				{
+					throw exception;
+				}
+			};
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 43e41c3a..f7abdeb8 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -16,6 +16,7 @@ namespace GraphQL.Client.Http
 	internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
+		private readonly Action<Exception> _webSocketExceptionHandler;
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
@@ -23,9 +24,10 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		private ClientWebSocket clientWebSocket = null;
 
-		public GraphQLHttpWebSocket(Uri webSocketUri)
+		public GraphQLHttpWebSocket(Uri webSocketUri, Action<Exception> webSocketExceptionHandler)
 		{
 			this.webSocketUri = webSocketUri;
+			_webSocketExceptionHandler = webSocketExceptionHandler;
 			arraySegment = new ArraySegment<byte>(buffer);
 			ResponseStream = _createResponseStream();
 		}
@@ -74,7 +76,7 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 					try
 					{
 						// exceptions thrown by the handler will propagate to OnError()
-						_handleExceptions(e);
+						_webSocketExceptionHandler?.Invoke(e);
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return _cancellationTokenSource.Token.IsCancellationRequested
@@ -107,11 +109,6 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 				.Publish().RefCount();
 		}
 
-		private void _handleExceptions(Exception e)
-		{
-
-		}
-
 		private Task _initializeWebSocketTask;
 		private Task _initializeWebSocket()
 		{

From 492c440affa359a374f5379149e46dcd6f6cb4a3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 7 Dec 2018 10:15:07 +0100
Subject: [PATCH 018/455] move reconnect-logic into subscriptions

---
 root.props                                    |   2 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  90 ++++--------
 .../Http/GraphQLHttpClientOptions.cs          |  10 ++
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 128 ++++++++++++++++++
 .../Http/GraphQLHttpWebSocket.cs              |  45 +-----
 .../CallbackTester.cs                         |  81 +++++++++++
 .../SubscriptionsTest.cs                      |  48 ++++++-
 7 files changed, 293 insertions(+), 111 deletions(-)
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
 create mode 100644 tests/GraphQL.Integration.Tests/CallbackTester.cs

diff --git a/root.props b/root.props
index 20595010..5758bed1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.7</Version>
+		<Version>2.0.0-alpha.subscriptions-api.8</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 99581029..36c12118 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,17 +1,11 @@
 using System;
-using System.Diagnostics;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Net.WebSockets;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
-using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
-using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http {
 
@@ -82,7 +76,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		/// <summary>
@@ -97,7 +91,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -108,7 +102,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options.WebSocketExceptionHandler);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
@@ -154,64 +148,11 @@ private Uri _getWebSocketUri()
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse>(async observer =>
-				{
-					var startRequest = new GraphQLWebSocketRequest
-					{
-						Id = Guid.NewGuid().ToString("N"),
-						Type = GQLWebSocketMessageType.GQL_START,
-						Payload = request
-					};
-					var closeRequest = new GraphQLWebSocketRequest
-					{
-						Id = startRequest.Id,
-						Type = GQLWebSocketMessageType.GQL_STOP
-					};
-
-					var disposable = new CompositeDisposable(
-						Disposable.Create(async () =>
-						{
-							try
-							{
-								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
-							}
-							catch (OperationCanceledException) { }
-						}),
-						// subscribe to result stream
-						graphQlHttpWebSocket.ResponseStream
-							.Where(response => response.Id == startRequest.Id)
-							.SelectMany(response =>
-							{
-								switch (response.Type)
-								{
-									case GQLWebSocketMessageType.GQL_COMPLETE:
-										Debug.WriteLine(
-											$"received 'complete' message on subscription {startRequest.Id}");
-										return Observable.Empty<GraphQLResponse>();
-									case GQLWebSocketMessageType.GQL_ERROR:
-										Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
-										return Observable.Throw<GraphQLResponse>(
-											new GraphQLSubscriptionException(response.Payload));
-									default:
-										Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-										return Observable.Return(((JObject)response?.Payload)
-											?.ToObject<GraphQLResponse>());
-								}
-							})
-							.Subscribe(observer)
-					);
-
-					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
-					// send subscription request
-					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
-
-					return disposable;
-				})
-			)
-			// transform to hot observable and auto-connect
-			.Publish().RefCount();
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
+				Options, _cancellationTokenSource.Token);
 		}
 
 		/// <summary>
@@ -219,6 +160,21 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		/// </summary>
 		public void Dispose()
 		{
+			lock (_disposeLocker)
+			{
+				if (!_disposed)
+				{
+					_dispose();
+				}
+			}
+		}
+
+		private bool _disposed = false;
+		private object _disposeLocker = new object();
+
+		private void _dispose()
+		{
+			_disposed = true;
 			this.graphQLHttpHandler.Dispose();
 			this.graphQlHttpWebSocket.Dispose();
 			_cancellationTokenSource.Cancel();
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index f2fbfe37..a99c0b46 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -57,6 +57,16 @@ public class GraphQLHttpClientOptions {
 					throw exception;
 				}
 			};
+
+		/// <summary>
+		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
new file mode 100644
index 00000000..5e1febed
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -0,0 +1,128 @@
+using System;
+using System.Diagnostics;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Threading;
+using GraphQL.Common;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http
+{
+	public static class GraphQLHttpSubscriptionHelpers
+	{
+		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			GraphQLRequest request,
+			GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLHttpClientOptions options,
+			CancellationToken cancellationToken = default)
+		{
+			int connectionAttempt = 0;
+
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
+				{
+					var startRequest = new GraphQLWebSocketRequest
+					{
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var closeRequest = new GraphQLWebSocketRequest
+					{
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+
+
+					var observable = graphQlHttpWebSocket.ResponseStream
+						.Where(response => response.Id == startRequest.Id)
+						.SelectMany(response =>
+						{
+							switch (response.Type)
+							{
+								case GQLWebSocketMessageType.GQL_COMPLETE:
+									Debug.WriteLine(
+										$"received 'complete' message on subscription {startRequest.Id}");
+									return Observable.Empty<GraphQLResponse>();
+								case GQLWebSocketMessageType.GQL_ERROR:
+									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+									return Observable.Throw<GraphQLResponse>(
+										new GraphQLSubscriptionException(response.Payload));
+								default:
+									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+									return Observable.Return(((JObject) response?.Payload)
+										?.ToObject<GraphQLResponse>());
+							}
+						});
+
+					Debug.WriteLine($"subscription connection attempt #{connectionAttempt}");
+					observable = (++connectionAttempt == 1)
+						? observable
+						: observable.DelaySubscription(options.BackOffStrategy(connectionAttempt - 1));
+
+					var disposable = new CompositeDisposable(
+						Disposable.Create(async () =>
+						{
+							connectionAttempt = 0;
+							try
+							{
+								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+							}
+							catch (OperationCanceledException) { }
+						}),
+						// subscribe to result stream
+						observable.Subscribe(observer)
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+
+					return disposable;
+				}))
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// exceptions thrown by the handler will propagate to OnError()
+						options.WebSocketExceptionHandler?.Invoke(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return cancellationToken.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the websocket for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLResponse>(t.Item2);
+
+					connectionAttempt = 1;
+					return t.Item1 == null
+						? Observable.Empty<GraphQLResponse>()
+						: Observable.Return(t.Item1);
+				})
+				// transform to hot observable and auto-connect
+				.Publish().RefCount();
+		}
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index f7abdeb8..2b7a6ae8 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -16,7 +16,7 @@ namespace GraphQL.Client.Http
 	internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
-		private readonly Action<Exception> _webSocketExceptionHandler;
+		private readonly GraphQLHttpClientOptions _options;
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
@@ -24,10 +24,10 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		private ClientWebSocket clientWebSocket = null;
 
-		public GraphQLHttpWebSocket(Uri webSocketUri, Action<Exception> webSocketExceptionHandler)
+		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
 			this.webSocketUri = webSocketUri;
-			_webSocketExceptionHandler = webSocketExceptionHandler;
+			_options = options;
 			arraySegment = new ArraySegment<byte>(buffer);
 			ResponseStream = _createResponseStream();
 		}
@@ -62,49 +62,12 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 					// when reconnecting, apply the delay computed by the BackOffStrategy
 					observable = (++reconnectionAttempt == 1)
 						? observable
-						: observable.DelaySubscription(BackOffStrategy(reconnectionAttempt - 1));
+						: observable.DelaySubscription(_options.BackOffStrategy(reconnectionAttempt - 1));
 					return observable.Subscribe(observer);
 				})
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
 					Observable.Empty<GraphQLWebSocketResponse>())
-				// wrap results
-				.Select(response => new Tuple<GraphQLWebSocketResponse, Exception>(response, null))
-				// do exception handling
-				.Catch<Tuple<GraphQLWebSocketResponse, Exception>, Exception>(e =>
-				{
-					try
-					{
-						// exceptions thrown by the handler will propagate to OnError()
-						_webSocketExceptionHandler?.Invoke(e);
-
-						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-						return _cancellationTokenSource.Token.IsCancellationRequested
-							? Observable.Empty<Tuple<GraphQLWebSocketResponse, Exception>>()
-							: Observable.Throw<Tuple<GraphQLWebSocketResponse, Exception>>(e);
-					}
-					catch (Exception exception)
-					{
-						// wrap all other exceptions to be propagated behind retry
-						return Observable.Return(new Tuple<GraphQLWebSocketResponse, Exception>(null, exception));
-					}
-				})
-				// attempt to recreate the subscription stream for rethrown exceptions
-				.Retry()
-				// unwrap and push results or throw wrapped exceptions
-				.SelectMany(t =>
-				{
-					// if the result contains an exception, throw it on the observable
-					if (t.Item2 != null)
-						return Observable.Throw<GraphQLWebSocketResponse>(t.Item2);
-
-					// else a value from OnNext() has arrived, so reset the reconnectionAttempt counter and pass the value on
-					reconnectionAttempt = 1;
-
-					return t.Item1 == null
-						? Observable.Empty<GraphQLWebSocketResponse>()
-						: Observable.Return(t.Item1);
-				})
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
new file mode 100644
index 00000000..bf214d73
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+	public class CallbackTester<T>
+	{
+		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool CallbackInvoked => _callbackInvoked.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		public void Callback(T param)
+		{
+			LastPayload = param;
+			_callbackInvoked.Set();
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null)
+		{
+			try
+			{
+				if (!_callbackInvoked.Wait(timeout ?? Timeout))
+					Assert.True(false, $"callback not invoked within {(timeout ?? Timeout).TotalSeconds} s!");
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null)
+		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
+			try
+			{
+				if (_callbackInvoked.Wait(timeout.Value))
+					Assert.True(false, "callback was inadvertently invoked pushed!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset()
+		{
+			LastPayload = default(T);
+			_callbackInvoked.Reset();
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 4dc1b2b9..a5266d98 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
@@ -39,8 +41,12 @@ public SubscriptionsTest()
 		{
 		}
 
-		private GraphQLHttpClient GetGraphQLClient(int port)
-			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
+		private GraphQLHttpClient GetGraphQLClient(int port, Action<Exception> webSocketErrorHandler = null)
+			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
+			{
+				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+				WebSocketExceptionHandler = webSocketErrorHandler
+			} );
 
 
 		[Fact]
@@ -233,5 +239,43 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				tester2.ShouldHaveCompleted();
 			}
 		}
+
+		[Fact]
+		public async void CanHandleConnectionTimeout()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var server = CreateServer(port);
+			var callbackTester = new CallbackTester<Exception>();
+
+			var client = GetGraphQLClient(port, callbackTester.Callback);
+			Debug.WriteLine("creating subscription stream");
+			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+
+			Debug.WriteLine("subscribing...");
+			var tester = observable.SubscribeTester();
+			const string message1 = "Hello World";
+
+			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+			Assert.Equal(message1, (string)response.Data.addMessage.content);
+
+			tester.ShouldHaveReceivedUpdate(gqlResponse =>
+			{
+				Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+			});
+
+			Debug.WriteLine("stopping web host...");
+			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
+			Debug.WriteLine("web host stopped...");
+
+			callbackTester.CallbackShouldHaveBeenInvoked(exception =>
+			{
+				Assert.IsType<WebSocketException>(exception);
+			}, TimeSpan.FromSeconds(10));
+
+			// disposing the client should complete the subscription
+			client.Dispose();
+			tester.ShouldHaveCompleted();
+			server.Dispose();
+		}
 	}
 }

From 293c3512b42a56bf262db5f9428312dcf4bed7f5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 7 Dec 2018 10:35:30 +0100
Subject: [PATCH 019/455] move external exception handler declaration to
 CreateSubscriptionStream overloads

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 24 ++++++++++++++++-
 .../Http/GraphQLHttpClientOptions.cs          | 18 -------------
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  6 ++++-
 src/GraphQL.Client/IGraphQLClient.cs          | 26 +++++++++++++++++++
 .../SubscriptionsTest.cs                      |  7 +++--
 5 files changed, 57 insertions(+), 24 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 36c12118..90209d40 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -152,7 +153,28 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
 			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
-				Options, _cancellationTokenSource.Token);
+				Options, cancellationToken: _cancellationTokenSource.Token);
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		{
+			return CreateSubscriptionStream(request, e =>
+			{
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		{
+			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			return observable;
 		}
 
 		/// <summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index a99c0b46..38008421 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -40,24 +40,6 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public MediaTypeHeaderValue MediaType { get; set; } = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
-		/// <summary>
-		/// The exception handler for the websocket connection.
-		/// <see cref="Exception"/>s thrown in this handler will bubble down through the reactive websocket stream and cause it to fail.
-		/// All other exceptions will cause the websocket to be closed and to attempt a reconnection.
-		/// </summary>
-		public Action<Exception> WebSocketExceptionHandler { get; set; } =
-			exception =>
-			{
-				if (exception is WebSocketException webSocketException)
-				{
-					Console.Error.WriteLine(webSocketException.ToString());
-				}
-				else
-				{
-					throw exception;
-				}
-			};
-
 		/// <summary>
 		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
 		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 5e1febed..8d4a71af 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -16,6 +16,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			GraphQLRequest request,
 			GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLHttpClientOptions options,
+			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
 		{
 			int connectionAttempt = 0;
@@ -93,8 +94,11 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				{
 					try
 					{
+						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
+						if (exceptionHandler == null) throw e;
+
 						// exceptions thrown by the handler will propagate to OnError()
-						options.WebSocketExceptionHandler?.Invoke(e);
+						exceptionHandler?.Invoke(e);
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return cancellationToken.IsCancellationRequested
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 34fc72ec..60af36ab 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -46,6 +46,32 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index a5266d98..8acbf6f4 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -41,11 +41,10 @@ public SubscriptionsTest()
 		{
 		}
 
-		private GraphQLHttpClient GetGraphQLClient(int port, Action<Exception> webSocketErrorHandler = null)
+		private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-				WebSocketExceptionHandler = webSocketErrorHandler
 			} );
 
 
@@ -247,9 +246,9 @@ public async void CanHandleConnectionTimeout()
 			var server = CreateServer(port);
 			var callbackTester = new CallbackTester<Exception>();
 
-			var client = GetGraphQLClient(port, callbackTester.Callback);
+			var client = GetGraphQLClient(port);
 			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
 
 			Debug.WriteLine("subscribing...");
 			var tester = observable.SubscribeTester();

From e6c469a48d54da6dd21a92f9abcbcf8166b5434c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 7 Dec 2018 10:51:13 +0100
Subject: [PATCH 020/455] fix exception on disposing disconnected subscription

---
 root.props                                               | 2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs               | 4 ++++
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs     | 9 +++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 5758bed1..d00301d1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.8</Version>
+		<Version>2.0.0-alpha.subscriptions-api.10</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 8d4a71af..b4829f04 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
@@ -72,7 +73,10 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
 								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
 							}
+							// do not break on disposing
 							catch (OperationCanceledException) { }
+							// do not break with missing connection on Retry()
+							catch (WebSocketException) { }
 						}),
 						// subscribe to result stream
 						observable.Subscribe(observer)
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8acbf6f4..bd9f52d7 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -271,6 +271,15 @@ public async void CanHandleConnectionTimeout()
 				Assert.IsType<WebSocketException>(exception);
 			}, TimeSpan.FromSeconds(10));
 
+			try
+			{
+				server.Start();
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+			}
+
 			// disposing the client should complete the subscription
 			client.Dispose();
 			tester.ShouldHaveCompleted();

From 7bcf0e4d79eeac2a79b869c432c65da81361ab1c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 10 Dec 2018 10:08:32 +0100
Subject: [PATCH 021/455] fix tests, add console app for testing reconnect
 after server restart

---
 GraphQL.Client.sln                            |   9 +-
 .../Program.cs                                |  44 ++++++
 ...iptionIntegrationTest.ConsoleClient.csproj |  13 ++
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  44 +++---
 .../Http/GraphQLHttpWebSocket.cs              | 125 ++++++++++++------
 .../SubscriptionsTest.cs                      |  12 +-
 6 files changed, 180 insertions(+), 67 deletions(-)
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/Program.cs
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 722a7d85..aa9d13e0 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.27130.2010
@@ -49,6 +49,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SubscriptionIntegrationTest.ConsoleClient", "SubscriptionIntegrationTest.ConsoleClient\SubscriptionIntegrationTest.ConsoleClient.csproj", "{D588BC10-6B17-477F-9546-F8D1CE02EACB}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -83,6 +85,10 @@ Global
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -97,6 +103,7 @@ Global
 		{B21E97C3-F328-473F-A054-A4BF272B63F0} = {9413EC62-CDDE-4E77-9784-E1136EA5D1EE}
 		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
new file mode 100644
index 00000000..a891236a
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -0,0 +1,44 @@
+using System;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+
+namespace SubsccriptionIntegrationTest.ConsoleClient
+{
+	class Program
+	{
+		static void Main(string[] args)
+		{
+			Console.WriteLine("configuring client ...");
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			{
+#pragma warning disable 618
+				var stream = client.CreateSubscriptionStream(new GraphQLRequest
+					{
+						Query = @"
+							subscription {
+							  messageAdded{
+							    content
+								from {
+								  displayName
+								}
+							  }
+							}"
+					},
+					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+#pragma warning restore 618
+
+				Console.WriteLine("subscribing to message stream ...");
+				using (var subscription = stream.Subscribe(
+					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
+					() => Console.WriteLine($"message subscription stream completed")))
+				{
+					Console.WriteLine("client setup complete");
+					Console.WriteLine("press any key to exit");
+					Console.Read();
+					Console.WriteLine("shutting down ...");
+				}
+			}
+		}
+	}
+}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
new file mode 100644
index 00000000..21901c2f
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
+    <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index b4829f04..512dc443 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -4,6 +4,7 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -20,8 +21,6 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
 		{
-			int connectionAttempt = 0;
-
 			return Observable.Defer(() =>
 				Observable.Create<GraphQLResponse>(async observer =>
 				{
@@ -36,8 +35,6 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Id = startRequest.Id,
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
-
-
 					var observable = graphQlHttpWebSocket.ResponseStream
 						.Where(response => response.Id == startRequest.Id)
 						.SelectMany(response =>
@@ -45,8 +42,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 							switch (response.Type)
 							{
 								case GQLWebSocketMessageType.GQL_COMPLETE:
-									Debug.WriteLine(
-										$"received 'complete' message on subscription {startRequest.Id}");
+									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
 									return Observable.Empty<GraphQLResponse>();
 								case GQLWebSocketMessageType.GQL_ERROR:
 									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
@@ -59,15 +55,24 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 							}
 						});
 
-					Debug.WriteLine($"subscription connection attempt #{connectionAttempt}");
-					observable = (++connectionAttempt == 1)
-						? observable
-						: observable.DelaySubscription(options.BackOffStrategy(connectionAttempt - 1));
+					try
+					{
+						// intialize websocket (completes immediately if socket is already open)
+						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						// subscribe observer to failed observable
+						return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+					}
 
 					var disposable = new CompositeDisposable(
+						observable.Subscribe(observer),
 						Disposable.Create(async () =>
 						{
-							connectionAttempt = 0;
+							// only try to send close request on open websocket
+							if (graphQlHttpWebSocket.WebSocketState != WebSocketState.Open) return;
+
 							try
 							{
 								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
@@ -75,16 +80,20 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 							}
 							// do not break on disposing
 							catch (OperationCanceledException) { }
-							// do not break with missing connection on Retry()
-							catch (WebSocketException) { }
-						}),
-						// subscribe to result stream
-						observable.Subscribe(observer)
+						})
 					);
 
 					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
 					// send subscription request
-					await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+					try
+					{
+						await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						Console.WriteLine(e);
+						throw;
+					}
 
 					return disposable;
 				}))
@@ -124,7 +133,6 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 					if (t.Item2 != null)
 						return Observable.Throw<GraphQLResponse>(t.Item2);
 
-					connectionAttempt = 1;
 					return t.Item1 == null
 						? Observable.Empty<GraphQLResponse>()
 						: Observable.Return(t.Item1);
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 2b7a6ae8..c5e2d349 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -3,6 +3,7 @@
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
+using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
 using System.Text;
 using System.Threading;
@@ -20,9 +21,13 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
-		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+
+		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+
+		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
 		private ClientWebSocket clientWebSocket = null;
+		private int _connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
@@ -32,58 +37,43 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			ResponseStream = _createResponseStream();
 		}
 
+		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+
+
 		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			await _initializeWebSocket().ConfigureAwait(false);
+			await InitializeWebSocket().ConfigureAwait(false);
 			var webSocketRequestString = JsonConvert.SerializeObject(request);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
 		}
 
-		/// <summary>
-		/// The back-off strategy for automatic reconnects. Calculates the delay before the next connection attempt is made.<br/>
-		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
-		/// </summary>
-		public static Func<int, TimeSpan> BackOffStrategy = n =>
-		{
-			var rnd = new Random();
-			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
-		};
+		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
 
 		#region Private Methods
 
-		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		private Task _backOff()
 		{
-			int reconnectionAttempt = 0;
+			_connectionAttempt++;
 
-			return Observable.Create<GraphQLWebSocketResponse>(observer =>
-				{
-					var observable = _getReceiveResultStream().GetAwaiter().GetResult();
-					// when reconnecting, apply the delay computed by the BackOffStrategy
-					observable = (++reconnectionAttempt == 1)
-						? observable
-						: observable.DelaySubscription(_options.BackOffStrategy(reconnectionAttempt - 1));
-					return observable.Subscribe(observer);
-				})
-				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLWebSocketResponse>())
-				// transform to hot observable and auto-connect
-				.Publish().RefCount();
+			if(_connectionAttempt == 1) return Task.CompletedTask;
+
+			var delay = _options.BackOffStrategy(_connectionAttempt - 1);
+			Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
+			return Task.Delay(delay);
 		}
 
-		private Task _initializeWebSocketTask;
-		private Task _initializeWebSocket()
+		public Task InitializeWebSocket()
 		{
 			// do not attempt to initialize if cancellation is requested
 			if(_disposed != null)
 				throw new OperationCanceledException();
 
 			// if an initialization task is already running, return that
-			if(_initializeWebSocketTask != null &&
-			   !_initializeWebSocketTask.IsFaulted &&
-			   !_initializeWebSocketTask.IsCompleted)
-				return _initializeWebSocketTask;
+			if(InitializeWebSocketTask != null &&
+			   !InitializeWebSocketTask.IsFaulted &&
+			   !InitializeWebSocketTask.IsCompleted)
+				return InitializeWebSocketTask;
 
 			// if the websocket is open, return a completed task
 			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
@@ -93,28 +83,73 @@ private Task _initializeWebSocket()
 			clientWebSocket?.Dispose();
 			clientWebSocket = new ClientWebSocket();
 			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-			return _initializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+		}
+
+		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		{
+			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
+				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLWebSocketResponse>());
+		}
+
+		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
+		{
+			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			return new CompositeDisposable
+			(
+				observable.Subscribe(observer),
+				Disposable.Create(() =>
+				{
+					Debug.WriteLine("response stream disposed");
+				})
+			);
 		}
 
 		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
-			await _initializeWebSocket().ConfigureAwait(false);
-			return Observable.Defer(() => _receiveResultAsync().ToObservable()).Repeat();
+			await InitializeWebSocket().ConfigureAwait(false);
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			Debug.WriteLine($"opening websocket {this.GetHashCode()}");
+			await _backOff().ConfigureAwait(false);
+			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on websocket {this.GetHashCode()}");
+			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+			_connectionAttempt = 1;
+		}
+
+
+		private Task<GraphQLWebSocketResponse> _receiveAsyncTask = null;
+		private object _receiveTaskLocker = new object();
+		/// <summary>
+		/// wrapper method to pick up the existing request task if already running
+		/// </summary>
+		/// <returns></returns>
+		private Task<GraphQLWebSocketResponse> _getReceiveTask()
+		{
+			lock (_receiveTaskLocker)
+			{
+				if (_receiveAsyncTask == null ||
+				    _receiveAsyncTask.IsFaulted ||
+				    _receiveAsyncTask.IsCompleted)
+					_receiveAsyncTask = _receiveResultAsync();
+			}
+
+			return _receiveAsyncTask;
 		}
 
 		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
 			try
 			{
+				Debug.WriteLine("receiving websocket data ...");
 				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
+				var webSocketReceiveResult =
+					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
 				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
 				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
 				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
@@ -124,6 +159,10 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 				Console.WriteLine(e);
 				throw;
 			}
+			finally
+			{
+				Debug.WriteLine("websocket data received");
+			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)
@@ -136,11 +175,11 @@ private async Task _closeAsync(CancellationToken cancellationToken = default)
 			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
 			    this.clientWebSocket.State != WebSocketState.CloseSent)
 			{
-				Debug.WriteLine($"websocket {this.GetHashCode()} state = {this.clientWebSocket.State}");
+				Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
 				return;
 			}
 
-			Debug.WriteLine($"closing websocket {this.GetHashCode()}");
+			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
 		}
 
@@ -161,13 +200,13 @@ public void Dispose()
 
 		private async Task DisposeAsync()
 		{
-			Debug.WriteLine($"disposing websocket {this.GetHashCode()}...");
+			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
 			await _closeAsync().ConfigureAwait(false);
 			clientWebSocket?.Dispose();
 			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"websocket {this.GetHashCode()} disposed");
+			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
 		}
 		#endregion
 	}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index bd9f52d7..36804c95 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -148,7 +148,7 @@ public async void CanReconnectWithSameObservable()
 				tester = observable.SubscribeTester();
 				tester.ShouldHaveReceivedUpdate(
 					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value); },
-					TimeSpan.FromSeconds(3));
+					TimeSpan.FromSeconds(10));
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string) response.Data.addMessage.content);
@@ -182,12 +182,14 @@ public async void CanReconnectWithSameObservable()
 		public async void CanConnectMultipleSubscriptionsSimultaneously()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var callbackTester = new CallbackTester<Exception>();
+			var callbackTester2 = new CallbackTester<Exception>();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest);
+				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = subscription1.SubscribeTester();
@@ -200,13 +202,13 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2);
+				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
 				var tester2 = subscription2.SubscribeTester();
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
-				}, TimeSpan.FromSeconds(3));
+				}, TimeSpan.FromSeconds(10));
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
@@ -282,7 +284,7 @@ public async void CanHandleConnectionTimeout()
 
 			// disposing the client should complete the subscription
 			client.Dispose();
-			tester.ShouldHaveCompleted();
+			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
 			server.Dispose();
 		}
 	}

From 424f561a7444083d1da404675bffc78c0d5b0154 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 11 Dec 2018 21:51:40 +0100
Subject: [PATCH 022/455] Use single websocket for all subscriptions (#84)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart
---
 GraphQL.Client.sln                            |   9 +-
 .../Program.cs                                |  44 +++
 ...iptionIntegrationTest.ConsoleClient.csproj |  13 +
 root.props                                    |   2 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |   6 +
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  49 +++-
 .../Http/GraphQLHttpClientOptions.cs          |  18 +-
 .../Http/GraphQLHttpObservableSubscription.cs | 268 ------------------
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 144 ++++++++++
 .../Http/GraphQLHttpSubscriptionResult.cs     |  98 +------
 .../Http/GraphQLHttpWebSocket.cs              | 213 ++++++++++++++
 .../Http/GraphQLSubscriptionException.cs      |  32 +++
 src/GraphQL.Client/IGraphQLClient.cs          |  34 +++
 src/GraphQL.Common/GQLWebSocketMessageType.cs |  93 ++++++
 ...nRequest.cs => GraphQLWebSocketRequest.cs} |  10 +-
 ...esponse.cs => GraphQLWebSocketResponse.cs} |  10 +-
 .../CallbackTester.cs                         |  81 ++++++
 .../GraphQLClientExtensions.cs                |   2 +-
 .../NetworkHelpers.cs                         |  17 ++
 .../ObservableTester.cs                       |  49 ++--
 .../SubscriptionsTest.cs                      | 225 +++++++++++++--
 21 files changed, 993 insertions(+), 424 deletions(-)
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/Program.cs
 create mode 100644 SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
 delete mode 100644 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
 create mode 100644 src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
 create mode 100644 src/GraphQL.Common/GQLWebSocketMessageType.cs
 rename src/GraphQL.Common/Request/{GraphQLSubscriptionRequest.cs => GraphQLWebSocketRequest.cs} (73%)
 rename src/GraphQL.Common/Response/{GraphQLSubscriptionResponse.cs => GraphQLWebSocketResponse.cs} (72%)
 create mode 100644 tests/GraphQL.Integration.Tests/CallbackTester.cs
 create mode 100644 tests/GraphQL.Integration.Tests/NetworkHelpers.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 722a7d85..aa9d13e0 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.27130.2010
@@ -49,6 +49,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SubscriptionIntegrationTest.ConsoleClient", "SubscriptionIntegrationTest.ConsoleClient\SubscriptionIntegrationTest.ConsoleClient.csproj", "{D588BC10-6B17-477F-9546-F8D1CE02EACB}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -83,6 +85,10 @@ Global
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -97,6 +103,7 @@ Global
 		{B21E97C3-F328-473F-A054-A4BF272B63F0} = {9413EC62-CDDE-4E77-9784-E1136EA5D1EE}
 		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{D588BC10-6B17-477F-9546-F8D1CE02EACB} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
new file mode 100644
index 00000000..a891236a
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -0,0 +1,44 @@
+using System;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+
+namespace SubsccriptionIntegrationTest.ConsoleClient
+{
+	class Program
+	{
+		static void Main(string[] args)
+		{
+			Console.WriteLine("configuring client ...");
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			{
+#pragma warning disable 618
+				var stream = client.CreateSubscriptionStream(new GraphQLRequest
+					{
+						Query = @"
+							subscription {
+							  messageAdded{
+							    content
+								from {
+								  displayName
+								}
+							  }
+							}"
+					},
+					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+#pragma warning restore 618
+
+				Console.WriteLine("subscribing to message stream ...");
+				using (var subscription = stream.Subscribe(
+					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
+					() => Console.WriteLine($"message subscription stream completed")))
+				{
+					Console.WriteLine("client setup complete");
+					Console.WriteLine("press any key to exit");
+					Console.Read();
+					Console.WriteLine("shutting down ...");
+				}
+			}
+		}
+	}
+}
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
new file mode 100644
index 00000000..21901c2f
--- /dev/null
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
+    <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/root.props b/root.props
index e2fc2d0c..d00301d1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.3</Version>
+		<Version>2.0.0-alpha.subscriptions-api.10</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 200758df..97a78f0e 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -17,6 +17,12 @@
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <Reference Include="System.Reactive">
+	    <HintPath>C:\Users\arose\.nuget\packages\system.reactive\4.1.2\lib\netstandard2.0\System.Reactive.dll</HintPath>
+	  </Reference>
+	</ItemGroup>
+
 	<!-- Allow method ReadAsAsync<T>
 	<ItemGroup>
 		<PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.4" />
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index fe8f4710..90209d40 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Reactive.Linq;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -41,6 +41,7 @@ public GraphQLHttpClientOptions Options {
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
+		internal readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		/// <summary>
@@ -76,6 +77,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		/// <summary>
@@ -90,6 +92,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
@@ -100,6 +103,7 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
@@ -141,10 +145,35 @@ private Uri _getWebSocketUri()
 			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
 		}
 
+		/// <inheritdoc />
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token);
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
+				Options, cancellationToken: _cancellationTokenSource.Token);
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+		{
+			return CreateSubscriptionStream(request, e =>
+			{
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
+		{
+			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
 			return observable;
 		}
 
@@ -153,7 +182,23 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		/// </summary>
 		public void Dispose()
 		{
+			lock (_disposeLocker)
+			{
+				if (!_disposed)
+				{
+					_dispose();
+				}
+			}
+		}
+
+		private bool _disposed = false;
+		private object _disposeLocker = new object();
+
+		private void _dispose()
+		{
+			_disposed = true;
 			this.graphQLHttpHandler.Dispose();
+			this.graphQlHttpWebSocket.Dispose();
 			_cancellationTokenSource.Cancel();
 			_cancellationTokenSource.Dispose();
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 9ff6b091..38008421 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -1,7 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.Http {
@@ -20,7 +23,11 @@ public class GraphQLHttpClientOptions {
 		/// The <see cref="Newtonsoft.Json.JsonSerializerSettings"/> that is going to be used
 		/// </summary>
 		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver()
+			ContractResolver = new CamelCasePropertyNamesContractResolver(),
+			Converters = new List<JsonConverter>
+			{
+				new StringEnumConverter()
+			}
 		};
 
 		/// <summary>
@@ -33,6 +40,15 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public MediaTypeHeaderValue MediaType { get; set; } = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
+		/// <summary>
+		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
+		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+		/// </summary>
+		public Func<int, TimeSpan> BackOffStrategy = n =>
+		{
+			var rnd = new Random();
+			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+		};
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
deleted file mode 100644
index d3f71990..00000000
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ /dev/null
@@ -1,268 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Net.WebSockets;
-using System.Reactive.Linq;
-using System.Reactive.Threading.Tasks;
-using System.Runtime.Serialization;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-
-namespace GraphQL.Client.Http {
-
-	/// <summary>
-	/// Represents the result of a subscription query
-	/// </summary>
-	[Obsolete("EXPERIMENTAL API")]
-	public class GraphQLHttpObservableSubscription : IDisposable {
-
-		private readonly ClientWebSocket clientWebSocket = new ClientWebSocket();
-		private readonly Uri webSocketUri;
-		private readonly GraphQLRequest graphQLRequest;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
-		private readonly CancellationTokenSource _cancellationTokenSource;
-
-		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default) {
-			_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-			_cancellationTokenSource.Token.Register(Dispose);
-			this.webSocketUri = webSocketUri;
-			this.graphQLRequest = graphQLRequest;
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-			arraySegment = new ArraySegment<byte>(buffer);
-		}
-
-		public async Task ConnectAsync(CancellationToken token)
-		{
-			Debug.WriteLine($"opening websocket on subscription {this.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
-		}
-
-		public async Task<GraphQLResponse> ReceiveResultAsync()
-		{
-			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
-			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
-			switch (webSocketResponse.Type)
-			{
-				case GQLWebSocketMessageType.GQL_COMPLETE:
-					Debug.WriteLine($"received 'complete' message on subscription {this.GetHashCode()}");
-					Dispose();
-					break;
-				case GQLWebSocketMessageType.GQL_ERROR:
-					Debug.WriteLine($"received 'error' message on subscription {this.GetHashCode()}");
-					throw new GQLSubscriptionException(webSocketResponse.Payload);
-				default:
-					Debug.WriteLine($"received payload on subscription {this.GetHashCode()}");
-					break;
-			}
-
-			return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
-		}
-
-		public async Task CloseAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
-			if (this.clientWebSocket.State == WebSocketState.Open) {
-				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
-			}
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
-		}
-
-		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_START,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
-		{
-			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
-			var webSocketRequest = new GraphQLSubscriptionRequest
-			{
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_STOP,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default)
-		{
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
-		}
-
-		#region IDisposable
-
-		public void Dispose()
-		{
-			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			if(Disposed == null) Disposed = DisposeAsync();
-		}
-
-		public Task Disposed { get; private set; }
-
-		private async Task DisposeAsync()
-		{
-			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
-			if(!_cancellationTokenSource.IsCancellationRequested)
-				_cancellationTokenSource.Cancel();
-			await CloseAsync().ConfigureAwait(false);
-			clientWebSocket?.Dispose();
-			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
-		}
-
-		#endregion
-
-		#region Static Factories
-
-		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
-		{
-			return Observable.Using(
-				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
-				InitializeSubscription
-				).Publish().RefCount();
-		}
-
-
-		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
-		{
-			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
-			return Task.FromResult(subscription);
-		}
-
-		private static async Task<IObservable<GraphQLResponse>> InitializeSubscription(GraphQLHttpObservableSubscription observableSubscription, CancellationToken cancelToken)
-		{
-			await observableSubscription.ConnectAsync(cancelToken).ConfigureAwait(false);
-			await observableSubscription.SendInitialMessageAsync(cancelToken).ConfigureAwait(false);
-			return Observable.Defer(() => observableSubscription.ReceiveResultAsync().ToObservable()).Repeat();
-		}
-
-		#endregion
-
-		[Serializable]
-		public class GQLSubscriptionException : Exception
-		{
-			//
-			// For guidelines regarding the creation of new exception types, see
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
-			// and
-			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
-			//
-
-			public GQLSubscriptionException()
-			{
-			}
-
-			public GQLSubscriptionException(object error) : base(error.ToString())
-			{
-			}
-
-			protected GQLSubscriptionException(
-				SerializationInfo info,
-				StreamingContext context) : base(info, context)
-			{
-			}
-		}
-
-		public static class GQLWebSocketMessageType
-		{
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-		}
-	}
-}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
new file mode 100644
index 00000000..512dc443
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -0,0 +1,144 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Http
+{
+	public static class GraphQLHttpSubscriptionHelpers
+	{
+		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			GraphQLRequest request,
+			GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLHttpClientOptions options,
+			Action<Exception> exceptionHandler = null,
+			CancellationToken cancellationToken = default)
+		{
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse>(async observer =>
+				{
+					var startRequest = new GraphQLWebSocketRequest
+					{
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var closeRequest = new GraphQLWebSocketRequest
+					{
+						Id = startRequest.Id,
+						Type = GQLWebSocketMessageType.GQL_STOP
+					};
+					var observable = graphQlHttpWebSocket.ResponseStream
+						.Where(response => response.Id == startRequest.Id)
+						.SelectMany(response =>
+						{
+							switch (response.Type)
+							{
+								case GQLWebSocketMessageType.GQL_COMPLETE:
+									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+									return Observable.Empty<GraphQLResponse>();
+								case GQLWebSocketMessageType.GQL_ERROR:
+									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
+									return Observable.Throw<GraphQLResponse>(
+										new GraphQLSubscriptionException(response.Payload));
+								default:
+									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+									return Observable.Return(((JObject) response?.Payload)
+										?.ToObject<GraphQLResponse>());
+							}
+						});
+
+					try
+					{
+						// intialize websocket (completes immediately if socket is already open)
+						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						// subscribe observer to failed observable
+						return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+					}
+
+					var disposable = new CompositeDisposable(
+						observable.Subscribe(observer),
+						Disposable.Create(async () =>
+						{
+							// only try to send close request on open websocket
+							if (graphQlHttpWebSocket.WebSocketState != WebSocketState.Open) return;
+
+							try
+							{
+								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+							}
+							// do not break on disposing
+							catch (OperationCanceledException) { }
+						})
+					);
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					try
+					{
+						await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+					}
+					catch (Exception e)
+					{
+						Console.WriteLine(e);
+						throw;
+					}
+
+					return disposable;
+				}))
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLResponse>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+				{
+					try
+					{
+						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
+						if (exceptionHandler == null) throw e;
+
+						// exceptions thrown by the handler will propagate to OnError()
+						exceptionHandler?.Invoke(e);
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						return cancellationToken.IsCancellationRequested
+							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
+							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
+					}
+					catch (Exception exception)
+					{
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the websocket for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t =>
+				{
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLResponse>(t.Item2);
+
+					return t.Item1 == null
+						? Observable.Empty<GraphQLResponse>()
+						: Observable.Return(t.Item1);
+				})
+				// transform to hot observable and auto-connect
+				.Publish().RefCount();
+		}
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
index e0c2dc6d..34ab6f0a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
@@ -3,6 +3,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
@@ -38,7 +39,7 @@ public async void StartAsync(CancellationToken cancellationToken = default) {
 				while (this.clientWebSocket.State == WebSocketState.Open) {
 					var webSocketReceiveResult = await this.clientWebSocket.ReceiveAsync(arraySegment, cancellationToken);
 					var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 					if (webSocketResponse != null)
 					{
 						var response = (GraphQLResponse) webSocketResponse.Payload;
@@ -62,7 +63,7 @@ public void Dispose() {
 		}
 
 		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_START,
 				Payload = this.graphQLRequest
@@ -71,7 +72,7 @@ private Task SendInitialMessageAsync(CancellationToken cancellationToken = defau
 		}
 
 		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLSubscriptionRequest {
+			var webSocketRequest = new GraphQLWebSocketRequest {
 				Id = "1",
 				Type = GQLWebSocketMessageType.GQL_STOP,
 				Payload = this.graphQLRequest
@@ -79,98 +80,11 @@ private Task SendCloseMessageAsync(CancellationToken cancellationToken = default
 			return this.SendGraphQLSubscriptionRequest(webSocketRequest);
 		}
 
-		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default) {
-			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+		private Task SendGraphQLSubscriptionRequest(GraphQLWebSocketRequest graphQlWebSocketRequest, CancellationToken cancellationToken = default) {
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQlWebSocketRequest);
 			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
 			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
 		}
-
-		private static class GQLWebSocketMessageType {
-
-			/// <summary>
-			///     Client sends this message after plain websocket connection to start the communication with the server
-			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-			///     to this message.
-			///     payload: Object : optional parameters that the client specifies in connectionParams
-			/// </summary>
-			public const string GQL_CONNECTION_INIT = "connection_init";
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-			///     the connection.
-			/// </summary>
-			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
-
-			/// <summary>
-			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-			///     the connection.
-			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-			///     client, just ignore the message).
-			///     payload: Object: the server side error
-			/// </summary>
-			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
-
-			/// <summary>
-			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-			///     client connection alive.
-			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-			///     server.
-			///     <remarks>
-			///         NOTE: This one here don't follow the standard due to connection optimization
-			///     </remarks>
-			/// </summary>
-			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
-
-			/// <summary>
-			///     Client sends this message to execute GraphQL operation
-			///     id: string : The id of the GraphQL operation to start
-			///     payload: Object:
-			///     query: string : GraphQL operation as string or parsed GraphQL document node
-			///     variables?: Object : Object with GraphQL variables
-			///     operationName?: string : GraphQL operation name
-			/// </summary>
-			public const string GQL_START = "start";
-
-			/// <summary>
-			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-			///     is a response for GQL_START message.
-			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-			///     id: string : ID of the operation that was successfully set up
-			///     payload: Object :
-			///     data: any: Execution result
-			///     errors?: Error[] : Array of resolvers errors
-			/// </summary>
-			public const string GQL_DATA = "data"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-			///     payload: Error : payload with the error attributed to the operation failing on the server
-			///     id: string : operation ID of the operation that failed on the server
-			/// </summary>
-			public const string GQL_ERROR = "error"; // Server -> Client
-
-			/// <summary>
-			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-			///     specific operation.
-			///     id: string : operation ID of the operation that completed
-			/// </summary>
-			public const string GQL_COMPLETE = "complete"; // Server -> Client
-
-			/// <summary>
-			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-			///     id: string : operation id
-			/// </summary>
-			public const string GQL_STOP = "stop"; // Client -> Server
-
-		}
-
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
new file mode 100644
index 00000000..c5e2d349
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -0,0 +1,213 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Reactive.Threading.Tasks;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json;
+
+namespace GraphQL.Client.Http
+{
+	internal class GraphQLHttpWebSocket: IDisposable
+	{
+		private readonly Uri webSocketUri;
+		private readonly GraphQLHttpClientOptions _options;
+		private readonly byte[] buffer = new byte[1024 * 1024];
+		private readonly ArraySegment<byte> arraySegment;
+		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+
+		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+
+		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
+
+		private ClientWebSocket clientWebSocket = null;
+		private int _connectionAttempt = 0;
+
+		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
+		{
+			this.webSocketUri = webSocketUri;
+			_options = options;
+			arraySegment = new ArraySegment<byte>(buffer);
+			ResponseStream = _createResponseStream();
+		}
+
+		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+
+
+		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			await InitializeWebSocket().ConfigureAwait(false);
+			var webSocketRequestString = JsonConvert.SerializeObject(request);
+			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+		}
+
+		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
+
+		#region Private Methods
+
+		private Task _backOff()
+		{
+			_connectionAttempt++;
+
+			if(_connectionAttempt == 1) return Task.CompletedTask;
+
+			var delay = _options.BackOffStrategy(_connectionAttempt - 1);
+			Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
+			return Task.Delay(delay);
+		}
+
+		public Task InitializeWebSocket()
+		{
+			// do not attempt to initialize if cancellation is requested
+			if(_disposed != null)
+				throw new OperationCanceledException();
+
+			// if an initialization task is already running, return that
+			if(InitializeWebSocketTask != null &&
+			   !InitializeWebSocketTask.IsFaulted &&
+			   !InitializeWebSocketTask.IsCompleted)
+				return InitializeWebSocketTask;
+
+			// if the websocket is open, return a completed task
+			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+				return Task.CompletedTask;
+
+			// else (re-)create websocket and connect
+			clientWebSocket?.Dispose();
+			clientWebSocket = new ClientWebSocket();
+			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+		}
+
+		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		{
+			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
+				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLWebSocketResponse>());
+		}
+
+		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
+		{
+			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			return new CompositeDisposable
+			(
+				observable.Subscribe(observer),
+				Disposable.Create(() =>
+				{
+					Debug.WriteLine("response stream disposed");
+				})
+			);
+		}
+
+		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
+		{
+			await InitializeWebSocket().ConfigureAwait(false);
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
+		}
+
+		private async Task _connectAsync(CancellationToken token)
+		{
+			await _backOff().ConfigureAwait(false);
+			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+			_connectionAttempt = 1;
+		}
+
+
+		private Task<GraphQLWebSocketResponse> _receiveAsyncTask = null;
+		private object _receiveTaskLocker = new object();
+		/// <summary>
+		/// wrapper method to pick up the existing request task if already running
+		/// </summary>
+		/// <returns></returns>
+		private Task<GraphQLWebSocketResponse> _getReceiveTask()
+		{
+			lock (_receiveTaskLocker)
+			{
+				if (_receiveAsyncTask == null ||
+				    _receiveAsyncTask.IsFaulted ||
+				    _receiveAsyncTask.IsCompleted)
+					_receiveAsyncTask = _receiveResultAsync();
+			}
+
+			return _receiveAsyncTask;
+		}
+
+		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
+		{
+			try
+			{
+				Debug.WriteLine("receiving websocket data ...");
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var webSocketReceiveResult =
+					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
+				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+				throw;
+			}
+			finally
+			{
+				Debug.WriteLine("websocket data received");
+			}
+		}
+
+		private async Task _closeAsync(CancellationToken cancellationToken = default)
+		{
+			if(clientWebSocket == null)
+				return;
+
+			// don't attempt to close the websocket if it is in a failed state
+			if (this.clientWebSocket.State != WebSocketState.Open &&
+			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
+			    this.clientWebSocket.State != WebSocketState.CloseSent)
+			{
+				Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
+				return;
+			}
+
+			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+		}
+
+		#endregion
+
+		#region IDisposable
+
+		private Task _disposed;
+		private object _disposedLocker = new object();
+		public void Dispose()
+		{
+			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+			lock (_disposedLocker)
+			{
+				if (_disposed == null) _disposed = DisposeAsync();
+			}
+		}
+
+		private async Task DisposeAsync()
+		{
+			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
+			if (!_cancellationTokenSource.IsCancellationRequested)
+				_cancellationTokenSource.Cancel();
+			await _closeAsync().ConfigureAwait(false);
+			clientWebSocket?.Dispose();
+			_cancellationTokenSource.Dispose();
+			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
+		}
+		#endregion
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
new file mode 100644
index 00000000..7aad64f0
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLSubscriptionException.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace GraphQL.Client.Http
+{
+	[Serializable]
+	public class GraphQLSubscriptionException : Exception
+	{
+		//
+		// For guidelines regarding the creation of new exception types, see
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+		// and
+		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+		//
+
+		public GraphQLSubscriptionException()
+		{
+		}
+
+		public GraphQLSubscriptionException(object error) : base(error.ToString())
+		{
+		}
+
+		protected GraphQLSubscriptionException(
+			SerializationInfo info,
+			StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 3343da14..60af36ab 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Common.Request;
@@ -36,8 +37,41 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// The stream must be recreated completely after an error has occured within its logic (i.e. a <see cref="WebSocketException"/>)
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 	}
 
 }
diff --git a/src/GraphQL.Common/GQLWebSocketMessageType.cs b/src/GraphQL.Common/GQLWebSocketMessageType.cs
new file mode 100644
index 00000000..1e2fff76
--- /dev/null
+++ b/src/GraphQL.Common/GQLWebSocketMessageType.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Common
+{
+	public static class GQLWebSocketMessageType
+	{
+
+		/// <summary>
+		///     Client sends this message after plain websocket connection to start the communication with the server
+		///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+		///     to this message.
+		///     payload: Object : optional parameters that the client specifies in connectionParams
+		/// </summary>
+		public const string GQL_CONNECTION_INIT = "connection_init";
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+		///     the connection.
+		/// </summary>
+		public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+
+		/// <summary>
+		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+		///     the connection.
+		///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+		///     client, just ignore the message).
+		///     payload: Object: the server side error
+		/// </summary>
+		public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+
+		/// <summary>
+		///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+		///     client connection alive.
+		///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+		///     server.
+		///     <remarks>
+		///         NOTE: This one here don't follow the standard due to connection optimization
+		///     </remarks>
+		/// </summary>
+		public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+
+		/// <summary>
+		///     Client sends this message to execute GraphQL operation
+		///     id: string : The id of the GraphQL operation to start
+		///     payload: Object:
+		///     query: string : GraphQL operation as string or parsed GraphQL document node
+		///     variables?: Object : Object with GraphQL variables
+		///     operationName?: string : GraphQL operation name
+		/// </summary>
+		public const string GQL_START = "start";
+
+		/// <summary>
+		///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+		///     is a response for GQL_START message.
+		///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+		///     id: string : ID of the operation that was successfully set up
+		///     payload: Object :
+		///     data: any: Execution result
+		///     errors?: Error[] : Array of resolvers errors
+		/// </summary>
+		public const string GQL_DATA = "data"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+		///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+		///     payload: Error : payload with the error attributed to the operation failing on the server
+		///     id: string : operation ID of the operation that failed on the server
+		/// </summary>
+		public const string GQL_ERROR = "error"; // Server -> Client
+
+		/// <summary>
+		///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+		///     specific operation.
+		///     id: string : operation ID of the operation that completed
+		/// </summary>
+		public const string GQL_COMPLETE = "complete"; // Server -> Client
+
+		/// <summary>
+		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+		///     id: string : operation id
+		/// </summary>
+		public const string GQL_STOP = "stop"; // Client -> Server
+
+	}
+}
diff --git a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
similarity index 73%
rename from src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
rename to src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index a468a0b3..46e14dce 100644
--- a/src/GraphQL.Common/Request/GraphQLSubscriptionRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Request {
 	/// A Subscription Request
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest> {
+	public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionRequest : IEquatable<GraphQLSubscriptionRequest>
 		public GraphQLRequest Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionRequest);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionRequest other) {
+		public bool Equals(GraphQLWebSocketRequest other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => EqualityComparer<GraphQLSubscriptionRequest>.Default.Equals(request1, request2);
+		public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionRequest request1, GraphQLSubscriptionRequest request2) => !(request1 == request2);
+		public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
 
 	}
 
diff --git a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
similarity index 72%
rename from src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
rename to src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
index 71c47c72..cd3fb2f4 100644
--- a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
+++ b/src/GraphQL.Common/Response/GraphQLWebSocketResponse.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Common.Response {
 	/// A Subscription Response
 	/// </summary>
 	[Obsolete("EXPERIMENTAL")]
-	public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionResponse> {
+	public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse> {
 
 		/// <summary>
 		/// The Identifier of the Response
@@ -25,10 +25,10 @@ public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionRespons
 		public dynamic Payload { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionResponse);
+		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLSubscriptionResponse other) {
+		public bool Equals(GraphQLWebSocketResponse other) {
 			if (other == null) {
 				return false;
 			}
@@ -57,10 +57,10 @@ public override int GetHashCode() {
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => EqualityComparer<GraphQLSubscriptionResponse>.Default.Equals(response1, response2);
+		public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLSubscriptionResponse response1, GraphQLSubscriptionResponse response2) => !(response1 == response2);
+		public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => !(response1 == response2);
 
 	}
 
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
new file mode 100644
index 00000000..bf214d73
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+	public class CallbackTester<T>
+	{
+		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool CallbackInvoked => _callbackInvoked.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		public void Callback(T param)
+		{
+			LastPayload = param;
+			_callbackInvoked.Set();
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null)
+		{
+			try
+			{
+				if (!_callbackInvoked.Wait(timeout ?? Timeout))
+					Assert.True(false, $"callback not invoked within {(timeout ?? Timeout).TotalSeconds} s!");
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null)
+		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
+			try
+			{
+				if (_callbackInvoked.Wait(timeout.Value))
+					Assert.True(false, "callback was inadvertently invoked pushed!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset()
+		{
+			LastPayload = default(T);
+			_callbackInvoked.Reset();
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index e8b4babf..c7dd0568 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -22,7 +22,7 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 				{
 					input = new
 					{
-						fromId = "me",
+						fromId = "2",
 						content = message,
 						sentAt = DateTime.Now
 					}
diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
new file mode 100644
index 00000000..1462767e
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
@@ -0,0 +1,17 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class NetworkHelpers
+	{
+		public static int GetFreeTcpPortNumber()
+		{
+			var l = new TcpListener(IPAddress.Loopback, 0);
+			l.Start();
+			var port = ((IPEndPoint)l.LocalEndpoint).Port;
+			l.Stop();
+			return port;
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index e7993a36..1569176d 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -20,7 +20,7 @@ public class ObservableTester<T> : IDisposable
 		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
 		/// <summary>
-		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// Indicates that an update has been received since the last <see cref="_reset"/>
 		/// </summary>
 		public bool UpdateReceived => _updateReceived.IsSet;
 		/// <summary>
@@ -51,84 +51,85 @@ public ObservableTester(IObservable<T> observable)
 		}
 
 		/// <summary>
-		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>.
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_updateReceived.Wait(Timeout))
-					Assert.True(false, "no update received!");
+				if (!_updateReceived.Wait(timeout ?? Timeout))
+					Assert.True(false, $"no update received within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertPayload?.Invoke(LastPayload);
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
+		public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null)
 		{
+			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
 			try
 			{
-				if (_updateReceived.Wait(100))
+				if (_updateReceived.Wait(timeout.Value))
 					Assert.True(false, "update was inadvertently pushed!");
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveCompleted()
+		public void ShouldHaveCompleted(TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_completed.Wait(Timeout))
-					Assert.True(false, "subscription did not complete!");
+				if (!_completed.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not complete within {(timeout ?? Timeout).TotalSeconds} s!");
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveThrownError(Action<Exception> assertError = null)
+		public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan? timeout = null)
 		{
 			try
 			{
-				if (!_error.Wait(Timeout))
-					Assert.True(false, "subscription did not throw an error!");
+				if (!_error.Wait(timeout ?? Timeout))
+					Assert.True(false, $"subscription did not throw an error within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertError?.Invoke(Error);
 			}
 			finally
 			{
-				Reset();
+				_reset();
 			}
 		}
 
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
-		public void Reset()
+		private void _reset()
 		{
-			if (_completed.IsSet)
-				throw new InvalidOperationException(
-					"the subscription sequence has completed. this tester instance cannot be reused");
+			//if (_completed.IsSet)
+			//	throw new InvalidOperationException(
+			//		"the subscription sequence has completed. this tester instance cannot be reused");
 
 			LastPayload = default(T);
 			_updateReceived.Reset();
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index f8a66760..36804c95 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
@@ -36,16 +38,20 @@ public static IWebHost CreateServer(int port)
 		private readonly IWebHost _server;
 
 		public SubscriptionsTest()
-		{}
+		{
+		}
 
 		private GraphQLHttpClient GetGraphQLClient(int port)
-			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
+			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
+			{
+				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+			} );
 
 
 		[Fact]
 		public async void AssertTestingHarness()
 		{
-			var port = 5001;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
@@ -53,29 +59,31 @@ public async void AssertTestingHarness()
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
-				Assert.Equal(message, (string)response.Data.addMessage.content);
+				Assert.Equal(message, (string) response.Data.addMessage.content);
 			}
 		}
 
+		private const string SubscriptionQuery = @"
+			subscription {
+			  messageAdded{
+			    content
+			  }
+			}";
+
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
+		{
+			Query = SubscriptionQuery
+		};
+
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
-			var port = 5002;
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
-				var graphQLRequest = new GraphQLRequest
-				{
-					Query = @"
-					subscription {
-					  messageAdded{
-					    content
-					  }
-					}"
-				};
-
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -89,26 +97,195 @@ public async void CanCreateObservableSubscription()
 					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				tester.Reset();
-
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				// disposing the client should throw a TaskCanceledException on the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		[Fact]
+		public async void CanReconnectWithSameObservable()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+
+				const string message1 = "Hello World";
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
+
+				Debug.WriteLine("creating new subscription...");
+				tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(
+					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value); },
+					TimeSpan.FromSeconds(10));
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string) response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message3, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester.ShouldHaveCompleted();
+			}
+		}
+
+		private const string SubscriptionQuery2 = @"
+			subscription {
+			  messageAdded{
+			    content
+				from {
+				  displayName
+				}
+			  }
+			}";
+
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
+		{
+			Query = SubscriptionQuery2
+		};
+
+		[Fact]
+		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var callbackTester = new CallbackTester<Exception>();
+			var callbackTester2 = new CallbackTester<Exception>();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+
+				Debug.WriteLine("subscribing...");
+				var tester = subscription1.SubscribeTester();
+
+				const string message1 = "Hello World";
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
+				var tester2 = subscription2.SubscribeTester();
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+				}, TimeSpan.FromSeconds(10));
+
+				const string message2 = "How are you?";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
 				Assert.Equal(message2, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+				});
 
-				tester.Reset();
+				Debug.WriteLine("disposing subscription...");
+				tester.Dispose();
 
-				// disposing the client should throw a TaskCanceledException on the subscription
-				client.Dispose();
-				tester.ShouldHaveThrownError(exception =>
+				const string message3 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
+				Assert.Equal(message3, (string)response.Data.addMessage.content);
+				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.True(exception is TaskCanceledException,
-							$"exception is of unexpected type {exception.GetType().Name}");
+					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				});
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester2.ShouldHaveCompleted();
+			}
+		}
+
+		[Fact]
+		public async void CanHandleConnectionTimeout()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			var server = CreateServer(port);
+			var callbackTester = new CallbackTester<Exception>();
+
+			var client = GetGraphQLClient(port);
+			Debug.WriteLine("creating subscription stream");
+			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+
+			Debug.WriteLine("subscribing...");
+			var tester = observable.SubscribeTester();
+			const string message1 = "Hello World";
+
+			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+			Assert.Equal(message1, (string)response.Data.addMessage.content);
+
+			tester.ShouldHaveReceivedUpdate(gqlResponse =>
+			{
+				Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+			});
+
+			Debug.WriteLine("stopping web host...");
+			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
+			Debug.WriteLine("web host stopped...");
+
+			callbackTester.CallbackShouldHaveBeenInvoked(exception =>
+			{
+				Assert.IsType<WebSocketException>(exception);
+			}, TimeSpan.FromSeconds(10));
+
+			try
+			{
+				server.Start();
 			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+			}
+
+			// disposing the client should complete the subscription
+			client.Dispose();
+			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
+			server.Dispose();
 		}
 	}
 }

From 16a9bd8ac69678f2714fcfed1fb8e1f9576e59f4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Dec 2018 08:33:05 +0100
Subject: [PATCH 023/455] create "queue" for requests so that only one send
 operation is performed at a time

---
 .../Http/GraphQLHttpWebSocket.cs              | 34 ++++++++++++++++---
 .../Request/GraphQLWebSocketRequest.cs        | 25 ++++++++++++++
 2 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index c5e2d349..fec75db2 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
+using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
@@ -23,6 +24,8 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
@@ -35,17 +38,38 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			_options = options;
 			arraySegment = new ArraySegment<byte>(buffer);
 			ResponseStream = _createResponseStream();
+
+			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
 		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
 
+		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			_requestSubject.OnNext(request);
+			return request.SendTask();
+		}
 
-		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			await InitializeWebSocket().ConfigureAwait(false);
-			var webSocketRequestString = JsonConvert.SerializeObject(request);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+			try
+			{
+				if (_cancellationTokenSource.Token.IsCancellationRequested)
+				{
+					request.SendCanceled();
+					return;
+				}
+
+				await InitializeWebSocket().ConfigureAwait(false);
+				var webSocketRequestString = JsonConvert.SerializeObject(request);
+				var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+				await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+				request.SendCompleted();
+			}
+			catch (Exception e)
+			{
+				request.SendFailed(e);
+			}
 		}
 
 		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
diff --git a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index 46e14dce..d805efc4 100644
--- a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace GraphQL.Common.Request {
 
@@ -24,6 +25,30 @@ public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 		/// </summary>
 		public GraphQLRequest Payload { get; set; }
 
+		private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
+
+		/// <summary>
+		/// Task used to await the actual send operation and to convey potential exceptions
+		/// </summary>
+		/// <returns></returns>
+		public Task SendTask() => _tcs.Task;
+
+		/// <summary>
+		/// gets called when the send operation for this request has completed sucessfully
+		/// </summary>
+		public void SendCompleted() => _tcs.SetResult(true);
+
+		/// <summary>
+		/// gets called when an exception occurs during the send operation
+		/// </summary>
+		/// <param name="e"></param>
+		public void SendFailed(Exception e) => _tcs.SetException(e);
+
+		/// <summary>
+		/// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
+		/// </summary>
+		public void SendCanceled() => _tcs.SetCanceled();
+
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 

From c37fe83d0cc6ec54f68dbf1c60a39babe42144f8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Dec 2018 12:33:01 +0100
Subject: [PATCH 024/455] fix websockets on win 7

---
 root.props                                    |  2 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |  2 ++
 .../Http/GraphQLHttpWebSocket.cs              | 20 ++++++++++++++++---
 3 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/root.props b/root.props
index d00301d1..00258eb1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.10</Version>
+		<Version>2.0.0-alpha.subscriptions-api.12</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 97a78f0e..d0e912eb 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -14,7 +14,9 @@
 
 	<ItemGroup>
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
+		<PackageReference Include="WebSocket4Net" Version="0.15.2" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index fec75db2..297ec288 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -29,7 +29,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
-		private ClientWebSocket clientWebSocket = null;
+		private WebSocket clientWebSocket = null;
 		private int _connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
@@ -105,8 +105,22 @@ public Task InitializeWebSocket()
 
 			// else (re-)create websocket and connect
 			clientWebSocket?.Dispose();
-			clientWebSocket = new ClientWebSocket();
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
+			// fix websocket not supported on win 7 using
+			// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
+			clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+			switch (clientWebSocket)
+			{
+				case ClientWebSocket nativeWebSocket:
+					nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
+					managedWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				default:
+					throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+			}
+
 			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
 

From 0562eb8e8ad44f84b0b1f3c5a7ed18221158446a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Dec 2018 12:37:49 +0100
Subject: [PATCH 025/455] remove websockets4net dependency

---
 root.props                               | 2 +-
 src/GraphQL.Client/GraphQL.Client.csproj | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/root.props b/root.props
index 00258eb1..0749001b 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.12</Version>
+		<Version>2.0.0-alpha.subscriptions-api.13</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index d0e912eb..8043bf35 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -16,7 +16,6 @@
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
 		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
-		<PackageReference Include="WebSocket4Net" Version="0.15.2" />
 	</ItemGroup>
 
 	<ItemGroup>

From bd9bf5e2f0feb8a2835b5d1dac7121b2a54ec726 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 13:56:31 +0100
Subject: [PATCH 026/455] fix suff for dotnet core 3.0

---
 .../Program.cs                                | 22 +++++++++----------
 .../GraphQL.Common.Benchmark.csproj           |  4 ++++
 root.props                                    |  2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  1 -
 .../GraphQLClientExtensions.cs                |  7 +++---
 .../SubscriptionsTest.cs                      | 12 ++--------
 6 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index a891236a..961ad1d3 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -12,18 +12,16 @@ static void Main(string[] args)
 			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
 			{
 #pragma warning disable 618
-				var stream = client.CreateSubscriptionStream(new GraphQLRequest
-					{
-						Query = @"
-							subscription {
-							  messageAdded{
-							    content
-								from {
-								  displayName
-								}
-							  }
-							}"
-					},
+				var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+						subscription {
+							messageAdded{
+							content
+							from {
+								displayName
+							}
+							}
+						}"
+					),
 					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
 
diff --git a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
index 2591eaad..d5ccaa33 100644
--- a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
+++ b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
@@ -8,5 +8,9 @@
 	<ItemGroup>
 		<PackageReference Include="BenchmarkDotNet" Version="0.11.3" />
 	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
+	</ItemGroup>
 	
 </Project>
diff --git a/root.props b/root.props
index 9f8c24b7..91fe5186 100644
--- a/root.props
+++ b/root.props
@@ -8,7 +8,7 @@
 		<GenerateDocumentationFile>True</GenerateDocumentationFile>
 		<LangVersion>8.0</LangVersion>
 		<NeutralLanguage>en-US</NeutralLanguage>
-		<NoWarn>CS0618;CS1591;CS1701</NoWarn>
+		<NoWarn>CS0618;CS1591;CS1701;NU5105;NU5125</NoWarn>
 		<PackageIconUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/assets/logo.64x64.png</PackageIconUrl>
 		<PackageLicenseUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/LICENSE.txt</PackageLicenseUrl>
 		<PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 512dc443..f48364ec 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -4,7 +4,6 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index c7dd0568..065b4a5c 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -10,14 +10,13 @@ public static class GraphQLClientExtensions
 	{
 		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
 		{
-			var graphQLRequest = new GraphQLRequest
-			{
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
-				}",
+				}")
+			{
 				Variables = new
 				{
 					input = new
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 36804c95..b1e4ca93 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -2,7 +2,6 @@
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -11,7 +10,6 @@
 using Microsoft.Extensions.Logging;
 using Xunit;
 
-
 namespace GraphQL.Integration.Tests
 {
 	public class SubscriptionsTest
@@ -70,10 +68,7 @@ public async void AssertTestingHarness()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
-		{
-			Query = SubscriptionQuery
-		};
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
 		[Fact]
 		public async void CanCreateObservableSubscription()
@@ -173,10 +168,7 @@ public async void CanReconnectWithSameObservable()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
-		{
-			Query = SubscriptionQuery2
-		};
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
 		public async void CanConnectMultipleSubscriptionsSimultaneously()

From 72ba90d882e8ae267fc5eab7423e099323449dac Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 14:08:12 +0100
Subject: [PATCH 027/455] check response for 'null' in where clause

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs              | 6 ++++++
 src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs | 2 +-
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs           | 2 +-
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs      | 2 +-
 4 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 2bb4c689..255b3d6e 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -160,6 +160,9 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
 		{
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
 			return CreateSubscriptionStream(request, e =>
 			{
 				if (e is WebSocketException webSocketException)
@@ -173,6 +176,9 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
 		{
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
 			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
 			return observable;
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index f48364ec..10b2e501 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -35,7 +35,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
 					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => response.Id == startRequest.Id)
+						.Where(response => response != null && response.Id == startRequest.Id)
 						.SelectMany(response =>
 						{
 							switch (response.Type)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 297ec288..4ed3d5ee 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -194,7 +194,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 			}
 			catch (Exception e)
 			{
-				Console.WriteLine(e);
+				Debug.WriteLine(e);
 				throw;
 			}
 			finally
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index b1e4ca93..8b17d1fa 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -43,7 +43,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-			} );
+			});
 
 
 		[Fact]

From f8e18651dc5921de1d5e7b208dc782650722cd70 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 14:25:57 +0100
Subject: [PATCH 028/455] add obsolete parameterless constructor to
 GraphQLRequest

---
 root.props                                   | 2 +-
 src/GraphQL.Common/Request/GraphQLRequest.cs | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 91fe5186..6d2e4399 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4</Version>
+		<Version>2.0.0-alpha.4.subscription-api.2</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 244672f8..18d9f16b 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -33,6 +33,11 @@ public GraphQLRequest(string query){
 			this.Query = query;
 		}
 
+		[Obsolete("this constructor will be removed in a future version!")]
+		public GraphQLRequest() {
+			this.Query = string.Empty;
+		}
+
 		/// <inheritdoc />
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest);
 

From 632a45d5dc18a34d070ec657eecc5f76d57114e5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 15:03:00 +0100
Subject: [PATCH 029/455] add debug output in websocket receive

---
 root.props                                      | 2 +-
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs | 7 ++-----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/root.props b/root.props
index 6d2e4399..055ec330 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.2</Version>
+		<Version>2.0.0-alpha.4.subscription-api.3</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 4ed3d5ee..9ab2d3f2 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -190,17 +190,14 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
 				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
 				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+				Debug.WriteLine($"websocket data received: {stringResult}");
 				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 			}
 			catch (Exception e)
 			{
-				Debug.WriteLine(e);
+				Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
 				throw;
 			}
-			finally
-			{
-				Debug.WriteLine("websocket data received");
-			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)

From f8021af51c591d6cc4fcbc8f6600b12a42fc3d27 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 22 Jan 2019 16:47:16 +0100
Subject: [PATCH 030/455] reuse observables for identical requests

---
 .../Program.cs                                | 59 ++++++++++++++-----
 ...iptionIntegrationTest.ConsoleClient.csproj |  7 ++-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 16 ++++-
 src/GraphQL.Common/Request/GraphQLRequest.cs  | 13 +++-
 .../IntegrationTestServer.csproj              |  8 +--
 5 files changed, 79 insertions(+), 24 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 961ad1d3..dcea2a98 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Reactive.Disposables;
+using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 
@@ -6,13 +8,45 @@ namespace SubsccriptionIntegrationTest.ConsoleClient
 {
 	class Program
 	{
-		static void Main(string[] args)
+		static async Task Main(string[] args)
 		{
 			Console.WriteLine("configuring client ...");
 			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
 			{
+
+				Console.WriteLine("subscribing to message stream ...");
+
+				var subscriptions = new CompositeDisposable();
+
+				subscriptions.Add(CreateSubscription("1", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("2", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("3", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("4", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("5", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("6", client));
+				//await Task.Delay(1000);
+				subscriptions.Add(CreateSubscription("7", client));
+				//await Task.Delay(1000);
+
+				using (subscriptions)
+				{
+					Console.WriteLine("client setup complete");
+					Console.WriteLine("press any key to exit");
+					Console.Read();
+					Console.WriteLine("shutting down ...");
+				}
+			}
+		}
+
+		private static IDisposable CreateSubscription(string id, GraphQLHttpClient client)
+		{
 #pragma warning disable 618
-				var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
 						subscription {
 							messageAdded{
 							content
@@ -21,22 +55,15 @@ static void Main(string[] args)
 							}
 							}
 						}"
-					),
-					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+				),
+				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
 
-				Console.WriteLine("subscribing to message stream ...");
-				using (var subscription = stream.Subscribe(
-					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
-					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
-					() => Console.WriteLine($"message subscription stream completed")))
-				{
-					Console.WriteLine("client setup complete");
-					Console.WriteLine("press any key to exit");
-					Console.Read();
-					Console.WriteLine("shutting down ...");
-				}
-			}
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: message subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: message subscription stream completed"));
+			
 		}
 	}
 }
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
index 21901c2f..83d4884b 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -2,9 +2,14 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFrameworks>netcoreapp3.0;net461</TargetFrameworks>
+	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
     <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 255b3d6e..bbd003b2 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
@@ -152,8 +153,13 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
 				Options, cancellationToken: _cancellationTokenSource.Token);
+			subscriptionStreams.Add(request, observable);
+			return observable;
 		}
 
 		/// <inheritdoc />
@@ -162,7 +168,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		{
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
+					   
 			return CreateSubscriptionStream(request, e =>
 			{
 				if (e is WebSocketException webSocketException)
@@ -179,10 +185,16 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
+			if(subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
 			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
 
+		private Dictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new Dictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 18d9f16b..2a1bddc0 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -52,7 +52,18 @@ public bool Equals(GraphQLRequest? other) {
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() => EqualityComparer<GraphQLRequest>.Default.GetHashCode(this);
+		//public override int GetHashCode() => EqualityComparer<GraphQLRequest>.Default.GetHashCode(this);
+
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = EqualityComparer<string?>.Default.GetHashCode(Query);
+				hashCode = (hashCode * 397) ^ EqualityComparer<string?>.Default.GetHashCode(OperationName);
+				hashCode = (hashCode * 397) ^ EqualityComparer<dynamic?>.Default.GetHashCode(Variables);
+				return hashCode;
+			}
+		}
 
 		/// <inheritdoc />
 		public static bool operator ==(GraphQLRequest? request1, GraphQLRequest? request2) => EqualityComparer<GraphQLRequest?>.Default.Equals(request1, request2);
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 179554ff..3a733458 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -9,10 +9,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
     <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />

From 95d33193b7b2fdbe828d5ab380a666fb3d07f6c8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 23 Jan 2019 11:33:58 +0100
Subject: [PATCH 031/455] store changes to consoleapp

---
 .../Program.cs                                | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index dcea2a98..5d96b32b 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Reactive.Disposables;
+using System.Reactive.Linq;
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
@@ -19,19 +20,19 @@ static async Task Main(string[] args)
 				var subscriptions = new CompositeDisposable();
 
 				subscriptions.Add(CreateSubscription("1", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("2", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("3", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("4", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("5", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("6", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 				subscriptions.Add(CreateSubscription("7", client));
-				//await Task.Delay(1000);
+				await Task.Delay(1000);
 
 				using (subscriptions)
 				{
@@ -55,7 +56,9 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 							}
 							}
 						}"
-				),
+				)
+			//{ Variables = new { id } }
+			,
 				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
 

From abd9cafdc6d31a7391273030d2360cb4a5fd1c50 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 23 Jan 2019 11:36:07 +0100
Subject: [PATCH 032/455] fix StackOverflowException in
 GraphQLRequest.GetHashCode()

---
 src/GraphQL.Common/Request/GraphQLRequest.cs | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 244672f8..d60065ac 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -47,7 +47,16 @@ public bool Equals(GraphQLRequest? other) {
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() => EqualityComparer<GraphQLRequest>.Default.GetHashCode(this);
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = EqualityComparer<string?>.Default.GetHashCode(Query);
+				hashCode = (hashCode * 397) ^ EqualityComparer<string?>.Default.GetHashCode(OperationName);
+				hashCode = (hashCode * 397) ^ EqualityComparer<dynamic?>.Default.GetHashCode(Variables);
+				return hashCode;
+			}
+		}
 
 		/// <inheritdoc />
 		public static bool operator ==(GraphQLRequest? request1, GraphQLRequest? request2) => EqualityComparer<GraphQLRequest?>.Default.Equals(request1, request2);

From 93fae18e4098d675372c992acbff66775fd803e3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 24 Jan 2019 14:46:48 +0100
Subject: [PATCH 033/455] fix receiving long messages via websocket

---
 .../Program.cs                                | 12 +++---
 .../Http/GraphQLHttpWebSocket.cs              | 43 ++++++++++++++-----
 .../IntegrationTestServer.csproj              |  1 +
 tests/IntegrationTestServer/Startup.cs        |  5 +++
 4 files changed, 45 insertions(+), 16 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 5d96b32b..87c557df 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -48,16 +48,16 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 		{
 #pragma warning disable 618
 			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
-						subscription {
-							messageAdded{
-							content
+					subscription {
+						messageAdded{
+						content
 							from {
 								displayName
 							}
-							}
-						}"
+						}
+					}"
 				)
-			//{ Variables = new { id } }
+			{ Variables = new { id } }
 			,
 				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
 #pragma warning restore 618
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 9ab2d3f2..76135bc5 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Net.WebSockets;
 using System.Reactive;
 using System.Reactive.Disposables;
@@ -19,8 +21,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
 		private readonly GraphQLHttpClientOptions _options;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
+		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
@@ -36,7 +37,7 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
 			this.webSocketUri = webSocketUri;
 			_options = options;
-			arraySegment = new ArraySegment<byte>(buffer);
+			buffer = new ArraySegment<byte>(new byte[8192]);
 			ResponseStream = _createResponseStream();
 
 			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
@@ -185,13 +186,35 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 			try
 			{
 				Debug.WriteLine("receiving websocket data ...");
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var webSocketReceiveResult =
-					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-				Debug.WriteLine($"websocket data received: {stringResult}");
-				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+				WebSocketReceiveResult webSocketReceiveResult = null;
+
+				using (var ms = new MemoryStream())
+				{
+					do
+					{
+						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
+						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+					}
+					while (!webSocketReceiveResult.EndOfMessage);
+
+					_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+					ms.Seek(0, SeekOrigin.Begin);
+
+					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
+					{
+						using (var reader = new StreamReader(ms, Encoding.UTF8))
+						{
+							var stringResult = await reader.ReadToEndAsync();
+							Debug.WriteLine($"websocket data received: {stringResult}");
+							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+						}
+					}
+					else
+					{
+						throw new NotSupportedException("binary websocket messages are not supported");
+					}
+				}				
 			}
 			catch (Exception e)
 			{
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 3a733458..6d78ae48 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -12,6 +12,7 @@
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
     <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 0161c739..166bf202 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,6 +1,7 @@
 using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
+using GraphQL.Server.Ui.Playground;
 using IntegrationTestServer.ChatSchema;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -63,6 +64,10 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 				GraphQLEndPoint = "/graphql",
 				Path = "/ui/voyager"
 			});
+			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
+			{
+				Path = "/ui/playground"
+			});
 			app.UseMvc();
 		}
 	}

From 34db7a4f3acad2dc90df6462ba2f2c747293bbc6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 24 Jan 2019 15:01:50 +0100
Subject: [PATCH 034/455] add obsolete constructor

---
 src/GraphQL.Common/Request/GraphQLRequest.cs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index d60065ac..d04f1992 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -33,6 +33,15 @@ public GraphQLRequest(string query){
 			this.Query = query;
 		}
 
+		/// <summary>
+		/// Initialize a new GraphQLRequest
+		/// </summary>
+		[Obsolete("Pass query as parameter! This constructor will be removed in a future version!")]
+		public GraphQLRequest()
+		{
+			this.Query = string.Empty;
+		}
+
 		/// <inheritdoc />
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest);
 

From ca4216d08b398c059ae4997c5df2992d8a0ef737 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 25 Jan 2019 11:50:42 +0100
Subject: [PATCH 035/455] make ReceiveResultStream observable Hot

---
 .../Program.cs                                | 47 ++++++++++++++-----
 root.props                                    |  2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  4 +-
 .../Http/GraphQLHttpWebSocket.cs              | 15 +++---
 .../SubscriptionsTest.cs                      | 31 ++++++------
 .../ChatSchema/ChatSubscriptions.cs           | 10 +++-
 .../IntegrationTestServer.csproj              |  3 +-
 tests/IntegrationTestServer/Program.cs        |  4 +-
 8 files changed, 77 insertions(+), 39 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 87c557df..28ade711 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -20,19 +20,12 @@ static async Task Main(string[] args)
 				var subscriptions = new CompositeDisposable();
 
 				subscriptions.Add(CreateSubscription("1", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("2", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("3", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("4", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("5", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("6", client));
-				await Task.Delay(1000);
-				subscriptions.Add(CreateSubscription("7", client));
-				await Task.Delay(1000);
+				//subscriptions.Add(CreateSubscription2("2", client));
+				//subscriptions.Add(CreateSubscription("3", client));
+				//subscriptions.Add(CreateSubscription("4", client));
+				//subscriptions.Add(CreateSubscription("5", client));
+				//subscriptions.Add(CreateSubscription("6", client));
+				//subscriptions.Add(CreateSubscription("7", client));
 
 				using (subscriptions)
 				{
@@ -41,7 +34,9 @@ static async Task Main(string[] args)
 					Console.Read();
 					Console.WriteLine("shutting down ...");
 				}
+				Console.WriteLine("subscriptions disposed ...");
 			}
+			Console.WriteLine("client disposed ...");
 		}
 
 		private static IDisposable CreateSubscription(string id, GraphQLHttpClient client)
@@ -68,5 +63,31 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 				() => Console.WriteLine($"{id}: message subscription stream completed"));
 			
 		}
+
+
+		private static IDisposable CreateSubscription2(string id, GraphQLHttpClient client)
+		{
+#pragma warning disable 618
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+					subscription {
+						contentAdded{
+						content
+							from {
+								displayName
+							}
+						}
+					}"
+				)
+			{ Variables = new { id } }
+			,
+				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+#pragma warning restore 618
+
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new content from \"{response.Data.contentAdded.from.displayName.Value}\": {response.Data.contentAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: content subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: content subscription stream completed"));
+
+		}
 	}
 }
diff --git a/root.props b/root.props
index 055ec330..7f52c061 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.3</Version>
+		<Version>2.0.0-alpha.4.subscription-api.5</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 10b2e501..03a57dc1 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -35,7 +35,9 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
 					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => response != null && response.Id == startRequest.Id)
+						.Where(response => {
+							return response != null && response.Id == startRequest.Id;
+						})
 						.SelectMany(response =>
 						{
 							switch (response.Type)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 76135bc5..ae747161 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,9 +1,7 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Net.WebSockets;
-using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
@@ -63,8 +61,11 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 
 				await InitializeWebSocket().ConfigureAwait(false);
 				var webSocketRequestString = JsonConvert.SerializeObject(request);
-				var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-				await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+				await this.clientWebSocket.SendAsync(
+					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
+					WebSocketMessageType.Text,
+					true,
+					_cancellationTokenSource.Token).ConfigureAwait(false);
 				request.SendCompleted();
 			}
 			catch (Exception e)
@@ -149,7 +150,7 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
 			await InitializeWebSocket().ConfigureAwait(false);
-			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat().Publish().RefCount();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
@@ -185,7 +186,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
 			try
 			{
-				Debug.WriteLine("receiving websocket data ...");
+				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
 				WebSocketReceiveResult webSocketReceiveResult = null;
 
 				using (var ms = new MemoryStream())
@@ -206,7 +207,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 						using (var reader = new StreamReader(ms, Encoding.UTF8))
 						{
 							var stringResult = await reader.ReadToEndAsync();
-							Debug.WriteLine($"websocket data received: {stringResult}");
+							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
 							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 						}
 					}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8b17d1fa..6a896479 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -22,7 +22,10 @@ public static IWebHost CreateServer(int port)
 			config["server.urls"] = $"http://localhost:{port}";
 
 			var host = new WebHostBuilder()
-				.ConfigureLogging((ctx, logging) => logging.AddDebug())
+				.ConfigureLogging((ctx, logging) =>
+				{
+					logging.AddDebug();
+				})
 				.UseConfiguration(config)
 				.UseKestrel()
 				.UseStartup<IntegrationTestServer.Startup>()
@@ -160,7 +163,7 @@ public async void CanReconnectWithSameObservable()
 
 		private const string SubscriptionQuery2 = @"
 			subscription {
-			  messageAdded{
+			  contentAdded{
 			    content
 				from {
 				  displayName
@@ -171,7 +174,7 @@ public async void CanReconnectWithSameObservable()
 		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
-		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		public async void CanConnectTwoSubscriptionsSimultaneously()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackTester<Exception>();
@@ -181,10 +184,10 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
 
 				Debug.WriteLine("subscribing...");
-				var tester = subscription1.SubscribeTester();
+				var tester = observable1.SubscribeTester();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -194,13 +197,13 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
-				var tester2 = subscription2.SubscribeTester();
+				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
+				var tester2 = observable2.SubscribeTester();
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
-				}, TimeSpan.FromSeconds(10));
+					Assert.Equal(message1, (string)gqlResponse.Data.contentAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
+				});
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
@@ -211,8 +214,8 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				});
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+					Assert.Equal(message2, (string)gqlResponse.Data.contentAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
 				});
 
 				Debug.WriteLine("disposing subscription...");
@@ -223,8 +226,8 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+					Assert.Equal(message3, (string)gqlResponse.Data.contentAdded.content.Value);
+					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
 				});
 
 				// disposing the client should complete the subscription
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 3c8c9624..5a081515 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -25,7 +25,15 @@ public ChatSubscriptions(IChat chat)
                 Subscriber = new EventStreamResolver<Message>(Subscribe)
             });
 
-            AddField(new EventStreamFieldType
+			AddField(new EventStreamFieldType
+			{
+				Name = "contentAdded",
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(Subscribe)
+			});
+
+			AddField(new EventStreamFieldType
             {
                 Name = "messageAddedByUser",
                 Arguments = new QueryArguments(
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 6d78ae48..e0f21c49 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -10,7 +10,8 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.1-1.multiple-subscriptions.2" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index fd8448a8..9b0392b7 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Logging;
 
 namespace IntegrationTestServer
 {
@@ -12,6 +13,7 @@ public static void Main(string[] args)
 
 		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
 			WebHost.CreateDefaultBuilder(args)
-				.UseStartup<Startup>();
+				.UseStartup<Startup>()
+			    .ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 	}
 }

From acb36a1b7f483ba142ff7433e63b81c4be55b555 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 25 Jan 2019 13:23:37 +0100
Subject: [PATCH 036/455] fix multiple subscriptions by using subject in
 GraphQLHttpWebSocket

---
 .../Program.cs                                | 12 ++++-----
 .../Http/GraphQLHttpWebSocket.cs              | 27 ++++++++++++++-----
 2 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 28ade711..758797d4 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -20,12 +20,12 @@ static async Task Main(string[] args)
 				var subscriptions = new CompositeDisposable();
 
 				subscriptions.Add(CreateSubscription("1", client));
-				//subscriptions.Add(CreateSubscription2("2", client));
-				//subscriptions.Add(CreateSubscription("3", client));
-				//subscriptions.Add(CreateSubscription("4", client));
-				//subscriptions.Add(CreateSubscription("5", client));
-				//subscriptions.Add(CreateSubscription("6", client));
-				//subscriptions.Add(CreateSubscription("7", client));
+				subscriptions.Add(CreateSubscription2("2", client));
+				subscriptions.Add(CreateSubscription("3", client));
+				subscriptions.Add(CreateSubscription("4", client));
+				subscriptions.Add(CreateSubscription("5", client));
+				subscriptions.Add(CreateSubscription("6", client));
+				subscriptions.Add(CreateSubscription("7", client));
 
 				using (subscriptions)
 				{
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index ae747161..f8190e94 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -22,7 +22,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
-		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+		private Subject<GraphQLWebSocketResponse> _responseSubject;
 		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private IDisposable _requestSubscription;
 
@@ -36,12 +36,14 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			this.webSocketUri = webSocketUri;
 			_options = options;
 			buffer = new ArraySegment<byte>(new byte[8192]);
-			ResponseStream = _createResponseStream();
+			_responseStream = _createResponseStream();
 
 			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
-		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+		public IObservable<GraphQLWebSocketResponse> ResponseStream => _responseStream;
+		public IObservable<GraphQLWebSocketResponse> _responseStream;
+		//private IDisposable _responseStreamConnection;
 
 		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
@@ -106,6 +108,7 @@ public Task InitializeWebSocket()
 				return Task.CompletedTask;
 
 			// else (re-)create websocket and connect
+			//_responseStreamConnection?.Dispose();
 			clientWebSocket?.Dispose();
 
 			// fix websocket not supported on win 7 using
@@ -125,7 +128,7 @@ public Task InitializeWebSocket()
 
 			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
-
+		
 		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 		{
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
@@ -136,10 +139,19 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
 		{
-			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			if (_responseSubject == null || _responseSubject.IsDisposed)
+			{
+				_responseSubject = new Subject<GraphQLWebSocketResponse>();
+				var observable = await _getReceiveResultStream().ConfigureAwait(false);
+				observable.Subscribe(_responseSubject);
+			}
+					   
 			return new CompositeDisposable
 			(
-				observable.Subscribe(observer),
+				_responseSubject.Finally(() => {
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				}).Subscribe(observer),
 				Disposable.Create(() =>
 				{
 					Debug.WriteLine("response stream disposed");
@@ -150,7 +162,7 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
 		{
 			await InitializeWebSocket().ConfigureAwait(false);
-			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat().Publish().RefCount();
+			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
 		}
 
 		private async Task _connectAsync(CancellationToken token)
@@ -159,6 +171,7 @@ private async Task _connectAsync(CancellationToken token)
 			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
 			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+			//_responseStreamConnection = _responseStream.Connect();
 			_connectionAttempt = 1;
 		}
 

From e70f7a40d7a862cc2a4b6395fc58829126cc035d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 25 Jan 2019 13:31:09 +0100
Subject: [PATCH 037/455] fix overlapping subscriptions

---
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index f8190e94..d7e88bac 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -144,14 +144,21 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 				_responseSubject = new Subject<GraphQLWebSocketResponse>();
 				var observable = await _getReceiveResultStream().ConfigureAwait(false);
 				observable.Subscribe(_responseSubject);
+
+				_responseSubject.Subscribe(_ => { }, ex =>
+				{
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				},
+				() => {
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				});
 			}
 					   
 			return new CompositeDisposable
 			(
-				_responseSubject.Finally(() => {
-					_responseSubject?.Dispose();
-					_responseSubject = null;
-				}).Subscribe(observer),
+				_responseSubject.Subscribe(observer),
 				Disposable.Create(() =>
 				{
 					Debug.WriteLine("response stream disposed");

From 2fbd83d0e43e1abe8b61d121fc28f4e90babf94d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 10:11:22 +0100
Subject: [PATCH 038/455] fix subscription test to work arround
 https://github.com/graphql-dotnet/server/pull/199

---
 root.props                                    |  2 +-
 .../GraphQLClientExtensions.cs                | 18 ++++++++
 .../SubscriptionsTest.cs                      | 44 +++++++------------
 .../ChatSchema/ChatMutation.cs                | 13 +++++-
 .../ChatSchema/ChatSubscriptions.cs           | 10 ++++-
 .../IntegrationTestServer/ChatSchema/IChat.cs | 43 +++++++++++++++---
 .../IntegrationTestServer.csproj              |  2 +-
 7 files changed, 95 insertions(+), 37 deletions(-)

diff --git a/root.props b/root.props
index 7f52c061..5059adb1 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.5</Version>
+		<Version>2.0.0-alpha.4.subscription-api.6</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index 065b4a5c..ff71ee6d 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -29,5 +29,23 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 			};
 			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
 		}
+
+		public static async Task<GraphQLResponse> JoinDeveloperUser(this GraphQLHttpClient client)
+		{
+			var graphQLRequest = new GraphQLRequest(@"
+				mutation($userId: String){
+				  join(userId: $userId){
+				    displayName
+				    id
+				  }
+				}")
+			{
+				Variables = new
+				{
+					userId = "1"
+				}
+			};
+			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 6a896479..635a0d1c 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
+using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -163,11 +164,9 @@ public async void CanReconnectWithSameObservable()
 
 		private const string SubscriptionQuery2 = @"
 			subscription {
-			  contentAdded{
-			    content
-				from {
-				  displayName
-				}
+			  userJoined{
+				displayName
+				id
 			  }
 			}";
 
@@ -185,9 +184,11 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse> observable1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable1.SubscribeTester();
+				var tester2 = observable2.SubscribeTester();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -197,42 +198,31 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
-				var tester2 = observable2.SubscribeTester();
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message1, (string)gqlResponse.Data.contentAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
-				});
+				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
+
+				response = await client.JoinDeveloperUser().ConfigureAwait(false);
+				Assert.Equal("developer", (string)response.Data.join.displayName.Value);
 
-				const string message2 = "How are you?";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				});
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.contentAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
+					Assert.Equal("1", (string)gqlResponse.Data.userJoined.id.Value);
+					Assert.Equal("developer", (string)gqlResponse.Data.userJoined.displayName.Value);
 				});
-
+				
 				Debug.WriteLine("disposing subscription...");
-				tester.Dispose();
+				tester2.Dispose();
 
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string)gqlResponse.Data.contentAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.contentAdded.from.displayName.Value);
+					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester2.ShouldHaveCompleted();
+				tester.ShouldHaveCompleted();
 			}
 		}
 
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
index 7c2a2333..0ca1dfbd 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -16,7 +16,18 @@ public ChatMutation(IChat chat)
                     var message = chat.AddMessage(receivedMessage);
                     return message;
                 });
-        }
+
+			Field<MessageFromType>("join",
+				arguments: new QueryArguments(
+					new QueryArgument<StringGraphType> { Name = "userId" }
+				),
+				resolve: context =>
+				{
+					var userId = context.GetArgument<string>("userId");
+					var userJoined = chat.Join(userId);
+					return userJoined;
+				});
+		}
     }
 
     public class MessageInputType : InputObjectGraphType
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 5a081515..0ceb77a5 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -43,7 +43,15 @@ public ChatSubscriptions(IChat chat)
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
                 Subscriber = new EventStreamResolver<Message>(SubscribeById)
             });
-        }
+
+			AddField(new EventStreamFieldType
+			{
+				Name = "userJoined",
+				Type = typeof(MessageFromType),
+				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
+				Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
+			});
+		}
 
         private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
         {
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
index 68c8e86b..e52c0432 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -11,16 +11,20 @@ public interface IChat
 
         Message AddMessage(Message message);
 
-        IObservable<Message> Messages(string user);
+		MessageFrom Join(string userId);
 
-        Message AddMessage(ReceivedMessage message);
+		IObservable<Message> Messages(string user);
+		IObservable<MessageFrom> UserJoined();
+
+		Message AddMessage(ReceivedMessage message);
     }
 
     public class Chat : IChat
     {
         private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+		private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
-        public Chat()
+		public Chat()
         {
             AllMessages = new ConcurrentStack<Message>();
             Users = new ConcurrentDictionary<string, string>
@@ -58,9 +62,25 @@ public Message AddMessage(Message message)
             AllMessages.Push(message);
             _messageStream.OnNext(message);
             return message;
-        }
+		}
+
+		public MessageFrom Join(string userId)
+		{
+			if (!Users.TryGetValue(userId, out var displayName))
+			{
+				displayName = "(unknown)";
+			}
+
+			var joinedUser = new MessageFrom {
+				Id = userId,
+				DisplayName = displayName
+			};
 
-        public IObservable<Message> Messages(string user)
+			_userJoined.OnNext(joinedUser);
+			return joinedUser;
+		}
+
+		public IObservable<Message> Messages(string user)
         {
             return _messageStream
                 .Select(message =>
@@ -75,5 +95,16 @@ public void AddError(Exception exception)
         {
             _messageStream.OnError(exception);
         }
-    }
+
+		public IObservable<MessageFrom> UserJoined()
+		{
+			return _userJoined.AsObservable();
+		}
+	}
+
+	public class User
+	{
+		public string Id { get; set; }
+		public string Name { get; set; }
+	}
 }
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index e0f21c49..cfba48cd 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,7 +11,7 @@
   <ItemGroup>
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.1-1.multiple-subscriptions.2" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />

From e1ba20a5c91cfa5a24c3264ad6f16eb6249eb75f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 10:25:58 +0100
Subject: [PATCH 039/455] add an observable which publishes all websocket
 exceptions

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs    |  4 ++++
 src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs | 11 ++++++++++-
 src/GraphQL.Client/IGraphQLClient.cs            |  6 ++++++
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index bbd003b2..f522003c 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -39,6 +39,10 @@ public GraphQLHttpClientOptions Options {
 			set => this.graphQLHttpHandler.Options = value;
 		}
 
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL")]
+		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
+
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index d7e88bac..d6426f64 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -24,6 +24,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 
 		private Subject<GraphQLWebSocketResponse> _responseSubject;
 		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private Subject<Exception> _exceptionSubject = new Subject<Exception>();
 		private IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
@@ -41,6 +42,8 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
+		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
+
 		public IObservable<GraphQLWebSocketResponse> ResponseStream => _responseStream;
 		public IObservable<GraphQLWebSocketResponse> _responseStream;
 		//private IDisposable _responseStreamConnection;
@@ -134,7 +137,13 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
 				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLWebSocketResponse>());
+					Observable.Empty<GraphQLWebSocketResponse>())
+				.Catch<GraphQLWebSocketResponse, Exception>(e =>
+					{
+						// post all exceptions in this stream to the exception subject, so they can be received on the outside
+						_exceptionSubject.OnNext(e);
+						return Observable.Throw<GraphQLWebSocketResponse>(e);
+					});
 		}
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 60af36ab..098d0524 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -72,6 +72,12 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
+
+		/// <summary>
+		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+		/// </summary>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<Exception> WebSocketReceiveErrors { get; }
 	}
 
 }

From 7984248b91f1bb292f877b941498dbcf1e7872d6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 10:43:05 +0100
Subject: [PATCH 040/455] fix OnNext calls of exceptionSubject

---
 .../Program.cs                                | 16 ++++++----
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 15 ++++++----
 .../Http/GraphQLHttpWebSocket.cs              | 29 ++++++++++---------
 3 files changed, 36 insertions(+), 24 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 758797d4..d7391d06 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
@@ -19,6 +20,13 @@ static async Task Main(string[] args)
 
 				var subscriptions = new CompositeDisposable();
 
+				subscriptions.Add(client.WebSocketReceiveErrors.Subscribe(e => {
+					if(e is WebSocketException we)
+						Console.WriteLine($"WebSocketException: {we.Message} (WebSocketError {we.WebSocketErrorCode}, ErrorCode {we.ErrorCode}, NativeErrorCode {we.NativeErrorCode}");
+					else
+						Console.WriteLine($"Exception in websocket receive stream: {e.ToString()}");
+				}));
+
 				subscriptions.Add(CreateSubscription("1", client));
 				subscriptions.Add(CreateSubscription2("2", client));
 				subscriptions.Add(CreateSubscription("3", client));
@@ -52,9 +60,7 @@ private static IDisposable CreateSubscription(string id, GraphQLHttpClient clien
 						}
 					}"
 				)
-			{ Variables = new { id } }
-			,
-				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+			{ Variables = new { id } });
 #pragma warning restore 618
 
 			return stream.Subscribe(
@@ -78,9 +84,7 @@ private static IDisposable CreateSubscription2(string id, GraphQLHttpClient clie
 						}
 					}"
 				)
-			{ Variables = new { id } }
-			,
-				e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
+			{ Variables = new { id } });
 #pragma warning restore 618
 
 			return stream.Subscribe(
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 03a57dc1..d6d98ee0 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -108,11 +108,16 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				{
 					try
 					{
-						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
-						if (exceptionHandler == null) throw e;
-
-						// exceptions thrown by the handler will propagate to OnError()
-						exceptionHandler?.Invoke(e);
+						if (exceptionHandler == null) {
+							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
+							// this will ensure that the client tries to re-establish subscriptions on connection loss
+							if (!(e is WebSocketException)) throw e;
+						}
+						else
+						{
+							// exceptions thrown by the handler will propagate to OnError()
+							exceptionHandler?.Invoke(e);
+						}
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return cancellationToken.IsCancellationRequested
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index d6426f64..90caf737 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -137,13 +137,7 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
 				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLWebSocketResponse>())
-				.Catch<GraphQLWebSocketResponse, Exception>(e =>
-					{
-						// post all exceptions in this stream to the exception subject, so they can be received on the outside
-						_exceptionSubject.OnNext(e);
-						return Observable.Throw<GraphQLWebSocketResponse>(e);
-					});
+					Observable.Empty<GraphQLWebSocketResponse>());
 		}
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
@@ -156,6 +150,7 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 
 				_responseSubject.Subscribe(_ => { }, ex =>
 				{
+					_exceptionSubject.OnNext(ex);
 					_responseSubject?.Dispose();
 					_responseSubject = null;
 				},
@@ -183,12 +178,20 @@ private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStrea
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			await _backOff().ConfigureAwait(false);
-			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
-			//_responseStreamConnection = _responseStream.Connect();
-			_connectionAttempt = 1;
+			try
+			{
+				await _backOff().ConfigureAwait(false);
+				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+				//_responseStreamConnection = _responseStream.Connect();
+				_connectionAttempt = 1;
+			}
+			catch (Exception e)
+			{
+				_exceptionSubject.OnNext(e);
+				throw;
+			}
 		}
 
 

From ef37543dc285fdcfef274316d5a59174753cf37f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 11:14:52 +0100
Subject: [PATCH 041/455] fix GraphQLHttpClient(Uri endPoint,
 GraphQLHttpClientOptions options) constructor

---
 .../Program.cs                                |  6 ++
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 27 ++++---
 .../Http/GraphQLHttpClientOptions.cs          |  5 ++
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 73 ++++++++++++++++++-
 4 files changed, 101 insertions(+), 10 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index d7391d06..51cd62ae 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -28,11 +28,17 @@ static async Task Main(string[] args)
 				}));
 
 				subscriptions.Add(CreateSubscription("1", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription2("2", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("3", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("4", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("5", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("6", client));
+				await Task.Delay(200);
 				subscriptions.Add(CreateSubscription("7", client));
 
 				using (subscriptions)
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index f522003c..e6a76359 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -74,13 +74,14 @@ public GraphQLHttpClient(string endPoint, GraphQLHttpClientOptions options) : th
 		/// <param name="endPoint">The EndPoint to be used</param>
 		/// <param name="options">The Options to be used</param>
 		public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
+
+			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
+
 			if (options == null) { throw new ArgumentNullException(nameof(options)); }
-			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
 			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
 			if (options.HttpMessageHandler == null) { throw new ArgumentNullException(nameof(options.HttpMessageHandler)); }
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
-			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
@@ -114,14 +115,22 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
 			this.SendQueryAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken cancellationToken = default) =>
 			this.SendMutationAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		[Obsolete("EXPERIMENTAL API")]
 		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, CancellationToken cancellationToken = default) =>
@@ -160,8 +169,8 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (subscriptionStreams.ContainsKey(request))
 				return subscriptionStreams[request];
 
-			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
-				Options, cancellationToken: _cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
+
 			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
@@ -192,7 +201,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if(subscriptionStreams.ContainsKey(request))
 				return subscriptionStreams[request];
 
-			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
 			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 38008421..ddce13c7 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -49,6 +49,11 @@ public class GraphQLHttpClientOptions {
 			var rnd = new Random();
 			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
 		};
+
+		/// <summary>
+		/// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
+		/// </summary>
+		public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index d6d98ee0..f57cb741 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -4,6 +4,7 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using GraphQL.Common;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
@@ -14,8 +15,8 @@ namespace GraphQL.Client.Http
 	public static class GraphQLHttpSubscriptionHelpers
 	{
 		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLHttpClientOptions options,
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
@@ -146,5 +147,75 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
+
+		internal static async Task<GraphQLResponse> Request(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLRequest request,
+			CancellationToken cancellationToken = default)
+		{
+			return await Observable.Create<GraphQLResponse>(async observer =>
+			{
+				var websocketRequest = new GraphQLWebSocketRequest
+				{
+					Id = Guid.NewGuid().ToString("N"),
+					Type = GQLWebSocketMessageType.GQL_START,
+					Payload = request
+				};
+				var observable = graphQlHttpWebSocket.ResponseStream
+					.Where(response => {
+						return response != null && response.Id == websocketRequest.Id;
+					})
+					.SelectMany(response =>
+					{
+						switch (response.Type)
+						{
+							case GQLWebSocketMessageType.GQL_COMPLETE:
+								Debug.WriteLine($"received 'complete' message on subscription {websocketRequest.Id}");
+								return Observable.Empty<GraphQLResponse>();
+							case GQLWebSocketMessageType.GQL_ERROR:
+								Debug.WriteLine($"received 'error' message on subscription {websocketRequest.Id}");
+								return Observable.Throw<GraphQLResponse>(
+									new GraphQLSubscriptionException(response.Payload));
+							default:
+								Debug.WriteLine($"received payload on subscription {websocketRequest.Id}");
+								return Observable.Return(((JObject)response?.Payload)
+									?.ToObject<GraphQLResponse>());
+						}
+					});
+
+				try
+				{
+					// intialize websocket (completes immediately if socket is already open)
+					await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					// subscribe observer to failed observable
+					return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+				}
+
+				var disposable = new CompositeDisposable(
+					observable.Subscribe(observer)
+				);
+
+				Debug.WriteLine($"sending initial message on subscription {websocketRequest.Id}");
+				// send subscription request
+				try
+				{
+					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					Console.WriteLine(e);
+					throw;
+				}
+
+				return disposable;
+			})
+			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+			.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+				Observable.Empty<GraphQLResponse>())
+			.FirstOrDefaultAsync();
+		}
 	}
 }

From 309a8e3e6308c9961012f022b8756cc83f889113 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 11:28:49 +0100
Subject: [PATCH 042/455] test requests via websockets

---
 .../Program.cs                                | 38 +++++++++++++++++--
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 10 ++---
 2 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index 51cd62ae..95000512 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -13,7 +13,7 @@ class Program
 		static async Task Main(string[] args)
 		{
 			Console.WriteLine("configuring client ...");
-			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/", new GraphQLHttpClientOptions{ UseWebSocketForQueriesAndMutations = true }))
 			{
 
 				Console.WriteLine("subscribing to message stream ...");
@@ -44,8 +44,40 @@ static async Task Main(string[] args)
 				using (subscriptions)
 				{
 					Console.WriteLine("client setup complete");
-					Console.WriteLine("press any key to exit");
-					Console.Read();
+					var quit = false;
+					do
+					{
+						Console.WriteLine("write message and press enter...");
+						var message = Console.ReadLine();
+						var graphQLRequest = new GraphQLRequest(@"
+							mutation($input: MessageInputType){
+							  addMessage(message: $input){
+								content
+							  }
+							}")
+						{
+							Variables = new
+							{
+								input = new
+								{
+									fromId = "2",
+									content = message,
+									sentAt = DateTime.Now
+								}
+							}
+						};
+						var result = await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+
+						if(result.Errors != null && result.Errors.Length > 0)
+						{
+							Console.WriteLine($"request returned {result.Errors.Length} errors:");
+							foreach (var item in result.Errors)
+							{
+								Console.WriteLine($"{item.Message}");
+							}
+						}
+					}
+					while(!quit);
 					Console.WriteLine("shutting down ...");
 				}
 				Console.WriteLine("subscriptions disposed ...");
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index f57cb741..ef71a0ce 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -170,14 +170,14 @@ internal static async Task<GraphQLResponse> Request(
 						switch (response.Type)
 						{
 							case GQLWebSocketMessageType.GQL_COMPLETE:
-								Debug.WriteLine($"received 'complete' message on subscription {websocketRequest.Id}");
+								Debug.WriteLine($"received 'complete' message on request {websocketRequest.Id}");
 								return Observable.Empty<GraphQLResponse>();
 							case GQLWebSocketMessageType.GQL_ERROR:
-								Debug.WriteLine($"received 'error' message on subscription {websocketRequest.Id}");
+								Debug.WriteLine($"received 'error' message on request {websocketRequest.Id}");
 								return Observable.Throw<GraphQLResponse>(
 									new GraphQLSubscriptionException(response.Payload));
 							default:
-								Debug.WriteLine($"received payload on subscription {websocketRequest.Id}");
+								Debug.WriteLine($"received response for request {websocketRequest.Id}");
 								return Observable.Return(((JObject)response?.Payload)
 									?.ToObject<GraphQLResponse>());
 						}
@@ -198,8 +198,8 @@ internal static async Task<GraphQLResponse> Request(
 					observable.Subscribe(observer)
 				);
 
-				Debug.WriteLine($"sending initial message on subscription {websocketRequest.Id}");
-				// send subscription request
+				Debug.WriteLine($"submitting request {websocketRequest.Id}");
+				// send request
 				try
 				{
 					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);

From b9c1443c7d9f9410352026e05e4ae01ab9f26778 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 28 Jan 2019 11:30:33 +0100
Subject: [PATCH 043/455] bump pre-release version

---
 root.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 5059adb1..b32dba6a 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.6</Version>
+		<Version>2.0.0-alpha.4.subscription-api.7</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 

From 3ee031af026ad3adda920c2631a274842e26ce95 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 29 Jan 2019 20:43:37 +0100
Subject: [PATCH 044/455] Subscriptions API (#92)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart

* Update GraphQL.Client.Tests.csproj

* Nullable check (#86)

* nonnullable

* fix some things

* other fix

* netstandard2.0

* Update README.md

* create "queue" for requests so that only one send operation is performed at a time

* fix websockets on win 7

* remove websockets4net dependency

* Update root.props

* Update config.yml

* IsTestProject

* Benchmar

* benchmark

* Update GraphQLLocation.cs

* new Spec

* fix suff for dotnet core 3.0

* check response for 'null' in where clause

* add obsolete parameterless constructor to GraphQLRequest

* add debug output in websocket receive

* reuse observables for identical requests

* store changes to consoleapp

* fix StackOverflowException in GraphQLRequest.GetHashCode()

* fix receiving long messages via websocket

* add obsolete constructor

* make ReceiveResultStream observable Hot

* fix multiple subscriptions by using subject in GraphQLHttpWebSocket

* fix overlapping subscriptions

* fix subscription test to work arround https://github.com/graphql-dotnet/server/pull/199

* add an observable which publishes all websocket exceptions

* fix OnNext calls of exceptionSubject

* fix GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) constructor

* test requests via websockets

* bump pre-release version
---
 .circleci/config.yml                          |   8 +-
 GraphQL.Client.sln                            |  13 +-
 README.md                                     |  40 ++--
 .../Program.cs                                | 137 +++++++++--
 ...iptionIntegrationTest.ConsoleClient.csproj |   7 +-
 .../GraphQL.Common.Benchmark.csproj           |  16 ++
 .../GraphQL.Common.Benchmark/Program.cs       |  36 +++
 .../Request/GraphQLRequestBenchmark.cs        |  57 +++++
 root.props                                    |   6 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |   1 +
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  55 ++++-
 .../Http/GraphQLHttpClientOptions.cs          |   5 +
 .../Http/GraphQLHttpSubscriptionHelpers.cs    |  91 +++++++-
 .../Http/GraphQLHttpWebSocket.cs              | 159 ++++++++++---
 src/GraphQL.Client/IGraphQLClient.cs          |   6 +
 .../Obsolete.GraphQLClient.Extensions.cs      |   4 +-
 src/GraphQL.Client/Obsolete.GraphQLClient.cs  |   4 +-
 src/GraphQL.Common/GraphQL.Common.csproj      |   4 +-
 src/GraphQL.Common/Request/GraphQLRequest.cs  |  67 +++---
 .../Request/GraphQLWebSocketRequest.cs        |  25 ++
 .../Response/GraphQLLocation.cs               |  34 +--
 .../GraphQL.Client.Tests.csproj               |   5 +-
 .../GraphQLClientGetTests.cs                  |  21 +-
 .../GraphQLClientPostTests.cs                 |  29 +--
 .../GraphQLHttpClientSendQueryAsyncTest.cs    |  41 ++--
 .../Http/HttpClientExtensionsTest.cs          |  20 +-
 .../IGraphQLClientTest.cs                     |  20 +-
 tests/GraphQL.Common.Tests/AssertGraphQL.cs   |   2 -
 .../GraphQL.Common.Tests.csproj               |   3 +-
 .../Request/GraphQLRequestConsts.cs           | 220 +++++++++---------
 .../Request/GraphQLRequestTests.cs            |  12 -
 .../GraphQLClientExtensions.cs                |  25 +-
 .../SubscriptionsTest.cs                      |  65 ++----
 .../ChatSchema/ChatMutation.cs                |  13 +-
 .../ChatSchema/ChatSubscriptions.cs           |  20 +-
 .../IntegrationTestServer/ChatSchema/IChat.cs |  43 +++-
 .../IntegrationTestServer.csproj              |  10 +-
 tests/IntegrationTestServer/Program.cs        |   4 +-
 tests/IntegrationTestServer/Startup.cs        |   5 +
 39 files changed, 900 insertions(+), 433 deletions(-)
 create mode 100644 benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
 create mode 100644 benchmarks/GraphQL.Common.Benchmark/Program.cs
 create mode 100644 benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 7e3c5054..8594df23 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -47,15 +47,15 @@ jobs:
       - run: dotnet build --configuration Release
       - run: dotnet pack --configuration Release
       - store_artifacts:
-          path: ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.3.nupkg
+          path: ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.4.nupkg
       - store_artifacts:
-          path: ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.3.nupkg
+          path: ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.4.nupkg
       - deploy:
           name: MyGet
           command: |
             if [ "${CIRCLE_BRANCH}" == "master" ]; then
-              dotnet nuget push ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.3.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
-              dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.3.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
+              dotnet nuget push ./src/GraphQL.Common/bin/Release/GraphQL.Common.2.0.0-alpha.4.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
+              dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.4.nupkg --api-key $MY_GET_API_KEY --source $MY_GET_SOURCE
             fi
 workflows:
   version: 2
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index aa9d13e0..4d28e424 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2010
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.28407.52
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{47C98B55-08F1-4428-863E-2C5C876DEEFE}"
 	ProjectSection(SolutionItems) = preProject
@@ -45,6 +45,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{9413
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks", "{A2E950A3-BD50-40C0-8189-57B455FFBC62}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Common.Benchmark", "benchmarks\GraphQL.Common.Benchmark\GraphQL.Common.Benchmark.csproj", "{6A935C7C-7DD1-489D-9259-56C1A398D643}"
+EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests", "tests\GraphQL.Integration.Tests\GraphQL.Integration.Tests.csproj", "{86BC3878-6549-4EF1-9672-B7C15A3FDF46}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
@@ -89,6 +93,10 @@ Global
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6A935C7C-7DD1-489D-9259-56C1A398D643}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -104,6 +112,7 @@ Global
 		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{D588BC10-6B17-477F-9546-F8D1CE02EACB} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{6A935C7C-7DD1-489D-9259-56C1A398D643} = {A2E950A3-BD50-40C0-8189-57B455FFBC62}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/README.md b/README.md
index f7bfc120..68c7b303 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@ A GraphQL Client for .NET Standard over HTTP.
 
 ## Specification:
 The Library will try to follow the following standards and documents:
-[GraphQL Specification](http://facebook.github.io/graphql/October2016/)
+[GraphQL Specification](https://facebook.github.io/graphql/June2018/)
 [GraphQL HomePage](http://graphql.org/learn/)
 
 ## Usage:
@@ -15,32 +15,30 @@ The Library will try to follow the following standards and documents:
 ### Create a GraphQLRequest:
 #### Simple Request:
 ```csharp
-var heroRequest = new GraphQLRequest {
-  Query = @"
+var heroRequest = new GraphQLRequest(@"
     {
-      hero {
-        name
-      }
+		hero {
+			name
+		}
     }"
-};
+);
 ```
 
 #### OperationName and Variables Request:
 ```csharp
-var heroAndFriendsRequest = new GraphQLRequest {
-  Query = @"
-    query HeroNameAndFriends($episode: Episode) {
-      hero(episode: $episode) {
-        name
-        friends {
-          name
-        }
-      }
-    }",
-  OperationName = "HeroNameAndFriends",
-  Variables = new {
-    episode = "JEDI"
-  }
+var heroAndFriendsRequest = new GraphQLRequest(@"
+	query HeroNameAndFriends($episode: Episode) {
+		hero(episode: $episode) {
+			name
+			friends {
+				name
+			}
+		}
+	}"){
+	OperationName = "HeroNameAndFriends",
+	Variables = new {
+		episode = "JEDI"
+	}
 };
 ```
 
diff --git a/SubscriptionIntegrationTest.ConsoleClient/Program.cs b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
index a891236a..95000512 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/Program.cs
+++ b/SubscriptionIntegrationTest.ConsoleClient/Program.cs
@@ -1,4 +1,8 @@
 using System;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 
@@ -6,39 +10,126 @@ namespace SubsccriptionIntegrationTest.ConsoleClient
 {
 	class Program
 	{
-		static void Main(string[] args)
+		static async Task Main(string[] args)
 		{
 			Console.WriteLine("configuring client ...");
-			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/"))
+			using (var client = new GraphQLHttpClient("http://localhost:5000/graphql/", new GraphQLHttpClientOptions{ UseWebSocketForQueriesAndMutations = true }))
 			{
-#pragma warning disable 618
-				var stream = client.CreateSubscriptionStream(new GraphQLRequest
-					{
-						Query = @"
-							subscription {
-							  messageAdded{
-							    content
-								from {
-								  displayName
-								}
-							  }
-							}"
-					},
-					e => Console.WriteLine($"WebSocketException: {e.Message} (WebSocketError {e.WebSocketErrorCode}, ErrorCode {e.ErrorCode}, NativeErrorCode {e.NativeErrorCode}"));
-#pragma warning restore 618
 
 				Console.WriteLine("subscribing to message stream ...");
-				using (var subscription = stream.Subscribe(
-					response => Console.WriteLine($"new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
-					exception => Console.WriteLine($"message subscription stream failed: {exception}"),
-					() => Console.WriteLine($"message subscription stream completed")))
+
+				var subscriptions = new CompositeDisposable();
+
+				subscriptions.Add(client.WebSocketReceiveErrors.Subscribe(e => {
+					if(e is WebSocketException we)
+						Console.WriteLine($"WebSocketException: {we.Message} (WebSocketError {we.WebSocketErrorCode}, ErrorCode {we.ErrorCode}, NativeErrorCode {we.NativeErrorCode}");
+					else
+						Console.WriteLine($"Exception in websocket receive stream: {e.ToString()}");
+				}));
+
+				subscriptions.Add(CreateSubscription("1", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription2("2", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("3", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("4", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("5", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("6", client));
+				await Task.Delay(200);
+				subscriptions.Add(CreateSubscription("7", client));
+
+				using (subscriptions)
 				{
 					Console.WriteLine("client setup complete");
-					Console.WriteLine("press any key to exit");
-					Console.Read();
+					var quit = false;
+					do
+					{
+						Console.WriteLine("write message and press enter...");
+						var message = Console.ReadLine();
+						var graphQLRequest = new GraphQLRequest(@"
+							mutation($input: MessageInputType){
+							  addMessage(message: $input){
+								content
+							  }
+							}")
+						{
+							Variables = new
+							{
+								input = new
+								{
+									fromId = "2",
+									content = message,
+									sentAt = DateTime.Now
+								}
+							}
+						};
+						var result = await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+
+						if(result.Errors != null && result.Errors.Length > 0)
+						{
+							Console.WriteLine($"request returned {result.Errors.Length} errors:");
+							foreach (var item in result.Errors)
+							{
+								Console.WriteLine($"{item.Message}");
+							}
+						}
+					}
+					while(!quit);
 					Console.WriteLine("shutting down ...");
 				}
+				Console.WriteLine("subscriptions disposed ...");
 			}
+			Console.WriteLine("client disposed ...");
+		}
+
+		private static IDisposable CreateSubscription(string id, GraphQLHttpClient client)
+		{
+#pragma warning disable 618
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+					subscription {
+						messageAdded{
+						content
+							from {
+								displayName
+							}
+						}
+					}"
+				)
+			{ Variables = new { id } });
+#pragma warning restore 618
+
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new message from \"{response.Data.messageAdded.from.displayName.Value}\": {response.Data.messageAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: message subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: message subscription stream completed"));
+			
+		}
+
+
+		private static IDisposable CreateSubscription2(string id, GraphQLHttpClient client)
+		{
+#pragma warning disable 618
+			var stream = client.CreateSubscriptionStream(new GraphQLRequest(@"
+					subscription {
+						contentAdded{
+						content
+							from {
+								displayName
+							}
+						}
+					}"
+				)
+			{ Variables = new { id } });
+#pragma warning restore 618
+
+			return stream.Subscribe(
+				response => Console.WriteLine($"{id}: new content from \"{response.Data.contentAdded.from.displayName.Value}\": {response.Data.contentAdded.content.Value}"),
+				exception => Console.WriteLine($"{id}: content subscription stream failed: {exception}"),
+				() => Console.WriteLine($"{id}: content subscription stream completed"));
+
 		}
 	}
 }
diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
index 21901c2f..83d4884b 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -2,9 +2,14 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFrameworks>netcoreapp3.0;net461</TargetFrameworks>
+	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\src\GraphQL.Client\GraphQL.Client.csproj" />
     <ProjectReference Include="..\src\GraphQL.Common\GraphQL.Common.csproj" />
diff --git a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
new file mode 100644
index 00000000..d5ccaa33
--- /dev/null
+++ b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>netcoreapp2.2</TargetFramework>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="BenchmarkDotNet" Version="0.11.3" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
+	</ItemGroup>
+	
+</Project>
diff --git a/benchmarks/GraphQL.Common.Benchmark/Program.cs b/benchmarks/GraphQL.Common.Benchmark/Program.cs
new file mode 100644
index 00000000..cdbcfce2
--- /dev/null
+++ b/benchmarks/GraphQL.Common.Benchmark/Program.cs
@@ -0,0 +1,36 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Running;
+using System;
+using System.Security.Cryptography;
+
+namespace GraphQL.Common.Benchmark{
+
+	public class Md5VsSha256{
+
+		private const int N = 10000;
+		private readonly byte[] data;
+
+		private readonly SHA256 sha256 = SHA256.Create();
+		private readonly MD5 md5 = MD5.Create();
+
+		public Md5VsSha256(){
+			this.data = new byte[N];
+			new Random(42).NextBytes(this.data);
+		}
+
+		[Benchmark]
+		public byte[] Sha256() => this.sha256.ComputeHash(this.data);
+
+		[Benchmark]
+		public byte[] Md5() => this.md5.ComputeHash(this.data);
+	}
+
+	public class Program{
+
+		public static void Main(string[] args){
+			var summary = BenchmarkRunner.Run<Md5VsSha256>();
+		}
+
+	}
+
+}
diff --git a/benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs b/benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs
new file mode 100644
index 00000000..c6869149
--- /dev/null
+++ b/benchmarks/GraphQL.Common.Benchmark/Request/GraphQLRequestBenchmark.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Text;
+using BenchmarkDotNet.Attributes;
+using GraphQL.Common.Request;
+
+namespace GraphQL.Common.Benchmark.Request {
+
+	public class GraphQLRequestBenchmark {
+
+		private readonly string query;
+		private readonly string operationName;
+		private readonly dynamic variables;
+		private readonly GraphQLRequest graphQLRequest1 = Generate();
+		private readonly GraphQLRequest graphQLRequest2 = Generate();
+
+		public GraphQLRequestBenchmark() {
+			var random = new Random();
+			var data = new byte[1000];
+			random.NextBytes(data);
+			this.query = Encoding.Default.GetString(data);
+			random.NextBytes(data);
+			this.operationName = Encoding.Default.GetString(data);
+			this.variables = new {
+				objectA = random.NextDouble(),
+				objectB = random.Next()
+			};
+		}
+
+		[Benchmark]
+		public GraphQLRequest Constructor() => new GraphQLRequest(this.query) { OperationName = this.operationName, Variables = this.variables };
+
+		[Benchmark]
+		public bool Equality() => this.graphQLRequest1.Equals(this.graphQLRequest2);
+
+		[Benchmark]
+		public bool InEquality() => !this.graphQLRequest1.Equals(this.graphQLRequest2);
+
+		private static GraphQLRequest Generate() {
+			var random = new Random();
+			var data = new byte[1000];
+			random.NextBytes(data);
+			var query = Encoding.Default.GetString(data);
+			random.NextBytes(data);
+			var operationName = Encoding.Default.GetString(data);
+			var variables = new {
+				objectA = random.NextDouble(),
+				objectB = random.Next()
+			};
+			return new GraphQLRequest(query) {
+				OperationName = operationName,
+				Variables = variables
+			};
+		}
+
+	}
+
+}
diff --git a/root.props b/root.props
index d00301d1..b32dba6a 100644
--- a/root.props
+++ b/root.props
@@ -6,9 +6,9 @@
 		<Description>A GraphQL Client for .NET Standard</Description>
 		<GenerateAssemblyInfo>True</GenerateAssemblyInfo>
 		<GenerateDocumentationFile>True</GenerateDocumentationFile>
-		<LangVersion>latest</LangVersion>
+		<LangVersion>8.0</LangVersion>
 		<NeutralLanguage>en-US</NeutralLanguage>
-		<NoWarn>CS0618;CS1591;CS1701</NoWarn>
+		<NoWarn>CS0618;CS1591;CS1701;NU5105;NU5125</NoWarn>
 		<PackageIconUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/assets/logo.64x64.png</PackageIconUrl>
 		<PackageLicenseUrl>https://raw.githubusercontent.com/graphql-dotnet/graphql-client/master/LICENSE.txt</PackageLicenseUrl>
 		<PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.subscriptions-api.10</Version>
+		<Version>2.0.0-alpha.4.subscription-api.7</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 97a78f0e..8043bf35 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -14,6 +14,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 90209d40..e6a76359 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
@@ -38,6 +39,10 @@ public GraphQLHttpClientOptions Options {
 			set => this.graphQLHttpHandler.Options = value;
 		}
 
+		/// <inheritdoc />
+		[Obsolete("EXPERIMENTAL")]
+		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
+
 		#endregion
 
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
@@ -69,13 +74,14 @@ public GraphQLHttpClient(string endPoint, GraphQLHttpClientOptions options) : th
 		/// <param name="endPoint">The EndPoint to be used</param>
 		/// <param name="options">The Options to be used</param>
 		public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
+
+			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
+
 			if (options == null) { throw new ArgumentNullException(nameof(options)); }
-			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
 			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
 			if (options.HttpMessageHandler == null) { throw new ArgumentNullException(nameof(options.HttpMessageHandler)); }
 			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
 
-			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
@@ -107,20 +113,28 @@ internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClie
 		}
 
 		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendQueryAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.SendQueryAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendMutationAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.SendMutationAsync(new GraphQLRequest(query), cancellationToken);
 
-		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-			this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
+		}
 
 		[Obsolete("EXPERIMENTAL API")]
 		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendSubscribeAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.SendSubscribeAsync(new GraphQLRequest(query), cancellationToken);
 
 		[Obsolete("EXPERIMENTAL API")]
 		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
@@ -152,14 +166,22 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			return GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket,
-				Options, cancellationToken: _cancellationTokenSource.Token);
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
+
+			subscriptionStreams.Add(request, observable);
+			return observable;
 		}
 
 		/// <inheritdoc />
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
 		{
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+					   
 			return CreateSubscriptionStream(request, e =>
 			{
 				if (e is WebSocketException webSocketException)
@@ -173,10 +195,19 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
 		{
-			var observable = GraphQLHttpSubscriptionHelpers.CreateSubscriptionStream(request, graphQlHttpWebSocket, Options, exceptionHandler, _cancellationTokenSource.Token);
+			if (_disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			if(subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
+			subscriptionStreams.Add(request, observable);
 			return observable;
 		}
 
+		private Dictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new Dictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
index 38008421..ddce13c7 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClientOptions.cs
@@ -49,6 +49,11 @@ public class GraphQLHttpClientOptions {
 			var rnd = new Random();
 			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
 		};
+
+		/// <summary>
+		/// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
+		/// </summary>
+		public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index 512dc443..ef71a0ce 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -15,8 +15,8 @@ namespace GraphQL.Client.Http
 	public static class GraphQLHttpSubscriptionHelpers
 	{
 		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLHttpClientOptions options,
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
@@ -36,7 +36,9 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
 					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => response.Id == startRequest.Id)
+						.Where(response => {
+							return response != null && response.Id == startRequest.Id;
+						})
 						.SelectMany(response =>
 						{
 							switch (response.Type)
@@ -107,11 +109,16 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				{
 					try
 					{
-						// if the external handler is not set, propagate all exceptions (default subscription behaviour without Retry())
-						if (exceptionHandler == null) throw e;
-
-						// exceptions thrown by the handler will propagate to OnError()
-						exceptionHandler?.Invoke(e);
+						if (exceptionHandler == null) {
+							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
+							// this will ensure that the client tries to re-establish subscriptions on connection loss
+							if (!(e is WebSocketException)) throw e;
+						}
+						else
+						{
+							// exceptions thrown by the handler will propagate to OnError()
+							exceptionHandler?.Invoke(e);
+						}
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return cancellationToken.IsCancellationRequested
@@ -140,5 +147,75 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
+
+		internal static async Task<GraphQLResponse> Request(
+			this GraphQLHttpWebSocket graphQlHttpWebSocket,
+			GraphQLRequest request,
+			CancellationToken cancellationToken = default)
+		{
+			return await Observable.Create<GraphQLResponse>(async observer =>
+			{
+				var websocketRequest = new GraphQLWebSocketRequest
+				{
+					Id = Guid.NewGuid().ToString("N"),
+					Type = GQLWebSocketMessageType.GQL_START,
+					Payload = request
+				};
+				var observable = graphQlHttpWebSocket.ResponseStream
+					.Where(response => {
+						return response != null && response.Id == websocketRequest.Id;
+					})
+					.SelectMany(response =>
+					{
+						switch (response.Type)
+						{
+							case GQLWebSocketMessageType.GQL_COMPLETE:
+								Debug.WriteLine($"received 'complete' message on request {websocketRequest.Id}");
+								return Observable.Empty<GraphQLResponse>();
+							case GQLWebSocketMessageType.GQL_ERROR:
+								Debug.WriteLine($"received 'error' message on request {websocketRequest.Id}");
+								return Observable.Throw<GraphQLResponse>(
+									new GraphQLSubscriptionException(response.Payload));
+							default:
+								Debug.WriteLine($"received response for request {websocketRequest.Id}");
+								return Observable.Return(((JObject)response?.Payload)
+									?.ToObject<GraphQLResponse>());
+						}
+					});
+
+				try
+				{
+					// intialize websocket (completes immediately if socket is already open)
+					await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					// subscribe observer to failed observable
+					return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+				}
+
+				var disposable = new CompositeDisposable(
+					observable.Subscribe(observer)
+				);
+
+				Debug.WriteLine($"submitting request {websocketRequest.Id}");
+				// send request
+				try
+				{
+					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
+				}
+				catch (Exception e)
+				{
+					Console.WriteLine(e);
+					throw;
+				}
+
+				return disposable;
+			})
+			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+			.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+				Observable.Empty<GraphQLResponse>())
+			.FirstOrDefaultAsync();
+		}
 	}
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index c5e2d349..90caf737 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
@@ -18,34 +19,64 @@ internal class GraphQLHttpWebSocket: IDisposable
 	{
 		private readonly Uri webSocketUri;
 		private readonly GraphQLHttpClientOptions _options;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-		private readonly ArraySegment<byte> arraySegment;
+		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
-		private Subject<GraphQLWebSocketResponse> _responseSubject = new Subject<GraphQLWebSocketResponse>();
+		private Subject<GraphQLWebSocketResponse> _responseSubject;
+		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private Subject<Exception> _exceptionSubject = new Subject<Exception>();
+		private IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
-		private ClientWebSocket clientWebSocket = null;
+		private WebSocket clientWebSocket = null;
 		private int _connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
 			this.webSocketUri = webSocketUri;
 			_options = options;
-			arraySegment = new ArraySegment<byte>(buffer);
-			ResponseStream = _createResponseStream();
+			buffer = new ArraySegment<byte>(new byte[8192]);
+			_responseStream = _createResponseStream();
+
+			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
-		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
 
+		public IObservable<GraphQLWebSocketResponse> ResponseStream => _responseStream;
+		public IObservable<GraphQLWebSocketResponse> _responseStream;
+		//private IDisposable _responseStreamConnection;
 
-		public async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
-			await InitializeWebSocket().ConfigureAwait(false);
-			var webSocketRequestString = JsonConvert.SerializeObject(request);
-			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
-			await this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, _cancellationTokenSource.Token).ConfigureAwait(false);
+			_requestSubject.OnNext(request);
+			return request.SendTask();
+		}
+
+		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
+		{
+			try
+			{
+				if (_cancellationTokenSource.Token.IsCancellationRequested)
+				{
+					request.SendCanceled();
+					return;
+				}
+
+				await InitializeWebSocket().ConfigureAwait(false);
+				var webSocketRequestString = JsonConvert.SerializeObject(request);
+				await this.clientWebSocket.SendAsync(
+					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
+					WebSocketMessageType.Text,
+					true,
+					_cancellationTokenSource.Token).ConfigureAwait(false);
+				request.SendCompleted();
+			}
+			catch (Exception e)
+			{
+				request.SendFailed(e);
+			}
 		}
 
 		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
@@ -80,12 +111,27 @@ public Task InitializeWebSocket()
 				return Task.CompletedTask;
 
 			// else (re-)create websocket and connect
+			//_responseStreamConnection?.Dispose();
 			clientWebSocket?.Dispose();
-			clientWebSocket = new ClientWebSocket();
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+
+			// fix websocket not supported on win 7 using
+			// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
+			clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+			switch (clientWebSocket)
+			{
+				case ClientWebSocket nativeWebSocket:
+					nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
+					managedWebSocket.Options.AddSubProtocol("graphql-ws");
+					break;
+				default:
+					throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+			}
+
 			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 		}
-
+		
 		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 		{
 			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
@@ -96,10 +142,27 @@ private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 
 		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
 		{
-			var observable = await _getReceiveResultStream().ConfigureAwait(false);
+			if (_responseSubject == null || _responseSubject.IsDisposed)
+			{
+				_responseSubject = new Subject<GraphQLWebSocketResponse>();
+				var observable = await _getReceiveResultStream().ConfigureAwait(false);
+				observable.Subscribe(_responseSubject);
+
+				_responseSubject.Subscribe(_ => { }, ex =>
+				{
+					_exceptionSubject.OnNext(ex);
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				},
+				() => {
+					_responseSubject?.Dispose();
+					_responseSubject = null;
+				});
+			}
+					   
 			return new CompositeDisposable
 			(
-				observable.Subscribe(observer),
+				_responseSubject.Subscribe(observer),
 				Disposable.Create(() =>
 				{
 					Debug.WriteLine("response stream disposed");
@@ -115,11 +178,20 @@ private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStrea
 
 		private async Task _connectAsync(CancellationToken token)
 		{
-			await _backOff().ConfigureAwait(false);
-			Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
-			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-			Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
-			_connectionAttempt = 1;
+			try
+			{
+				await _backOff().ConfigureAwait(false);
+				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+				//_responseStreamConnection = _responseStream.Connect();
+				_connectionAttempt = 1;
+			}
+			catch (Exception e)
+			{
+				_exceptionSubject.OnNext(e);
+				throw;
+			}
 		}
 
 
@@ -146,23 +218,42 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
 			try
 			{
-				Debug.WriteLine("receiving websocket data ...");
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var webSocketReceiveResult =
-					await clientWebSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(false);
-				_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-				var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
-				return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
+				WebSocketReceiveResult webSocketReceiveResult = null;
+
+				using (var ms = new MemoryStream())
+				{
+					do
+					{
+						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
+						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+					}
+					while (!webSocketReceiveResult.EndOfMessage);
+
+					_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+					ms.Seek(0, SeekOrigin.Begin);
+
+					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
+					{
+						using (var reader = new StreamReader(ms, Encoding.UTF8))
+						{
+							var stringResult = await reader.ReadToEndAsync();
+							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
+							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+						}
+					}
+					else
+					{
+						throw new NotSupportedException("binary websocket messages are not supported");
+					}
+				}				
 			}
 			catch (Exception e)
 			{
-				Console.WriteLine(e);
+				Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
 				throw;
 			}
-			finally
-			{
-				Debug.WriteLine("websocket data received");
-			}
 		}
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 60af36ab..098d0524 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -72,6 +72,12 @@ public interface IGraphQLClient : IDisposable {
 		/// <returns>an observable stream for the specified subscription</returns>
 		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
+
+		/// <summary>
+		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+		/// </summary>
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<Exception> WebSocketReceiveErrors { get; }
 	}
 
 }
diff --git a/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs b/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs
index a7b6dbfc..057e3c8a 100644
--- a/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs
+++ b/src/GraphQL.Client/Obsolete.GraphQLClient.Extensions.cs
@@ -99,8 +99,8 @@ fragment TypeRef on __Type {
 					}
 				}";
 
-		private static readonly GraphQLRequest IntrospectionGraphQLRequest = new GraphQLRequest {
-			Query = IntrospectionQuery.Replace("\t", "").Replace("\n", "").Replace("\r", ""),
+		private static readonly GraphQLRequest IntrospectionGraphQLRequest = new GraphQLRequest(
+			IntrospectionQuery.Replace("\t", "").Replace("\n", "").Replace("\r", "")){ 
 			Variables = null
 		};
 
diff --git a/src/GraphQL.Client/Obsolete.GraphQLClient.cs b/src/GraphQL.Client/Obsolete.GraphQLClient.cs
index 73f81450..922927bf 100644
--- a/src/GraphQL.Client/Obsolete.GraphQLClient.cs
+++ b/src/GraphQL.Client/Obsolete.GraphQLClient.cs
@@ -53,7 +53,7 @@ public GraphQLClient(GraphQLClientOptions options) : base(options) { }
 		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
 		/// <returns>The Response</returns>
 		public Task<GraphQLResponse> GetQueryAsync(string query, CancellationToken cancellationToken = default) =>
-			this.GetAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.GetAsync(new GraphQLRequest(query), cancellationToken);
 
 		/// <summary>
 		/// Send a <see cref="GraphQLRequest"/> via GET
@@ -71,7 +71,7 @@ public Task<GraphQLResponse> GetAsync(GraphQLRequest request, CancellationToken
 		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
 		/// <returns>The Response</returns>
 		public Task<GraphQLResponse> PostQueryAsync(string query, CancellationToken cancellationToken = default) =>
-			this.PostAsync(new GraphQLRequest { Query = query }, cancellationToken);
+			this.PostAsync(new GraphQLRequest(query), cancellationToken);
 
 		/// <summary>
 		/// Send a <see cref="GraphQLRequest"/> via POST
diff --git a/src/GraphQL.Common/GraphQL.Common.csproj b/src/GraphQL.Common/GraphQL.Common.csproj
index ed75f9dd..116ff1b9 100644
--- a/src/GraphQL.Common/GraphQL.Common.csproj
+++ b/src/GraphQL.Common/GraphQL.Common.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../src.props" />
@@ -8,7 +8,7 @@
 	</PropertyGroup>
 
 	<PropertyGroup>
-		<TargetFrameworks>netstandard1.0;netstandard2.0</TargetFrameworks>
+		<TargetFramework>netstandard2.0</TargetFramework>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/src/GraphQL.Common/Request/GraphQLRequest.cs b/src/GraphQL.Common/Request/GraphQLRequest.cs
index 212a3642..d04f1992 100644
--- a/src/GraphQL.Common/Request/GraphQLRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLRequest.cs
@@ -1,3 +1,4 @@
+#nullable enable
 using System;
 using System.Collections.Generic;
 
@@ -7,7 +8,7 @@ namespace GraphQL.Common.Request {
 	/// Represents a Query that can be fetched to a GraphQL Server.
 	/// For more information <see href="http://graphql.org/learn/serving-over-http/#post-request"/>
 	/// </summary>
-	public class GraphQLRequest : IEquatable<GraphQLRequest> {
+	public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 
 		/// <summary>
 		/// The Query
@@ -17,50 +18,60 @@ public class GraphQLRequest : IEquatable<GraphQLRequest> {
 		/// <summary>
 		/// If the provided <see cref="Query"/> contains multiple named operations, this specifies which operation should be executed.
 		/// </summary>
-		public string OperationName { get; set; }
+		public string? OperationName { get; set; }
 
 		/// <summary>
 		/// The Variables
 		/// </summary>
-		public dynamic Variables { get; set; }
+		public dynamic? Variables { get; set; }
+
+		/// <summary>
+		/// Initialize a new GraphQLRequest
+		/// </summary>
+		/// <param name="query">The Query</param>
+		public GraphQLRequest(string query){
+			this.Query = query;
+		}
+
+		/// <summary>
+		/// Initialize a new GraphQLRequest
+		/// </summary>
+		[Obsolete("Pass query as parameter! This constructor will be removed in a future version!")]
+		public GraphQLRequest()
+		{
+			this.Query = string.Empty;
+		}
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLRequest);
+		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLRequest other) {
-			if (other == null) {
-				return false;
-			}
-			if (ReferenceEquals(this, other)) {
-				return true;
-			}
-			if (!Equals(this.Query, other.Query)) {
-				return false;
-			}
-			if (!Equals(this.OperationName, other.OperationName)) {
-				return false;
-			}
-			if (!Equals(this.Variables, other.Variables)) {
-				return false;
-			}
+		public bool Equals(GraphQLRequest? other) {
+			if (other == null) {return false;}
+			if (ReferenceEquals(this, other)) { return true; }
+			if (!EqualityComparer<string>.Default.Equals(this.Query, other.Query)) { return false; }
+			if (!EqualityComparer<string?>.Default.Equals(this.OperationName, other.OperationName)) { return false; }
+			if (!EqualityComparer<dynamic?>.Default.Equals(this.Variables, other.Variables)) { return false; }
 			return true;
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() {
-			var hashCode = -689803966;
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Query);
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.OperationName);
-			hashCode = hashCode * -1521134295 + EqualityComparer<dynamic>.Default.GetHashCode(this.Variables);
-			return hashCode;
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				var hashCode = EqualityComparer<string?>.Default.GetHashCode(Query);
+				hashCode = (hashCode * 397) ^ EqualityComparer<string?>.Default.GetHashCode(OperationName);
+				hashCode = (hashCode * 397) ^ EqualityComparer<dynamic?>.Default.GetHashCode(Variables);
+				return hashCode;
+			}
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLRequest request1, GraphQLRequest request2) => EqualityComparer<GraphQLRequest>.Default.Equals(request1, request2);
+		public static bool operator ==(GraphQLRequest? request1, GraphQLRequest? request2) => EqualityComparer<GraphQLRequest?>.Default.Equals(request1, request2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLRequest request1, GraphQLRequest request2) => !(request1 == request2);
+		public static bool operator !=(GraphQLRequest? request1, GraphQLRequest? request2) => !(request1 == request2);
 
 	}
 
diff --git a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
index 46e14dce..d805efc4 100644
--- a/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Common/Request/GraphQLWebSocketRequest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace GraphQL.Common.Request {
 
@@ -24,6 +25,30 @@ public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 		/// </summary>
 		public GraphQLRequest Payload { get; set; }
 
+		private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
+
+		/// <summary>
+		/// Task used to await the actual send operation and to convey potential exceptions
+		/// </summary>
+		/// <returns></returns>
+		public Task SendTask() => _tcs.Task;
+
+		/// <summary>
+		/// gets called when the send operation for this request has completed sucessfully
+		/// </summary>
+		public void SendCompleted() => _tcs.SetResult(true);
+
+		/// <summary>
+		/// gets called when an exception occurs during the send operation
+		/// </summary>
+		/// <param name="e"></param>
+		public void SendFailed(Exception e) => _tcs.SetException(e);
+
+		/// <summary>
+		/// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
+		/// </summary>
+		public void SendCanceled() => _tcs.SetCanceled();
+
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
 
diff --git a/src/GraphQL.Common/Response/GraphQLLocation.cs b/src/GraphQL.Common/Response/GraphQLLocation.cs
index 913a7a44..c8eb8c5c 100644
--- a/src/GraphQL.Common/Response/GraphQLLocation.cs
+++ b/src/GraphQL.Common/Response/GraphQLLocation.cs
@@ -1,3 +1,4 @@
+#nullable enable
 using System;
 using System.Collections.Generic;
 
@@ -6,7 +7,7 @@ namespace GraphQL.Common.Response {
 	/// <summary>
 	/// Represents the location where the <see cref="GraphQLError"/> has been found
 	/// </summary>
-	public class GraphQLLocation : IEquatable<GraphQLLocation> {
+	public class GraphQLLocation : IEquatable<GraphQLLocation?> {
 
 		/// <summary>
 		/// The Column
@@ -19,38 +20,25 @@ public class GraphQLLocation : IEquatable<GraphQLLocation> {
 		public uint Line { get; set; }
 
 		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLLocation);
+		public override bool Equals(object? obj) => this.Equals(obj as GraphQLLocation);
 
 		/// <inheritdoc />
-		public bool Equals(GraphQLLocation other) {
-			if (other == null) {
-				return false;
-			}
-			if (ReferenceEquals(this, other)) {
-				return true;
-			}
-			if (!Equals(this.Column, other.Column)) {
-				return false;
-			}
-			if (!Equals(this.Line, other.Line)) {
-				return false;
-			}
+		public bool Equals(GraphQLLocation? other) {
+			if (other == null) { return false; }
+			if (ReferenceEquals(this, other)) { return true; }
+			if (!EqualityComparer<uint>.Default.Equals(this.Column, other.Column)) { return false; }
+			if (!EqualityComparer<uint>.Default.Equals(this.Line, other.Line)) { return false; }
 			return true;
 		}
 
 		/// <inheritdoc />
-		public override int GetHashCode() {
-			var hashCode = 412437926;
-			hashCode = hashCode * -1521134295 + this.Column.GetHashCode();
-			hashCode = hashCode * -1521134295 + this.Line.GetHashCode();
-			return hashCode;
-		}
+		public override int GetHashCode() => EqualityComparer<GraphQLLocation>.Default.GetHashCode(this);
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLLocation location1, GraphQLLocation location2) => EqualityComparer<GraphQLLocation>.Default.Equals(location1, location2);
+		public static bool operator ==(GraphQLLocation? location1, GraphQLLocation? location2) => EqualityComparer<GraphQLLocation?>.Default.Equals(location1, location2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLLocation location1, GraphQLLocation location2) => !(location1 == location2);
+		public static bool operator !=(GraphQLLocation? location1, GraphQLLocation? location2) => !(location1 == location2);
 
 	}
 
diff --git a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
index 660883af..1c9a24d9 100644
--- a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
+++ b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
@@ -4,16 +4,17 @@
 	<Import Project="../tests.props" />
 
 	<PropertyGroup>
+		<IsTestProject>true</IsTestProject>
 		<TargetFramework>netcoreapp3.0</TargetFramework>
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="1.1.2" />
+		<PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="1.1.2" />
 	</ItemGroup>
 
 	<ItemGroup>
 		<ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
 		<ProjectReference Include="..\GraphQL.Common.Tests\GraphQL.Common.Tests.csproj" />
 	</ItemGroup>
-	
+
 </Project>
diff --git a/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs b/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs
index faad38e8..2cdc0dfa 100644
--- a/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLClientGetTests.cs
@@ -8,14 +8,12 @@ public class GraphQLClientGetTests : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
-				}"
-			};
+				}");
 			var response = await this.GraphQLClient.GetAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -24,8 +22,7 @@ public async void QueryGetAsyncFact() {
 
 		[Fact]
 		public async void OperationNameGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -36,7 +33,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") {
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLClient.GetAsync(graphQLRequest).ConfigureAwait(false);
@@ -47,13 +44,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest (@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") {
 				Variables = new {
 					personId = "1"
 				}
@@ -66,8 +62,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariableGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -78,7 +73,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}"){
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs b/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs
index ba56c9a1..aacc1587 100644
--- a/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLClientPostTests.cs
@@ -9,14 +9,13 @@ public class GraphQLClientPostTests : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryPostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			var response = await this.GraphQLClient.PostAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -24,17 +23,14 @@ public async void QueryPostAsyncFact() {
 		}
 
 		[Fact]
-		public async void QueryPostAsyncWithoutUtf8EncodingFact()
-		{
-			var graphQLRequest = new GraphQLRequest
-			{
-				Query = @"
+		public async void QueryPostAsyncWithoutUtf8EncodingFact(){
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			this.GraphQLClient.Options.MediaType = MediaTypeHeaderValue.Parse("application/json");
 			var response = await this.GraphQLClient.PostAsync(graphQLRequest).ConfigureAwait(false);
 
@@ -44,8 +40,7 @@ public async void QueryPostAsyncWithoutUtf8EncodingFact()
 
 		[Fact]
 		public async void OperationNamePostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -56,7 +51,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLClient.PostAsync(graphQLRequest).ConfigureAwait(false);
@@ -67,13 +62,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesPostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") { 
 				Variables = new {
 					personId = "1"
 				}
@@ -86,8 +80,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariablePostAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -98,7 +91,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs b/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs
index 82062542..2d21100e 100644
--- a/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs
+++ b/tests/GraphQL.Client.Tests/Http/GraphQLHttpClientSendQueryAsyncTest.cs
@@ -1,42 +1,36 @@
-using GraphQL.Client.Http;
-using GraphQL.Common.Request;
 using System;
-using System.Collections.Generic;
 using System.Net.Http;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
 using Xunit;
 
 namespace GraphQL.Client.Tests.Http
 {
-    public class GraphQLHttpClientSendQueryAsyncTest
-    {
+
+	public class GraphQLHttpClientSendQueryAsyncTest{
 
 		// Relates to an issue with the 1.x versions.
 		// See: https://github.com/graphql-dotnet/graphql-client/issues/53
 		[Fact]
-		public async void SendQueryAsyncShouldPreserveUriParametersFact()
-		{
+		public async void SendQueryAsyncShouldPreserveUriParametersFact(){
 			var endpoint = new Uri("http://localhost/api/graphql?code=my-secret-api-key");
 
 			var handlerStub = new HttpHandlerStub();
-			GraphQLHttpClientOptions options = new GraphQLHttpClientOptions()
-			{
+			var options = new GraphQLHttpClientOptions(){
 				EndPoint = endpoint,
 				HttpMessageHandler = handlerStub
 			};
-			GraphQLHttpClient systemUnderTest = new GraphQLHttpClient(options);
+			var systemUnderTest = new GraphQLHttpClient(options);
 
-			var response = await systemUnderTest.SendQueryAsync(new GraphQLRequest
-			{
-				Query = @"
+			var response = await systemUnderTest.SendQueryAsync(new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			});
+			));
 
 			var actualRequestUri = handlerStub.LastRequest.RequestUri;
 			var queryParams = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(actualRequestUri.Query);
@@ -45,20 +39,21 @@ public async void SendQueryAsyncShouldPreserveUriParametersFact()
 		}
 
 
-		private class HttpHandlerStub : HttpMessageHandler
-		{
+		private class HttpHandlerStub : HttpMessageHandler{
+
 			public HttpRequestMessage LastRequest { get; private set; }
 
 			public CancellationToken LastCancellationToken { get; private set; }
 
-			protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
-			{
-				LastRequest = request;
-				LastCancellationToken = cancellationToken;
-				var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
-				response.Content = new StringContent("{}");
+			protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken){
+				this.LastRequest = request;
+				this.LastCancellationToken = cancellationToken;
+				var response = new HttpResponseMessage(System.Net.HttpStatusCode.OK){
+					Content = new StringContent("{}")
+				};
 				return Task.FromResult(response);
 			}
+
 		}
 
 	}
diff --git a/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs b/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs
index 1738f0a2..607c7e28 100644
--- a/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs
+++ b/tests/GraphQL.Client.Tests/Http/HttpClientExtensionsTest.cs
@@ -13,14 +13,13 @@ public class HttpClientExtensionsTest : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			var response = await this.GraphQLHttpClient.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -29,8 +28,7 @@ public async void QueryGetAsyncFact() {
 
 		[Fact]
 		public async void OperationNameGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -41,7 +39,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}"){
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLHttpClient.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
@@ -52,13 +50,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") {
 				Variables = new {
 					personId = "1"
 				}
@@ -71,8 +68,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariableGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -83,7 +79,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs b/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs
index 7b5b6368..7c384d55 100644
--- a/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs
+++ b/tests/GraphQL.Client.Tests/IGraphQLClientTest.cs
@@ -8,14 +8,13 @@ public class IGraphQLClientTest : BaseGraphQLClientTest {
 
 		[Fact]
 		public async void QueryGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				{
 					person(personID: ""1"") {
 						name
 					}
 				}"
-			};
+			);
 			var response = await this.GraphQLClientSwapi.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
 
 			Assert.Equal("Luke Skywalker", response.Data.person.name.Value);
@@ -24,8 +23,7 @@ public async void QueryGetAsyncFact() {
 
 		[Fact]
 		public async void OperationNameGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person{
 					person(personID: ""1"") {
 						name
@@ -36,7 +34,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person"
 			};
 			var response = await this.GraphQLClientSwapi.SendQueryAsync(graphQLRequest).ConfigureAwait(false);
@@ -47,13 +45,12 @@ query Planet {
 
 		[Fact]
 		public async void VariablesGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
 					}
-				}",
+				}") {
 				Variables = new {
 					personId = "1"
 				}
@@ -66,8 +63,7 @@ query Person($personId: ID!){
 
 		[Fact]
 		public async void OperationNameVariableGetAsyncFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				query Person($personId: ID!){
 					person(personID: $personId) {
 						name
@@ -78,7 +74,7 @@ query Planet {
 					planet(planetID: ""1"") {
 						name
 					}
-				}",
+				}") { 
 				OperationName = "Person",
 				Variables = new {
 					personId = "1"
diff --git a/tests/GraphQL.Common.Tests/AssertGraphQL.cs b/tests/GraphQL.Common.Tests/AssertGraphQL.cs
index a81f38ad..4115fc9f 100644
--- a/tests/GraphQL.Common.Tests/AssertGraphQL.cs
+++ b/tests/GraphQL.Common.Tests/AssertGraphQL.cs
@@ -6,8 +6,6 @@ namespace GraphQL.Common.Tests {
 
 	public static class AssertGraphQL {
 
-		public static void CorrectGraphQLRequest(GraphQLRequest graphQLRequest) => Assert.NotNull(graphQLRequest.Query);
-
 		public static void CorrectGraphQLResponse(GraphQLResponse graphQLResponse) {
 			Assert.NotNull(graphQLResponse.Data);
 			Assert.Null(graphQLResponse.Errors);
diff --git a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj b/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
index e0a660a7..4aae0487 100644
--- a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
+++ b/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
@@ -1,9 +1,10 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../tests.props" />
 
 	<PropertyGroup>
+		<IsTestProject>true</IsTestProject>
 		<TargetFramework>netcoreapp3.0</TargetFramework>
 	</PropertyGroup>
 	
diff --git a/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs b/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs
index 9d3fca63..520ca4b6 100644
--- a/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs
+++ b/tests/GraphQL.Common.Tests/Request/GraphQLRequestConsts.cs
@@ -7,130 +7,122 @@ public static class GraphQLRequestConsts {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#fields"/>
 		/// </summary>
-		public static GraphQLRequest FieldsRequest1 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					hero {
-						name
-					}
-				}",
+		public static GraphQLRequest FieldsRequest1 { get; } = new GraphQLRequest(@"
+			{
+				hero {
+					name
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#fields"/>
 		/// </summary>
-		public static GraphQLRequest FieldsRequest2 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					hero {
+		public static GraphQLRequest FieldsRequest2 { get; } = new GraphQLRequest(@"
+			{
+				hero {
+					name
+					# Queries can have comments!
+					friends {
 						name
-						# Queries can have comments!
-						friends {
-							name
-						}
 					}
-				}",
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#arguments"/>
 		/// </summary>
-		public static GraphQLRequest ArgumentsRequest1 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					human(id: ""1000"") {
-						name
-						height
-					}
-				}",
+		public static GraphQLRequest ArgumentsRequest1 { get; } = new GraphQLRequest(@"
+			{
+				human(id: ""1000"") {
+					name
+					height
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#arguments"/>
 		/// </summary>
-		public static GraphQLRequest ArgumentsRequest2 { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					human(id: ""1000"") {
-						name
-						height(unit: FOOT)
-					}
-				}",
+		public static GraphQLRequest ArgumentsRequest2 { get; } = new GraphQLRequest(@"
+			{
+				human(id: ""1000"") {
+					name
+					height(unit: FOOT)
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#aliases"/>
 		/// </summary>
-		public static GraphQLRequest AliasesRequest { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					empireHero: hero(episode: EMPIRE) {
-						name
-					}
-					jediHero: hero(episode: JEDI) {
-						name
-					}
-				}",
+		public static GraphQLRequest AliasesRequest { get; } = new GraphQLRequest(@"
+			{
+				empireHero: hero(episode: EMPIRE) {
+					name
+				}
+				jediHero: hero(episode: JEDI) {
+					name
+				}
+			}") { 
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#fragments"/>
 		/// </summary>
-		public static GraphQLRequest FragmentsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					leftComparison: hero(episode: EMPIRE) {
-						...comparisonFields
-					}
-					rightComparison: hero(episode: JEDI) {
-						...comparisonFields
-					}
+		public static GraphQLRequest FragmentsRequest { get; } = new GraphQLRequest(@"
+			{
+				leftComparison: hero(episode: EMPIRE) {
+					...comparisonFields
+				}
+				rightComparison: hero(episode: JEDI) {
+					...comparisonFields
 				}
+			}
 
-				fragment comparisonFields on Character {
+			fragment comparisonFields on Character {
+				name
+				appearsIn
+				friends {
 					name
-					appearsIn
-					friends {
-						name
-					}
-				}",
+				}
+			}") {
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#operation-name"/>
 		/// </summary>
-		public static GraphQLRequest OperationNameRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query HeroNameAndFriends {
-					hero {
+		public static GraphQLRequest OperationNameRequest { get; } = new GraphQLRequest(@"
+			query HeroNameAndFriends {
+				hero {
+					name
+					friends {
 						name
-						friends {
-							name
-						}
 					}
-				}",
+				}
+			}") {
 			Variables = null
 		};
 
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#variables"/>
 		/// </summary>
-		public static GraphQLRequest VariablesRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query HeroNameAndFriends($episode: Episode) {
-					hero(episode: $episode) {
+		public static GraphQLRequest VariablesRequest { get; } = new GraphQLRequest(@"
+			query HeroNameAndFriends($episode: Episode) {
+				hero(episode: $episode) {
+					name
+					friends {
 						name
-						friends {
-							name
-						}
 					}
-				}",
+				}
+			}") { 
 			Variables = new {
 				episode = "JEDI"
 			}
@@ -139,16 +131,15 @@ query HeroNameAndFriends($episode: Episode) {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#directives"/>
 		/// </summary>
-		public static GraphQLRequest DirectivesRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query Hero($episode: Episode, $withFriends: Boolean!) {
-					hero(episode: $episode) {
+		public static GraphQLRequest DirectivesRequest { get; } = new GraphQLRequest(@"
+			query Hero($episode: Episode, $withFriends: Boolean!) {
+				hero(episode: $episode) {
+					name
+					friends @include(if: $withFriends) {
 						name
-						friends @include(if: $withFriends) {
-							name
-						}
 					}
-				}",
+				}
+			}") { 
 			Variables = new {
 				episode = "JEDI",
 				withFriends = false
@@ -158,14 +149,13 @@ friends @include(if: $withFriends) {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#mutations"/>
 		/// </summary>
-		public static GraphQLRequest MutationsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				mutation CreateReviewForEpisode($ep: Episode!, $review: ReviewInput!) {
-					createReview(episode: $ep, review: $review) {
-						stars
-						commentary
-					}
-				}",
+		public static GraphQLRequest MutationsRequest { get; } = new GraphQLRequest(@"
+			mutation CreateReviewForEpisode($ep: Episode!, $review: ReviewInput!) {
+				createReview(episode: $ep, review: $review) {
+					stars
+					commentary
+				}
+			}") { 
 			Variables = new {
 				ep = "JEDI",
 				review = new {
@@ -178,19 +168,18 @@ mutation CreateReviewForEpisode($ep: Episode!, $review: ReviewInput!) {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#inline-fragments"/>
 		/// </summary>
-		public static GraphQLRequest InlineFragmentsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				query HeroForEpisode($ep: Episode!) {
-					hero(episode: $ep) {
-						name
-						... on Droid {
-							primaryFunction
-						}
-						... on Human {
-							height
-						}
+		public static GraphQLRequest InlineFragmentsRequest { get; } = new GraphQLRequest(@"
+			query HeroForEpisode($ep: Episode!) {
+				hero(episode: $ep) {
+					name
+					... on Droid {
+						primaryFunction
 					}
-				}",
+					... on Human {
+						height
+					}
+				}
+			}") { 
 			Variables = new {
 				ep = "JEDI"
 			}
@@ -199,22 +188,21 @@ ... on Human {
 		/// <summary>
 		/// <see href="http://graphql.org/learn/queries/#meta-fields"/>
 		/// </summary>
-		public static GraphQLRequest MetaFieldsRequest { get; } = new GraphQLRequest {
-			Query = @"
-				{
-					search(text: ""an"") {
-						__typename
-						...on Human {
-							name
-						}
-						... on Droid {
-							name
-						}
-						... on Starship {
-							name
-						}
+		public static GraphQLRequest MetaFieldsRequest { get; } = new GraphQLRequest(@"
+			{
+				search(text: ""an"") {
+					__typename
+					...on Human {
+						name
+					}
+					... on Droid {
+						name
 					}
-				}",
+					... on Starship {
+						name
+					}
+				}
+			}") { 
 			Variables = null
 		};
 
diff --git a/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs b/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs
index 2512fe3b..6eb0febd 100644
--- a/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs
+++ b/tests/GraphQL.Common.Tests/Request/GraphQLRequestTests.cs
@@ -7,49 +7,41 @@ public class GraphQLRequestTests {
 		[Fact]
 		public void FieldsRequest1Fact() {
 			var graphQLRequest = GraphQLRequestConsts.FieldsRequest1;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void FieldsRequest2Fact() {
 			var graphQLRequest = GraphQLRequestConsts.FieldsRequest2;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void ArgumentsRequest1Fact() {
 			var graphQLRequest = GraphQLRequestConsts.ArgumentsRequest1;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void ArgumentsRequest2Fact() {
 			var graphQLRequest = GraphQLRequestConsts.ArgumentsRequest2;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void AliasesRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.AliasesRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void FragmentsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.FragmentsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void OperationNameRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.OperationNameRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 		[Fact]
 		public void VariablesRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.VariablesRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.episode);
 		}
@@ -57,7 +49,6 @@ public void VariablesRequestFact() {
 		[Fact]
 		public void DirectivesRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.DirectivesRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.episode);
 			Assert.Equal(false, graphQLRequest.Variables.withFriends);
@@ -66,7 +57,6 @@ public void DirectivesRequestFact() {
 		[Fact]
 		public void MutationsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.MutationsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.ep);
 			Assert.Equal(5, graphQLRequest.Variables.review.stars);
@@ -76,7 +66,6 @@ public void MutationsRequestFact() {
 		[Fact]
 		public void InlineFragmentsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.InlineFragmentsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 			Assert.NotNull(graphQLRequest.Variables);
 			Assert.Equal("JEDI", graphQLRequest.Variables.ep);
 		}
@@ -84,7 +73,6 @@ public void InlineFragmentsRequestFact() {
 		[Fact]
 		public void MetaFieldsRequestFact() {
 			var graphQLRequest = GraphQLRequestConsts.MetaFieldsRequest;
-			AssertGraphQL.CorrectGraphQLRequest(graphQLRequest);
 		}
 
 	}
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index c7dd0568..ff71ee6d 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -10,14 +10,13 @@ public static class GraphQLClientExtensions
 	{
 		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
 		{
-			var graphQLRequest = new GraphQLRequest
-			{
-				Query = @"
+			var graphQLRequest = new GraphQLRequest(@"
 				mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
-				}",
+				}")
+			{
 				Variables = new
 				{
 					input = new
@@ -30,5 +29,23 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 			};
 			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
 		}
+
+		public static async Task<GraphQLResponse> JoinDeveloperUser(this GraphQLHttpClient client)
+		{
+			var graphQLRequest = new GraphQLRequest(@"
+				mutation($userId: String){
+				  join(userId: $userId){
+				    displayName
+				    id
+				  }
+				}")
+			{
+				Variables = new
+				{
+					userId = "1"
+				}
+			};
+			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 36804c95..635a0d1c 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -11,7 +11,6 @@
 using Microsoft.Extensions.Logging;
 using Xunit;
 
-
 namespace GraphQL.Integration.Tests
 {
 	public class SubscriptionsTest
@@ -24,7 +23,10 @@ public static IWebHost CreateServer(int port)
 			config["server.urls"] = $"http://localhost:{port}";
 
 			var host = new WebHostBuilder()
-				.ConfigureLogging((ctx, logging) => logging.AddDebug())
+				.ConfigureLogging((ctx, logging) =>
+				{
+					logging.AddDebug();
+				})
 				.UseConfiguration(config)
 				.UseKestrel()
 				.UseStartup<IntegrationTestServer.Startup>()
@@ -45,7 +47,7 @@ private GraphQLHttpClient GetGraphQLClient(int port)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-			} );
+			});
 
 
 		[Fact]
@@ -70,10 +72,7 @@ public async void AssertTestingHarness()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest
-		{
-			Query = SubscriptionQuery
-		};
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
 		[Fact]
 		public async void CanCreateObservableSubscription()
@@ -165,21 +164,16 @@ public async void CanReconnectWithSameObservable()
 
 		private const string SubscriptionQuery2 = @"
 			subscription {
-			  messageAdded{
-			    content
-				from {
-				  displayName
-				}
+			  userJoined{
+				displayName
+				id
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest
-		{
-			Query = SubscriptionQuery2
-		};
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
-		public async void CanConnectMultipleSubscriptionsSimultaneously()
+		public async void CanConnectTwoSubscriptionsSimultaneously()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackTester<Exception>();
@@ -189,10 +183,12 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> subscription1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
-				var tester = subscription1.SubscribeTester();
+				var tester = observable1.SubscribeTester();
+				var tester2 = observable2.SubscribeTester();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -202,42 +198,31 @@ public async void CanConnectMultipleSubscriptionsSimultaneously()
 					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
 				});
 
-				IObservable<GraphQLResponse> subscription2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
-				var tester2 = subscription2.SubscribeTester();
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
-				}, TimeSpan.FromSeconds(10));
+				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
+
+				response = await client.JoinDeveloperUser().ConfigureAwait(false);
+				Assert.Equal("developer", (string)response.Data.join.displayName.Value);
 
-				const string message2 = "How are you?";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string)response.Data.addMessage.content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-				});
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
+					Assert.Equal("1", (string)gqlResponse.Data.userJoined.id.Value);
+					Assert.Equal("developer", (string)gqlResponse.Data.userJoined.displayName.Value);
 				});
-
+				
 				Debug.WriteLine("disposing subscription...");
-				tester.Dispose();
+				tester2.Dispose();
 
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
-					Assert.Equal("tester", (string)gqlResponse.Data.messageAdded.from.displayName.Value);
 				});
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester2.ShouldHaveCompleted();
+				tester.ShouldHaveCompleted();
 			}
 		}
 
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
index 7c2a2333..0ca1dfbd 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -16,7 +16,18 @@ public ChatMutation(IChat chat)
                     var message = chat.AddMessage(receivedMessage);
                     return message;
                 });
-        }
+
+			Field<MessageFromType>("join",
+				arguments: new QueryArguments(
+					new QueryArgument<StringGraphType> { Name = "userId" }
+				),
+				resolve: context =>
+				{
+					var userId = context.GetArgument<string>("userId");
+					var userJoined = chat.Join(userId);
+					return userJoined;
+				});
+		}
     }
 
     public class MessageInputType : InputObjectGraphType
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 3c8c9624..0ceb77a5 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -25,7 +25,15 @@ public ChatSubscriptions(IChat chat)
                 Subscriber = new EventStreamResolver<Message>(Subscribe)
             });
 
-            AddField(new EventStreamFieldType
+			AddField(new EventStreamFieldType
+			{
+				Name = "contentAdded",
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(Subscribe)
+			});
+
+			AddField(new EventStreamFieldType
             {
                 Name = "messageAddedByUser",
                 Arguments = new QueryArguments(
@@ -35,7 +43,15 @@ public ChatSubscriptions(IChat chat)
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
                 Subscriber = new EventStreamResolver<Message>(SubscribeById)
             });
-        }
+
+			AddField(new EventStreamFieldType
+			{
+				Name = "userJoined",
+				Type = typeof(MessageFromType),
+				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
+				Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
+			});
+		}
 
         private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
         {
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
index 68c8e86b..e52c0432 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -11,16 +11,20 @@ public interface IChat
 
         Message AddMessage(Message message);
 
-        IObservable<Message> Messages(string user);
+		MessageFrom Join(string userId);
 
-        Message AddMessage(ReceivedMessage message);
+		IObservable<Message> Messages(string user);
+		IObservable<MessageFrom> UserJoined();
+
+		Message AddMessage(ReceivedMessage message);
     }
 
     public class Chat : IChat
     {
         private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+		private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
-        public Chat()
+		public Chat()
         {
             AllMessages = new ConcurrentStack<Message>();
             Users = new ConcurrentDictionary<string, string>
@@ -58,9 +62,25 @@ public Message AddMessage(Message message)
             AllMessages.Push(message);
             _messageStream.OnNext(message);
             return message;
-        }
+		}
+
+		public MessageFrom Join(string userId)
+		{
+			if (!Users.TryGetValue(userId, out var displayName))
+			{
+				displayName = "(unknown)";
+			}
+
+			var joinedUser = new MessageFrom {
+				Id = userId,
+				DisplayName = displayName
+			};
 
-        public IObservable<Message> Messages(string user)
+			_userJoined.OnNext(joinedUser);
+			return joinedUser;
+		}
+
+		public IObservable<Message> Messages(string user)
         {
             return _messageStream
                 .Select(message =>
@@ -75,5 +95,16 @@ public void AddError(Exception exception)
         {
             _messageStream.OnError(exception);
         }
-    }
+
+		public IObservable<MessageFrom> UserJoined()
+		{
+			return _userJoined.AsObservable();
+		}
+	}
+
+	public class User
+	{
+		public string Id { get; set; }
+		public string Name { get; set; }
+	}
 }
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 179554ff..cfba48cd 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -9,10 +9,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.2.0" />
-    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
     <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index fd8448a8..9b0392b7 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Logging;
 
 namespace IntegrationTestServer
 {
@@ -12,6 +13,7 @@ public static void Main(string[] args)
 
 		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
 			WebHost.CreateDefaultBuilder(args)
-				.UseStartup<Startup>();
+				.UseStartup<Startup>()
+			    .ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 	}
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 0161c739..166bf202 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,6 +1,7 @@
 using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
+using GraphQL.Server.Ui.Playground;
 using IntegrationTestServer.ChatSchema;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -63,6 +64,10 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 				GraphQLEndPoint = "/graphql",
 				Path = "/ui/voyager"
 			});
+			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
+			{
+				Path = "/ui/playground"
+			});
 			app.UseMvc();
 		}
 	}

From b5bba654e94fbd4f445c3bddf1fd01fd8d17698b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 11 Feb 2019 19:51:59 +0100
Subject: [PATCH 045/455] Fix concurrent subscriptions (#94)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart

* Update GraphQL.Client.Tests.csproj

* Nullable check (#86)

* nonnullable

* fix some things

* other fix

* netstandard2.0

* Update README.md

* create "queue" for requests so that only one send operation is performed at a time

* fix websockets on win 7

* remove websockets4net dependency

* Update root.props

* Update config.yml

* IsTestProject

* Benchmar

* benchmark

* Update GraphQLLocation.cs

* new Spec

* fix suff for dotnet core 3.0

* check response for 'null' in where clause

* add obsolete parameterless constructor to GraphQLRequest

* add debug output in websocket receive

* reuse observables for identical requests

* store changes to consoleapp

* fix StackOverflowException in GraphQLRequest.GetHashCode()

* fix receiving long messages via websocket

* add obsolete constructor

* make ReceiveResultStream observable Hot

* fix multiple subscriptions by using subject in GraphQLHttpWebSocket

* fix overlapping subscriptions

* fix subscription test to work arround https://github.com/graphql-dotnet/server/pull/199

* add an observable which publishes all websocket exceptions

* fix OnNext calls of exceptionSubject

* fix GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) constructor

* test requests via websockets

* bump pre-release version

* fix initializing websocket when multiple threads create a subscription concurrently
---
 root.props                                    |  2 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  7 ++-
 .../Http/GraphQLHttpWebSocket.cs              | 61 ++++++++++---------
 3 files changed, 38 insertions(+), 32 deletions(-)

diff --git a/root.props b/root.props
index b32dba6a..61db8f41 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.7</Version>
+		<Version>2.0.0-alpha.4.subscription-api.8</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index e6a76359..d242569b 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -171,7 +172,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
 
-			subscriptionStreams.Add(request, observable);
+			subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
 
@@ -202,11 +203,11 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 				return subscriptionStreams[request];
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
-			subscriptionStreams.Add(request, observable);
+			subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
 
-		private Dictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new Dictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+		private ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
 
 		/// <summary>
 		/// Releases unmanaged resources
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 90caf737..28ae1e7b 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -81,6 +81,8 @@ await this.clientWebSocket.SendAsync(
 
 		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
 
+		private object _initializeLock = new object();
+
 		#region Private Methods
 
 		private Task _backOff()
@@ -100,36 +102,39 @@ public Task InitializeWebSocket()
 			if(_disposed != null)
 				throw new OperationCanceledException();
 
-			// if an initialization task is already running, return that
-			if(InitializeWebSocketTask != null &&
-			   !InitializeWebSocketTask.IsFaulted &&
-			   !InitializeWebSocketTask.IsCompleted)
-				return InitializeWebSocketTask;
-
-			// if the websocket is open, return a completed task
-			if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
-				return Task.CompletedTask;
-
-			// else (re-)create websocket and connect
-			//_responseStreamConnection?.Dispose();
-			clientWebSocket?.Dispose();
-
-			// fix websocket not supported on win 7 using
-			// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
-			clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
-			switch (clientWebSocket)
+			lock (_initializeLock)
 			{
-				case ClientWebSocket nativeWebSocket:
-					nativeWebSocket.Options.AddSubProtocol("graphql-ws");
-					break;
-				case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
-					managedWebSocket.Options.AddSubProtocol("graphql-ws");
-					break;
-				default:
-					throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
-			}
+				// if an initialization task is already running, return that
+				if(InitializeWebSocketTask != null &&
+				   !InitializeWebSocketTask.IsFaulted &&
+				   !InitializeWebSocketTask.IsCompleted)
+					return InitializeWebSocketTask;
+
+				// if the websocket is open, return a completed task
+				if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+					return Task.CompletedTask;
+
+				// else (re-)create websocket and connect
+				//_responseStreamConnection?.Dispose();
+				clientWebSocket?.Dispose();
+
+				// fix websocket not supported on win 7 using
+				// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
+				clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+				switch (clientWebSocket)
+				{
+					case ClientWebSocket nativeWebSocket:
+						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+						break;
+					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
+						managedWebSocket.Options.AddSubProtocol("graphql-ws");
+						break;
+					default:
+						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+				}
 
-			return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+				return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+			}
 		}
 		
 		private IObservable<GraphQLWebSocketResponse> _createResponseStream()

From 93cd3704190e0d96d83f65080a6b4fa8cd9fdd70 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 7 Mar 2019 11:42:44 +0100
Subject: [PATCH 046/455] Fix json converter in websocket (#99)

* add StringEnumConverter to JsonSerializerSettings

* fix dependencies

* change version

* fix version

* fix CloseAsync

* lock dispose

* implement external exception handling for subscription streams

* fix doc comment

* add back-off delay for automatic reconnects

* create GraphQLHttpWebSocket class

* get single socket working

* fix subscription test, cleanup code

* more code cleanup

* add test CanConnectMultipleSubscriptionsSimultaneously

* dynamically find free ports for integration test

* add WebSocketExceptionHandler to clientOptions

* move reconnect-logic into subscriptions

* move external exception handler declaration to CreateSubscriptionStream overloads

* fix exception on disposing disconnected subscription

* fix tests, add console app for testing reconnect after server restart

* Update GraphQL.Client.Tests.csproj

* Nullable check (#86)

* nonnullable

* fix some things

* other fix

* netstandard2.0

* Update README.md

* create "queue" for requests so that only one send operation is performed at a time

* fix websockets on win 7

* remove websockets4net dependency

* Update root.props

* Update config.yml

* IsTestProject

* Benchmar

* benchmark

* Update GraphQLLocation.cs

* new Spec

* fix suff for dotnet core 3.0

* check response for 'null' in where clause

* add obsolete parameterless constructor to GraphQLRequest

* add debug output in websocket receive

* reuse observables for identical requests

* store changes to consoleapp

* fix StackOverflowException in GraphQLRequest.GetHashCode()

* fix receiving long messages via websocket

* add obsolete constructor

* make ReceiveResultStream observable Hot

* fix multiple subscriptions by using subject in GraphQLHttpWebSocket

* fix overlapping subscriptions

* fix subscription test to work arround https://github.com/graphql-dotnet/server/pull/199

* add an observable which publishes all websocket exceptions

* fix OnNext calls of exceptionSubject

* fix GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) constructor

* test requests via websockets

* bump pre-release version

* use JsonSerializerSettings from options in websocket requests

* fix query errors via websocket

* fix sequence termination and error handling in websocket streams
---
 root.props                                    |  2 +-
 .../Http/GraphQLHttpSubscriptionHelpers.cs    | 79 ++++++++--------
 .../Http/GraphQLHttpWebSocket.cs              |  4 +-
 .../SubscriptionsTest.cs                      | 89 ++++++++++++++++++-
 .../ChatSchema/ChatSubscriptions.cs           |  9 ++
 5 files changed, 138 insertions(+), 45 deletions(-)

diff --git a/root.props b/root.props
index 61db8f41..df16b57f 100644
--- a/root.props
+++ b/root.props
@@ -17,7 +17,7 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.8</Version>
+		<Version>2.0.0-alpha.4.subscription-api.10</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
index ef71a0ce..4ba91205 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
@@ -3,6 +3,7 @@
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Common;
@@ -35,31 +36,39 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Id = startRequest.Id,
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
-					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => {
-							return response != null && response.Id == startRequest.Id;
-						})
-						.SelectMany(response =>
-						{
-							switch (response.Type)
+
+					var observable = Observable.Create<GraphQLResponse>(o =>
+						graphQlHttpWebSocket.ResponseStream.Subscribe(response =>
 							{
-								case GQLWebSocketMessageType.GQL_COMPLETE:
+								// ignore null values and messages for other requests
+								if (response == null || response.Id != startRequest.Id) return;
+
+								// terminate the sequence when a 'complete' message is received
+								if (response.Type == GQLWebSocketMessageType.GQL_COMPLETE)
+								{
 									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-									return Observable.Empty<GraphQLResponse>();
-								case GQLWebSocketMessageType.GQL_ERROR:
-									Debug.WriteLine($"received 'error' message on subscription {startRequest.Id}");
-									return Observable.Throw<GraphQLResponse>(
-										new GraphQLSubscriptionException(response.Payload));
-								default:
-									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-									return Observable.Return(((JObject) response?.Payload)
-										?.ToObject<GraphQLResponse>());
-							}
-						});
+									o.OnCompleted();
+									return;
+								}
+
+								// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+								Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+								o.OnNext(((JObject)response.Payload)?.ToObject<GraphQLResponse>());
+
+								// in case of a GraphQL error, terminate the sequence after the response has been posted
+								if (response.Type == GQLWebSocketMessageType.GQL_ERROR)
+								{
+									Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+									o.OnCompleted();
+								}
+							},
+							o.OnError,
+							o.OnCompleted)
+					);
 
 					try
 					{
-						// intialize websocket (completes immediately if socket is already open)
+						// initialize websocket (completes immediately if socket is already open)
 						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
 					}
 					catch (Exception e)
@@ -148,12 +157,12 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				.Publish().RefCount();
 		}
 
-		internal static async Task<GraphQLResponse> Request(
+		internal static Task<GraphQLResponse> Request(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
 			CancellationToken cancellationToken = default)
 		{
-			return await Observable.Create<GraphQLResponse>(async observer =>
+			return Observable.Create<GraphQLResponse>(async observer =>
 			{
 				var websocketRequest = new GraphQLWebSocketRequest
 				{
@@ -162,25 +171,12 @@ internal static async Task<GraphQLResponse> Request(
 					Payload = request
 				};
 				var observable = graphQlHttpWebSocket.ResponseStream
-					.Where(response => {
-						return response != null && response.Id == websocketRequest.Id;
-					})
-					.SelectMany(response =>
+					.Where(response => response != null && response.Id == websocketRequest.Id)
+					.TakeUntil(response => response.Type == GQLWebSocketMessageType.GQL_COMPLETE)
+					.Select(response =>
 					{
-						switch (response.Type)
-						{
-							case GQLWebSocketMessageType.GQL_COMPLETE:
-								Debug.WriteLine($"received 'complete' message on request {websocketRequest.Id}");
-								return Observable.Empty<GraphQLResponse>();
-							case GQLWebSocketMessageType.GQL_ERROR:
-								Debug.WriteLine($"received 'error' message on request {websocketRequest.Id}");
-								return Observable.Throw<GraphQLResponse>(
-									new GraphQLSubscriptionException(response.Payload));
-							default:
-								Debug.WriteLine($"received response for request {websocketRequest.Id}");
-								return Observable.Return(((JObject)response?.Payload)
-									?.ToObject<GraphQLResponse>());
-						}
+						Debug.WriteLine($"received response for request {websocketRequest.Id}");
+						return ((JObject) response?.Payload)?.ToObject<GraphQLResponse>();
 					});
 
 				try
@@ -215,7 +211,8 @@ internal static async Task<GraphQLResponse> Request(
 			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 			.Catch<GraphQLResponse, OperationCanceledException>(exception =>
 				Observable.Empty<GraphQLResponse>())
-			.FirstOrDefaultAsync();
+			.FirstOrDefaultAsync()
+			.ToTask(cancellationToken);
 		}
 	}
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 28ae1e7b..eb2881ba 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -65,7 +65,7 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 				}
 
 				await InitializeWebSocket().ConfigureAwait(false);
-				var webSocketRequestString = JsonConvert.SerializeObject(request);
+				var webSocketRequestString = JsonConvert.SerializeObject(request, _options.JsonSerializerSettings);
 				await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
 					WebSocketMessageType.Text,
@@ -245,7 +245,7 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 						{
 							var stringResult = await reader.ReadToEndAsync();
 							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
-							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
+							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult, _options.JsonSerializerSettings);
 						}
 					}
 					else
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 635a0d1c..fb704ad4 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -43,10 +43,11 @@ public SubscriptionsTest()
 		{
 		}
 
-		private GraphQLHttpClient GetGraphQLClient(int port)
+		private GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+				UseWebSocketForQueriesAndMutations = requestsViaWebsocket
 			});
 
 
@@ -65,6 +66,34 @@ public async void AssertTestingHarness()
 			}
 		}
 
+		[Fact]
+		public async void CanSendRequestViaWebsocket()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port, true);
+				const string message = "some random testing message";
+				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
+
+				Assert.Equal(message, (string)response.Data.addMessage.content);
+			}
+		}
+
+		[Fact]
+		public async void CanHandleRequestErrorViaWebsocket()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port, true);
+				const string message = "some random testing message";
+				var response = await client.SendQueryAsync(new GraphQLRequest("this query is formatted quite badly")).ConfigureAwait(false);
+
+				Assert.Single(response.Errors);
+			}
+		}
+
 		private const string SubscriptionQuery = @"
 			subscription {
 			  messageAdded{
@@ -272,5 +301,63 @@ public async void CanHandleConnectionTimeout()
 			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
 			server.Dispose();
 		}
+		
+		[Fact]
+		public async void CanHandleSubscriptionError()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(
+					new GraphQLRequest(@"
+						subscription {
+						  failImmediately {
+						    content
+						  }
+						}")
+					);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Single(gqlResponse.Errors);
+				});
+				tester.ShouldHaveCompleted();
+
+				client.Dispose();
+			}
+		}
+
+		[Fact]
+		public async void CanHandleQueryErrorInSubscription()
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(
+					new GraphQLRequest(@"
+						subscription {
+						  fieldDoesNotExist {
+						    content
+						  }
+						}")
+				);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.SubscribeTester();
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Single(gqlResponse.Errors);
+				});
+				tester.ShouldHaveCompleted();
+
+				client.Dispose();
+			}
+		}
 	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 0ceb77a5..178d2b78 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -51,6 +51,15 @@ public ChatSubscriptions(IChat chat)
 				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
 				Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
 			});
+
+
+			AddField(new EventStreamFieldType
+			{
+				Name = "failImmediately",
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(context => throw new NotSupportedException("this is supposed to fail"))
+			});
 		}
 
         private IObservable<Message> SubscribeById(ResolveEventStreamContext context)

From 1d56d41cb456af86755f6ead7adc1bf611c3a510 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 28 Jan 2020 22:38:16 +0100
Subject: [PATCH 047/455] fix problems in solution

---
 GraphQL.Client.sln.DotSettings                |   2 +
 .../GraphQL.Client.Http.Examples/Program.cs   |   1 -
 .../GraphQL.Client.Http.csproj                |   8 +
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  | 146 ++++++++++++++----
 .../GraphQLHttpClientOptions.cs               |   1 -
 .../GraphQLHttpClient_SubscriptionApi.cs}     |  39 +----
 .../GraphQLHttpSubscriptionHelpers.cs         |  15 +-
 .../GraphQLHttpWebSocket.cs                   |   2 -
 .../GraphQLSubscriptionException.cs           |   2 -
 ...Type.cs => GraphQLWebSocketMessageType.cs} |   8 +-
 .../GraphQLWebSocketRequest.cs                |   2 +-
 .../GraphQLWebSocketResponse.cs               |   2 +-
 .../HttpClientExtensions.cs                   |  12 +-
 src/GraphQL.Client/IGraphQLClient.cs          |   8 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |  17 +-
 .../CallbackTester.cs                         |   3 -
 .../GraphQL.Integration.Tests.csproj          |   1 +
 .../GraphQLClientExtensions.cs                |   3 +-
 .../ObservableTester.cs                       |   3 -
 .../SubscriptionsTest.cs                      |   3 +-
 20 files changed, 167 insertions(+), 111 deletions(-)
 create mode 100644 GraphQL.Client.sln.DotSettings
 rename src/{GraphQL.Client/Http/GraphQLHttpClient.cs => GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs} (81%)
 rename src/GraphQL.Client.Http/{GQLWebSocketMessageType.cs => GraphQLWebSocketMessageType.cs} (96%)

diff --git a/GraphQL.Client.sln.DotSettings b/GraphQL.Client.sln.DotSettings
new file mode 100644
index 00000000..9e5ec22f
--- /dev/null
+++ b/GraphQL.Client.sln.DotSettings
@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=QL/@EntryIndexedValue">QL</s:String></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/examples/GraphQL.Client.Http.Examples/Program.cs b/examples/GraphQL.Client.Http.Examples/Program.cs
index 50618a1d..7924a3d7 100644
--- a/examples/GraphQL.Client.Http.Examples/Program.cs
+++ b/examples/GraphQL.Client.Http.Examples/Program.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Text.Json;
-using System.Text.Json.Serialization;
 using System.Threading.Tasks;
 using GraphQL.Server.Test.GraphQL.Models;
 using Microsoft.AspNetCore.TestHost;
diff --git a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
index 05900a76..adf84a10 100644
--- a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
+++ b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
@@ -6,6 +6,14 @@
 		<TargetFramework>netstandard2.0</TargetFramework>
     </PropertyGroup>
 
+    <ItemGroup>
+      <Compile Remove="GraphQLHttpClient_SubscriptionApi.cs" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <None Include="GraphQLHttpClient_SubscriptionApi.cs" />
+    </ItemGroup>
+
     <ItemGroup>
       <ProjectReference Include="..\GraphQL.Client\GraphQL.Client.csproj" />
     </ItemGroup>
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 634bcd2b..071ed2a3 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Concurrent;
 using System.Net.Http;
+using System.Net.WebSockets;
 using System.Text;
 using System.Text.Json;
 using System.Threading;
@@ -9,56 +11,50 @@ namespace GraphQL.Client.Http {
 
 	public class GraphQLHttpClient : IDisposable, IGraphQLClient {
 
+		private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
+		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+		private readonly HttpClient httpClient;
+
 		public Uri EndPoint { get; set; }
 
 		public JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions {
 			PropertyNamingPolicy = JsonNamingPolicy.CamelCase
 		};
+		
+		/// <summary>
+		/// The Options	to be used
+		/// </summary>
+		public GraphQLHttpClientOptions Options { get; }
 
-		private readonly HttpClient httpClient;
+		/// <inheritdoc />
+		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
 
-		public GraphQLHttpClient(string endPoint) {
-			this.EndPoint = new Uri(endPoint);
-			this.httpClient = new HttpClient();
-		}
 
-		public GraphQLHttpClient(Uri endPoint) {
-			this.EndPoint = endPoint;
-			this.httpClient = new HttpClient();
-		}
+		public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint))
+		{ }
 
-		public GraphQLHttpClient(string endPoint, GraphQLHttpClientOptions options) {
-			this.EndPoint = new Uri(endPoint);
+		public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint)
+		{ }
+		
+		public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
+			Options = new GraphQLHttpClientOptions();
+			configure(Options);
 			this.httpClient = new HttpClient();
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
-		public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
-			this.EndPoint = endPoint;
+		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
+			Options = options;
 			this.httpClient = new HttpClient();
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
-		public GraphQLHttpClient(string endPoint, HttpClient httpClient) {
-			this.EndPoint = new Uri(endPoint);
-			this.httpClient = httpClient;
-		}
-
-		public GraphQLHttpClient(Uri endPoint, HttpClient httpClient) {
-			this.EndPoint = endPoint;
-			this.httpClient = httpClient;
-		}
-
-		public GraphQLHttpClient(string endPoint, GraphQLHttpClientOptions options, HttpClient httpClient) {
-			this.EndPoint = new Uri(endPoint);
+		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
+			Options = options;
 			this.httpClient = httpClient;
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
-
-		public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options, HttpClient httpClient) {
-			this.EndPoint = endPoint;
-			this.httpClient = httpClient;
-		}
-
-		public void Dispose() => this.httpClient.Dispose();
-
+		
 		public async Task<GraphQLHttpResponse<TResponse>> SendHttpQueryAsync<TVariable, TResponse>(GraphQLHttpRequest<TVariable> request, CancellationToken cancellationToken = default) {
 			using var httpRequestMessage = this.GenerateHttpRequestMessage(request);
 			using var httpResponseMessage = await this.httpClient.SendAsync(httpRequestMessage, cancellationToken);
@@ -103,6 +99,90 @@ public async Task<GraphQLResponse<R>> SendMutationAsync<R>(GraphQLRequest reques
 			await Task.CompletedTask;
 			throw new NotImplementedException();
 		}
+		public async Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			await Task.CompletedTask;
+			throw new NotImplementedException();
+		}
+
+		public async Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			await Task.CompletedTask;
+			throw new NotImplementedException();
+		}
+
+		private Uri GetWebSocketUri() {
+			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
+			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
+		}
+
+		/// <inheritdoc />
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request) {
+			if (disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: cancellationTokenSource.Token);
+
+			subscriptionStreams.TryAdd(request, observable);
+			return observable;
+		}
+
+		/// <inheritdoc />
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) {
+			if (disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			return CreateSubscriptionStream(request, e => {
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		/// <inheritdoc />
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler) {
+			if (disposed)
+				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+			if (subscriptionStreams.ContainsKey(request))
+				return subscriptionStreams[request];
+
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, cancellationTokenSource.Token);
+			subscriptionStreams.TryAdd(request, observable);
+			return observable;
+		}
+
+		private ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+
+
+		#region IDisposable
+
+		/// <summary>
+		/// Releases unmanaged resources
+		/// </summary>
+		public void Dispose() {
+			lock (disposeLocker) {
+				if (!disposed) {
+					_dispose();
+				}
+			}
+		}
+
+		private bool disposed = false;
+		private readonly object disposeLocker = new object();
+
+		private void _dispose() {
+			disposed = true;
+			this.httpClient.Dispose();
+			this.graphQlHttpWebSocket.Dispose();
+			cancellationTokenSource.Cancel();
+			cancellationTokenSource.Dispose();
+		}
+
+		#endregion
+
 	}
 
 }
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index ddce13c7..c948c4de 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Net.WebSockets;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs
similarity index 81%
rename from src/GraphQL.Client/Http/GraphQLHttpClient.cs
rename to src/GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs
index d242569b..1d43a90a 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs
@@ -7,15 +7,13 @@
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
 
 namespace GraphQL.Client.Http {
 
 	/// <summary>
 	/// A Client to access GraphQL EndPoints
 	/// </summary>
-	public partial class GraphQLHttpClient : IGraphQLClient {
+	public class GraphQLHttpClient_SubscriptionApi : IGraphQLClient {
 
 		#region Properties
 
@@ -54,27 +52,27 @@ public GraphQLHttpClientOptions Options {
 		/// Initializes a new instance
 		/// </summary>
 		/// <param name="endPoint">The EndPoint to be used</param>
-		public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint)) { }
+		public GraphQLHttpClient_SubscriptionApi(string endPoint) : this(new Uri(endPoint)) { }
 
 		/// <summary>
 		/// Initializes a new instance
 		/// </summary>
 		/// <param name="endPoint">The EndPoint to be used</param>
-		public GraphQLHttpClient(Uri endPoint) : this(new GraphQLHttpClientOptions { EndPoint = endPoint }) { }
+		public GraphQLHttpClient_SubscriptionApi(Uri endPoint) : this(new GraphQLHttpClientOptions { EndPoint = endPoint }) { }
 
 		/// <summary>
 		/// Initializes a new instance
 		/// </summary>
 		/// <param name="endPoint">The EndPoint to be used</param>
 		/// <param name="options">The Options to be used</param>
-		public GraphQLHttpClient(string endPoint, GraphQLHttpClientOptions options) : this(new Uri(endPoint), options) { }
+		public GraphQLHttpClient_SubscriptionApi(string endPoint, GraphQLHttpClientOptions options) : this(new Uri(endPoint), options) { }
 
 		/// <summary>
 		/// Initializes a new instance
 		/// </summary>
 		/// <param name="endPoint">The EndPoint to be used</param>
 		/// <param name="options">The Options to be used</param>
-		public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
+		public GraphQLHttpClient_SubscriptionApi(Uri endPoint, GraphQLHttpClientOptions options) {
 
 			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
 
@@ -91,7 +89,7 @@ public GraphQLHttpClient(Uri endPoint, GraphQLHttpClientOptions options) {
 		/// Initializes a new instance
 		/// </summary>
 		/// <param name="options">The Options to be used</param>
-		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
+		public GraphQLHttpClient_SubscriptionApi(GraphQLHttpClientOptions options) {
 			if (options == null) { throw new ArgumentNullException(nameof(options)); }
 			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
 			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
@@ -102,7 +100,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
 		}
 
-		internal GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
+		internal GraphQLHttpClient_SubscriptionApi(GraphQLHttpClientOptions options, HttpClient httpClient) {
 			if (options == null) { throw new ArgumentNullException(nameof(options)); }
 			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
 			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
@@ -132,28 +130,7 @@ public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, Cancellat
 				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
 				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
 		}
-
-		[Obsolete("EXPERIMENTAL API")]
-		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendSubscribeAsync(new GraphQLRequest(query), cancellationToken);
-
-		[Obsolete("EXPERIMENTAL API")]
-		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
-		{
-			GraphQLHttpSubscriptionResult graphQLSubscriptionResult = _createSubscription(request, cancellationToken);
-			return Task.FromResult<IGraphQLSubscriptionResult>(graphQLSubscriptionResult);
-		}
-
-		private GraphQLHttpSubscriptionResult _createSubscription(GraphQLRequest request, CancellationToken cancellationToken)
-		{
-			if (request == null) { throw new ArgumentNullException(nameof(request)); }
-			if (request.Query == null) { throw new ArgumentNullException(nameof(request.Query)); }
-
-			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), request);
-			graphQLSubscriptionResult.StartAsync(cancellationToken);
-			return graphQLSubscriptionResult;
-		}
-
+		
 		private Uri _getWebSocketUri()
 		{
 			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
diff --git a/src/GraphQL.Client.Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client.Http/GraphQLHttpSubscriptionHelpers.cs
index 4ba91205..e10400cb 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpSubscriptionHelpers.cs
@@ -6,9 +6,6 @@
 using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
-using GraphQL.Common;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
 using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http
@@ -28,13 +25,13 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 					var startRequest = new GraphQLWebSocketRequest
 					{
 						Id = Guid.NewGuid().ToString("N"),
-						Type = GQLWebSocketMessageType.GQL_START,
+						Type = GraphQLWebSocketMessageType.GQL_START,
 						Payload = request
 					};
 					var closeRequest = new GraphQLWebSocketRequest
 					{
 						Id = startRequest.Id,
-						Type = GQLWebSocketMessageType.GQL_STOP
+						Type = GraphQLWebSocketMessageType.GQL_STOP
 					};
 
 					var observable = Observable.Create<GraphQLResponse>(o =>
@@ -44,7 +41,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 								if (response == null || response.Id != startRequest.Id) return;
 
 								// terminate the sequence when a 'complete' message is received
-								if (response.Type == GQLWebSocketMessageType.GQL_COMPLETE)
+								if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
 								{
 									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
 									o.OnCompleted();
@@ -56,7 +53,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 								o.OnNext(((JObject)response.Payload)?.ToObject<GraphQLResponse>());
 
 								// in case of a GraphQL error, terminate the sequence after the response has been posted
-								if (response.Type == GQLWebSocketMessageType.GQL_ERROR)
+								if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
 								{
 									Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
 									o.OnCompleted();
@@ -167,12 +164,12 @@ internal static Task<GraphQLResponse> Request(
 				var websocketRequest = new GraphQLWebSocketRequest
 				{
 					Id = Guid.NewGuid().ToString("N"),
-					Type = GQLWebSocketMessageType.GQL_START,
+					Type = GraphQLWebSocketMessageType.GQL_START,
 					Payload = request
 				};
 				var observable = graphQlHttpWebSocket.ResponseStream
 					.Where(response => response != null && response.Id == websocketRequest.Id)
-					.TakeUntil(response => response.Type == GQLWebSocketMessageType.GQL_COMPLETE)
+					.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
 					.Select(response =>
 					{
 						Debug.WriteLine($"received response for request {websocketRequest.Id}");
diff --git a/src/GraphQL.Client.Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/GraphQLHttpWebSocket.cs
index eb2881ba..ca0967ed 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpWebSocket.cs
@@ -9,8 +9,6 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
 using Newtonsoft.Json;
 
 namespace GraphQL.Client.Http
diff --git a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
index 7aad64f0..465ad5f3 100644
--- a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Runtime.Serialization;
-using System.Text;
 
 namespace GraphQL.Client.Http
 {
diff --git a/src/GraphQL.Client.Http/GQLWebSocketMessageType.cs b/src/GraphQL.Client.Http/GraphQLWebSocketMessageType.cs
similarity index 96%
rename from src/GraphQL.Client.Http/GQLWebSocketMessageType.cs
rename to src/GraphQL.Client.Http/GraphQLWebSocketMessageType.cs
index 1e2fff76..3258236e 100644
--- a/src/GraphQL.Client.Http/GQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Http/GraphQLWebSocketMessageType.cs
@@ -1,10 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace GraphQL.Common
+namespace GraphQL.Client.Http
 {
-	public static class GQLWebSocketMessageType
+	public static class GraphQLWebSocketMessageType
 	{
 
 		/// <summary>
diff --git a/src/GraphQL.Client.Http/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Http/GraphQLWebSocketRequest.cs
index d805efc4..05a7993b 100644
--- a/src/GraphQL.Client.Http/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Http/GraphQLWebSocketRequest.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
-namespace GraphQL.Common.Request {
+namespace GraphQL.Client.Http {
 
 	/// <summary>
 	/// A Subscription Request
diff --git a/src/GraphQL.Client.Http/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Http/GraphQLWebSocketResponse.cs
index cd3fb2f4..7aeec637 100644
--- a/src/GraphQL.Client.Http/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Http/GraphQLWebSocketResponse.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace GraphQL.Common.Response {
+namespace GraphQL.Client.Http {
 
 	/// <summary>
 	/// A Subscription Response
diff --git a/src/GraphQL.Client.Http/HttpClientExtensions.cs b/src/GraphQL.Client.Http/HttpClientExtensions.cs
index 4f511101..3b4aa2de 100644
--- a/src/GraphQL.Client.Http/HttpClientExtensions.cs
+++ b/src/GraphQL.Client.Http/HttpClientExtensions.cs
@@ -6,17 +6,13 @@ namespace GraphQL.Client.Http {
 	public static class HttpClientExtensions {
 
 		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, string endPoint) =>
-			new GraphQLHttpClient(endPoint, httpClient);
+			httpClient.AsGraphQLClient(new Uri(endPoint));
 
 		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
-			new GraphQLHttpClient(endPoint, httpClient);
-
-		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, string endPoint, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
-			new GraphQLHttpClient(endPoint, graphQLHttpClientOptions, httpClient);
-
-		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
-			new GraphQLHttpClient(endPoint, graphQLHttpClientOptions, httpClient);
+			new GraphQLHttpClient(new GraphQLHttpClientOptions{EndPoint = endPoint}, httpClient);
 
+		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
+			new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
 	}
 
 }
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 6b5c787b..4b0c84f8 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -11,6 +11,10 @@ public interface IGraphQLClient : IDisposable {
 
 		Task<GraphQLResponse<R>> SendMutationAsync<R>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
+
+		Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
+
 		/// <summary>
 		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
 		/// All subscriptions made to this stream share the same hot observable.<br/>
@@ -18,7 +22,6 @@ public interface IGraphQLClient : IDisposable {
 		/// </summary>
 		/// <param name="request">the GraphQL request for this subscription</param>
 		/// <returns>an observable stream for the specified subscription</returns>
-		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
 
 		/// <summary>
@@ -31,7 +34,6 @@ public interface IGraphQLClient : IDisposable {
 		/// <param name="request">the GraphQL request for this subscription</param>
 		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
 		/// <returns>an observable stream for the specified subscription</returns>
-		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
 
 		/// <summary>
@@ -44,13 +46,11 @@ public interface IGraphQLClient : IDisposable {
 		/// <param name="request">the GraphQL request for this subscription</param>
 		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
 		/// <returns>an observable stream for the specified subscription</returns>
-		[Obsolete("EXPERIMENTAL")]
 		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
 
 		/// <summary>
 		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
 		/// </summary>
-		[Obsolete("EXPERIMENTAL")]
 		IObservable<Exception> WebSocketReceiveErrors { get; }
 	}
 
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index ea0773e5..2349378d 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -18,6 +18,19 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		/// </summary>
 		public string? OperationName { get; set; }
 
+		/// <summary>
+		/// The request variables
+		/// </summary>
+		public object? Variables { get; set; }
+
+		public GraphQLRequest()
+		{
+		}
+
+		public GraphQLRequest(string query) {
+			Query = query;
+		}
+
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
 		/// </summary>
@@ -70,9 +83,9 @@ public override int GetHashCode() {
 	public class GraphQLRequest<T> : GraphQLRequest, IEquatable<GraphQLRequest<T>?> {
 
 		/// <summary>
-		/// Represents the variables sended
+		/// Represents the request variables
 		/// </summary>
-		public T Variables { get; set; }
+		public new T Variables { get; set; }
 
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
index bf214d73..91995feb 100644
--- a/tests/GraphQL.Integration.Tests/CallbackTester.cs
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -1,8 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using Xunit;
 
 namespace GraphQL.Integration.Tests
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 5fc195bc..25e38b7e 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -20,6 +20,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client.Http\GraphQL.Client.Http.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index ff71ee6d..bddb184d 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -1,8 +1,7 @@
 using System;
 using System.Threading.Tasks;
+using GraphQL.Client;
 using GraphQL.Client.Http;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
 
 namespace GraphQL.Integration.Tests
 {
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index 1569176d..5478825b 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -1,8 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using Xunit;
 
 namespace GraphQL.Integration.Tests
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index fb704ad4..a3ea92e7 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -3,9 +3,8 @@
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client;
 using GraphQL.Client.Http;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;

From ef7882666d9ac802bace9da2e1beb2275df4803f Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 28 Jan 2020 22:50:06 +0100
Subject: [PATCH 048/455] refactor GraphQLRequest, use options class in client

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  | 20 ++--
 .../GraphQLHttpClientOptions.cs               |  8 ++
 src/GraphQL.Primitives/GraphQLRequest.cs      | 97 +++++--------------
 3 files changed, 38 insertions(+), 87 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 071ed2a3..8f471d15 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -9,17 +9,11 @@
 
 namespace GraphQL.Client.Http {
 
-	public class GraphQLHttpClient : IDisposable, IGraphQLClient {
+	public class GraphQLHttpClient : IGraphQLClient {
 
 		private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 		private readonly HttpClient httpClient;
-
-		public Uri EndPoint { get; set; }
-
-		public JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions {
-			PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-		};
 		
 		/// <summary>
 		/// The Options	to be used
@@ -63,7 +57,7 @@ public async Task<GraphQLHttpResponse<TResponse>> SendHttpQueryAsync<TVariable,
 			}
 
 			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
-			return await JsonSerializer.DeserializeAsync<GraphQLHttpResponse<TResponse>>(bodyStream, this.JsonSerializerOptions, cancellationToken);
+			return await JsonSerializer.DeserializeAsync<GraphQLHttpResponse<TResponse>>(bodyStream, this.Options.JsonSerializerOptions, cancellationToken);
 		}
 
 		public async Task<GraphQLHttpResponse<TResponse>> SendHttpQueryAsync<TResponse>(GraphQLHttpRequest request, CancellationToken cancellationToken = default) =>
@@ -85,8 +79,8 @@ public async Task<GraphQLResponse<TResponse>> SendMutationAsync<TVariable, TResp
 		}
 
 		private HttpRequestMessage GenerateHttpRequestMessage<T>(GraphQLRequest<T> request) {
-			return new HttpRequestMessage(HttpMethod.Post, this.EndPoint) {
-				Content = new StringContent(JsonSerializer.Serialize(request, this.JsonSerializerOptions), Encoding.UTF8, "application/json")
+			return new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
+				Content = new StringContent(JsonSerializer.Serialize(request, this.Options.JsonSerializerOptions), Encoding.UTF8, "application/json")
 			};
 		}
 
@@ -110,8 +104,8 @@ public async Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, Can
 		}
 
 		private Uri GetWebSocketUri() {
-			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
-			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
+			var webSocketSchema = this.Options.EndPoint.Scheme == "https" ? "wss" : "ws";
+			return new Uri($"{webSocketSchema}://{this.Options.EndPoint.Host}:{this.Options.EndPoint.Port}{this.Options.EndPoint.AbsolutePath}");
 		}
 
 		/// <inheritdoc />
@@ -154,7 +148,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			return observable;
 		}
 
-		private ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+		private readonly ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
 
 
 		#region IDisposable
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index c948c4de..73a0a591 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Text.Json;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
@@ -29,6 +30,13 @@ public class GraphQLHttpClientOptions {
 			}
 		};
 
+		/// <summary>
+		/// The <see cref="JsonSerializerOptions"/> that is going to be used
+		/// </summary>
+		public JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions {
+			PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+		};
+
 		/// <summary>
 		/// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
 		/// </summary>
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 2349378d..dc1fbb2a 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -6,7 +6,7 @@ namespace GraphQL {
 	/// <summary>
 	/// A GraphQL request
 	/// </summary>
-	public class GraphQLRequest : IEquatable<GraphQLRequest?> {
+	public class GraphQLRequest<TVariables> : IEquatable<GraphQLRequest<TVariables>?> {
 
 		/// <summary>
 		/// The Query
@@ -19,35 +19,28 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		public string? OperationName { get; set; }
 
 		/// <summary>
-		/// The request variables
+		/// Represents the request variables
 		/// </summary>
-		public object? Variables { get; set; }
-
-		public GraphQLRequest()
-		{
-		}
-
-		public GraphQLRequest(string query) {
-			Query = query;
-		}
+		public TVariables Variables { get; set; }
 
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
 		/// </summary>
 		/// <param name="obj">The object to compare with this instance</param>
 		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest);
+		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest<TVariables>);
 
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
 		/// </summary>
 		/// <param name="other">The object to compare with this instance</param>
 		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public bool Equals(GraphQLRequest? other) {
+		public bool Equals(GraphQLRequest<TVariables>? other) {
 			if (other == null) { return false; }
 			if (ReferenceEquals(this, other)) { return true; }
 			if (!EqualityComparer<string>.Default.Equals(this.Query, other.Query)) { return false; }
 			if (!EqualityComparer<string?>.Default.Equals(this.OperationName, other.OperationName)) { return false; }
+			if (!EqualityComparer<dynamic?>.Default.Equals(this.Variables, other.Variables)) { return false; }
 			return true;
 		}
 
@@ -56,83 +49,39 @@ public bool Equals(GraphQLRequest? other) {
 		/// </summary>
 		public override int GetHashCode() {
 			unchecked {
-				var hashCode = EqualityComparer<string>.Default.GetHashCode(this.Query);
-				hashCode = (hashCode * 397) ^ EqualityComparer<string?>.Default.GetHashCode(this.OperationName);
-				return hashCode;
+				return base.GetHashCode() * 397 ^ EqualityComparer<dynamic?>.Default.GetHashCode(this.Variables);
 			}
 		}
 
 		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
+		/// Tests whether two specified <see cref="GraphQLRequest{TVariables}"/> instances are equivalent
 		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the equality operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the equality operator</param>
+		/// <param name="left">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the left of the equality operator</param>
+		/// <param name="right">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the right of the equality operator</param>
 		/// <returns>true if left and right are equal; otherwise, false</returns>
-		public static bool operator ==(GraphQLRequest? left, GraphQLRequest? right) => EqualityComparer<GraphQLRequest?>.Default.Equals(left, right);
+		public static bool operator ==(GraphQLRequest<TVariables>? left, GraphQLRequest<TVariables>? right) => EqualityComparer<GraphQLRequest<TVariables>?>.Default.Equals(left, right);
 
 		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are not equal
+		/// Tests whether two specified <see cref="GraphQLRequest{TVariables}"/> instances are not equal
 		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the not equal operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the not equal operator</param>
+		/// <param name="left">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the left of the not equal operator</param>
+		/// <param name="right">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the right of the not equal operator</param>
 		/// <returns>true if left and right are unequal; otherwise, false</returns>
-		public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
+		public static bool operator !=(GraphQLRequest<TVariables>? left, GraphQLRequest<TVariables>? right) => !(left == right);
 
 	}
 
-	public class GraphQLRequest<T> : GraphQLRequest, IEquatable<GraphQLRequest<T>?> {
-
-		/// <summary>
-		/// Represents the request variables
-		/// </summary>
-		public new T Variables { get; set; }
-
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="obj">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest<T>);
-
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="other">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public bool Equals(GraphQLRequest<T>? other) {
-			if (other == null) { return false; }
-			if (ReferenceEquals(this, other)) { return true; }
-			if (!EqualityComparer<string>.Default.Equals(this.Query, other.Query)) { return false; }
-			if (!EqualityComparer<string?>.Default.Equals(this.OperationName, other.OperationName)) { return false; }
-			if (!EqualityComparer<dynamic?>.Default.Equals(this.Variables, other.Variables)) { return false; }
-			return true;
+	/// <summary>
+	/// dynamic variant of a GraphQLRequest
+	/// </summary>
+	public class GraphQLRequest : GraphQLRequest<dynamic?> {
+		public GraphQLRequest()
+		{
 		}
 
-		/// <summary>
-		/// <inheritdoc cref="Object.GetHashCode"/>
-		/// </summary>
-		public override int GetHashCode() {
-			unchecked {
-				return base.GetHashCode() * 397 ^ EqualityComparer<dynamic?>.Default.GetHashCode(this.Variables);
-			}
+		public GraphQLRequest(string query) {
+			Query = query;
 		}
-
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the equality operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the equality operator</param>
-		/// <returns>true if left and right are equal; otherwise, false</returns>
-		public static bool operator ==(GraphQLRequest<T>? left, GraphQLRequest<T>? right) => EqualityComparer<GraphQLRequest<T>?>.Default.Equals(left, right);
-
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are not equal
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the not equal operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the not equal operator</param>
-		/// <returns>true if left and right are unequal; otherwise, false</returns>
-		public static bool operator !=(GraphQLRequest<T>? left, GraphQLRequest<T>? right) => !(left == right);
-
 	}
 
 }

From 72a0279b7a68c7f4d19444261052cb947ccdc329 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 09:04:36 +0100
Subject: [PATCH 049/455] reorganize websocket classes, fix type handling

---
 .../GraphQL.Client.Http.Examples/Program.cs   |  10 +-
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  | 117 ++++++-------
 .../GraphQLSerializationExtensions.cs         |  25 +++
 .../{ => Websocket}/GraphQLHttpWebSocket.cs   |  50 +++---
 .../GraphQLHttpWebsocketHelpers.cs}           |  63 +++----
 .../GraphQLWebSocketMessageType.cs            |   2 +-
 .../GraphQLWebSocketRequest.cs                |   6 +-
 .../GraphQLWebSocketResponse.cs               |  47 ++++--
 .../Websocket/WebsocketResponseWrapper.cs     |   9 +
 src/GraphQL.Client/GraphQLClientExtensions.cs |  26 +++
 src/GraphQL.Client/IGraphQLClient.cs          |  10 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |  95 ++++++++---
 .../JsonSerializationTests.cs                 |  25 +++
 .../GraphQLRequestTest.cs                     | 155 ++++--------------
 .../GraphQL.Integration.Tests.csproj          |   1 -
 .../GraphQLClientExtensions.cs                |  27 ++-
 .../SubscriptionsTest.cs                      |  67 +++++---
 17 files changed, 412 insertions(+), 323 deletions(-)
 create mode 100644 src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
 rename src/GraphQL.Client.Http/{ => Websocket}/GraphQLHttpWebSocket.cs (85%)
 rename src/GraphQL.Client.Http/{GraphQLHttpSubscriptionHelpers.cs => Websocket/GraphQLHttpWebsocketHelpers.cs} (72%)
 rename src/GraphQL.Client.Http/{ => Websocket}/GraphQLWebSocketMessageType.cs (99%)
 rename src/GraphQL.Client.Http/{ => Websocket}/GraphQLWebSocketRequest.cs (93%)
 rename src/GraphQL.Client.Http/{ => Websocket}/GraphQLWebSocketResponse.cs (55%)
 create mode 100644 src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
 create mode 100644 src/GraphQL.Client/GraphQLClientExtensions.cs
 create mode 100644 tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs

diff --git a/examples/GraphQL.Client.Http.Examples/Program.cs b/examples/GraphQL.Client.Http.Examples/Program.cs
index 7924a3d7..a8f42500 100644
--- a/examples/GraphQL.Client.Http.Examples/Program.cs
+++ b/examples/GraphQL.Client.Http.Examples/Program.cs
@@ -15,8 +15,8 @@ public class Program {
 		public async static Task Main(string[] args) {
 			using var httpClient = testServer.CreateClient();
 			using var graphqlClient = httpClient.AsGraphQLClient($"{testServer.BaseAddress}graphql");
-			var graphQLHttpRequest = new GraphQLHttpRequest {
-				Query = @"
+			var graphQLRequest = GraphQLRequest.New(
+				@"
 					{
 						repository(owner: ""graphql-dotnet"", name: ""graphql-client"") {
 							databaseId,
@@ -25,9 +25,9 @@ public async static Task Main(string[] args) {
 						    url
 						}
 					}"
-			};
-			var graphQLHttpResponse = await graphqlClient.SendHttpQueryAsync<Schema>(graphQLHttpRequest);
-			Console.WriteLine(JsonSerializer.Serialize(graphQLHttpResponse, new JsonSerializerOptions { WriteIndented = true }));
+			);
+			var graphQLResponse = await graphqlClient.SendQueryAsync<Schema>(graphQLRequest);
+			Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
 		}
 
 		private class Schema {
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 8f471d15..98c6e039 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -6,6 +6,7 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client.Http.Websocket;
 
 namespace GraphQL.Client.Http {
 
@@ -14,7 +15,8 @@ public class GraphQLHttpClient : IGraphQLClient {
 		private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 		private readonly HttpClient httpClient;
-		
+		private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
+
 		/// <summary>
 		/// The Options	to be used
 		/// </summary>
@@ -49,85 +51,48 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 		
-		public async Task<GraphQLHttpResponse<TResponse>> SendHttpQueryAsync<TVariable, TResponse>(GraphQLHttpRequest<TVariable> request, CancellationToken cancellationToken = default) {
-			using var httpRequestMessage = this.GenerateHttpRequestMessage(request);
-			using var httpResponseMessage = await this.httpClient.SendAsync(httpRequestMessage, cancellationToken);
-			if (!httpResponseMessage.IsSuccessStatusCode) {
-				throw new GraphQLHttpException(httpResponseMessage);
-			}
-
-			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
-			return await JsonSerializer.DeserializeAsync<GraphQLHttpResponse<TResponse>>(bodyStream, this.Options.JsonSerializerOptions, cancellationToken);
-		}
-
-		public async Task<GraphQLHttpResponse<TResponse>> SendHttpQueryAsync<TResponse>(GraphQLHttpRequest request, CancellationToken cancellationToken = default) =>
-			await this.SendHttpQueryAsync<dynamic, TResponse>(request, cancellationToken);
-
-		public async Task<GraphQLHttpResponse<TResponse>> SendHttpMutationAsync<TVariable, TResponse>(GraphQLHttpRequest<TVariable> request, CancellationToken cancellationToken = default) {
-			await Task.CompletedTask;
-			throw new NotImplementedException();
-		}
-
-		public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TVariable, TResponse>(GraphQLRequest<TVariable> request, CancellationToken cancellationToken = default) {
-			await Task.CompletedTask;
-			throw new NotImplementedException();
+		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
+				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
-		public async Task<GraphQLResponse<TResponse>> SendMutationAsync<TVariable, TResponse>(GraphQLRequest<TVariable> request, CancellationToken cancellationToken = default) {
-			await Task.CompletedTask;
-			throw new NotImplementedException();
-		}
-
-		private HttpRequestMessage GenerateHttpRequestMessage<T>(GraphQLRequest<T> request) {
-			return new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
-				Content = new StringContent(JsonSerializer.Serialize(request, this.Options.JsonSerializerOptions), Encoding.UTF8, "application/json")
-			};
+		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			return Options.UseWebSocketForQueriesAndMutations
+				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
+				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
-		public async Task<GraphQLResponse<R>> SendQueryAsync<R>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			await Task.CompletedTask;
+		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			throw new NotImplementedException();
 		}
 
-		public async Task<GraphQLResponse<R>> SendMutationAsync<R>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			await Task.CompletedTask;
-			throw new NotImplementedException();
-		}
-		public async Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			await Task.CompletedTask;
-			throw new NotImplementedException();
-		}
-
-		public async Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			await Task.CompletedTask;
+		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			throw new NotImplementedException();
 		}
 
-		private Uri GetWebSocketUri() {
-			var webSocketSchema = this.Options.EndPoint.Scheme == "https" ? "wss" : "ws";
-			return new Uri($"{webSocketSchema}://{this.Options.EndPoint.Host}:{this.Options.EndPoint.Port}{this.Options.EndPoint.AbsolutePath}");
-		}
-
 		/// <inheritdoc />
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request) {
+		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) {
 			if (disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			if (subscriptionStreams.ContainsKey(request))
-				return subscriptionStreams[request];
+			var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: cancellationTokenSource.Token);
+			if (subscriptionStreams.ContainsKey(key))
+				return (IObservable<GraphQLResponse<TResponse>>) subscriptionStreams[key];
 
-			subscriptionStreams.TryAdd(request, observable);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, Options, cancellationToken: cancellationTokenSource.Token);
+
+			subscriptionStreams.TryAdd(key, observable);
 			return observable;
 		}
 
 		/// <inheritdoc />
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) {
+		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) {
 			if (disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			return CreateSubscriptionStream(request, e => {
+			return CreateSubscriptionStream<TResponse>(request, e => {
 				if (e is WebSocketException webSocketException)
 					webSocketExceptionHandler(webSocketException);
 				else
@@ -136,19 +101,45 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		}
 
 		/// <inheritdoc />
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler) {
+		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler) {
 			if (disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			if (subscriptionStreams.ContainsKey(request))
-				return subscriptionStreams[request];
+			var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
+
+			if (subscriptionStreams.ContainsKey(key))
+				return (IObservable<GraphQLResponse<TResponse>>) subscriptionStreams[key];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, cancellationTokenSource.Token);
-			subscriptionStreams.TryAdd(request, observable);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, Options, exceptionHandler, cancellationTokenSource.Token);
+			subscriptionStreams.TryAdd(key, observable);
 			return observable;
 		}
 
-		private readonly ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
+		#region Private Methods
+
+		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			using var httpRequestMessage = this.GenerateHttpRequestMessage(request.SerializeToJson(Options));
+			using var httpResponseMessage = await this.httpClient.SendAsync(httpRequestMessage, cancellationToken);
+			if (!httpResponseMessage.IsSuccessStatusCode) {
+				throw new GraphQLHttpException(httpResponseMessage);
+			}
+
+			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
+			return await bodyStream.DeserializeFromJsonAsync<GraphQLHttpResponse<TResponse>>(Options, cancellationToken);
+		}
+		
+		private HttpRequestMessage GenerateHttpRequestMessage(string requestString) {
+			return new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
+				Content = new StringContent(requestString, Encoding.UTF8, "application/json")
+			};
+		}
+
+		private Uri GetWebSocketUri() {
+			var webSocketSchema = this.Options.EndPoint.Scheme == "https" ? "wss" : "ws";
+			return new Uri($"{webSocketSchema}://{this.Options.EndPoint.Host}:{this.Options.EndPoint.Port}{this.Options.EndPoint.AbsolutePath}");
+		}
+
+		#endregion
 
 
 		#region IDisposable
diff --git a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
new file mode 100644
index 00000000..90d4d6b3
--- /dev/null
+++ b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
@@ -0,0 +1,25 @@
+using System.IO;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GraphQL.Client.Http {
+	public static class GraphQLSerializationExtensions {
+
+		public static string SerializeToJson(this GraphQLRequest request,
+			GraphQLHttpClientOptions options) {
+			return JsonSerializer.Serialize(request, options.JsonSerializerOptions);
+		}
+		
+		public static TGraphQLResponse DeserializeFromJson<TGraphQLResponse>(this string jsonString,
+			GraphQLHttpClientOptions options) {
+			return JsonSerializer.Deserialize<TGraphQLResponse>(jsonString, options.JsonSerializerOptions);
+		}
+		
+		public static ValueTask<TGraphQLResponse> DeserializeFromJsonAsync<TGraphQLResponse>(this Stream stream,
+			GraphQLHttpClientOptions options, CancellationToken cancellationToken = default) {
+			return JsonSerializer.DeserializeAsync<TGraphQLResponse>(stream, options.JsonSerializerOptions, cancellationToken);
+		}
+
+	}
+}
diff --git a/src/GraphQL.Client.Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
similarity index 85%
rename from src/GraphQL.Client.Http/GraphQLHttpWebSocket.cs
rename to src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
index ca0967ed..566234b3 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
@@ -11,7 +11,7 @@
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http.Websocket
 {
 	internal class GraphQLHttpWebSocket: IDisposable
 	{
@@ -20,7 +20,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
-		private Subject<GraphQLWebSocketResponse> _responseSubject;
+		private Subject<WebsocketResponseWrapper> _responseSubject;
 		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private Subject<Exception> _exceptionSubject = new Subject<Exception>();
 		private IDisposable _requestSubscription;
@@ -42,8 +42,8 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 
 		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
 
-		public IObservable<GraphQLWebSocketResponse> ResponseStream => _responseStream;
-		public IObservable<GraphQLWebSocketResponse> _responseStream;
+		public IObservable<WebsocketResponseWrapper> ResponseStream => _responseStream;
+		public IObservable<WebsocketResponseWrapper> _responseStream;
 		//private IDisposable _responseStreamConnection;
 
 		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
@@ -63,9 +63,9 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 				}
 
 				await InitializeWebSocket().ConfigureAwait(false);
-				var webSocketRequestString = JsonConvert.SerializeObject(request, _options.JsonSerializerSettings);
+				var requestBytes = System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(request, _options.JsonSerializerOptions);
 				await this.clientWebSocket.SendAsync(
-					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
+					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
 					true,
 					_cancellationTokenSource.Token).ConfigureAwait(false);
@@ -135,19 +135,19 @@ public Task InitializeWebSocket()
 			}
 		}
 		
-		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
+		private IObservable<WebsocketResponseWrapper> _createResponseStream()
 		{
-			return Observable.Create<GraphQLWebSocketResponse>(_createResultStream)
+			return Observable.Create<WebsocketResponseWrapper>(_createResultStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
-				.Catch<GraphQLWebSocketResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLWebSocketResponse>());
+				.Catch<WebsocketResponseWrapper, OperationCanceledException>(exception =>
+					Observable.Empty<WebsocketResponseWrapper>());
 		}
 
-		private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketResponse> observer, CancellationToken token)
+		private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseWrapper> observer, CancellationToken token)
 		{
 			if (_responseSubject == null || _responseSubject.IsDisposed)
 			{
-				_responseSubject = new Subject<GraphQLWebSocketResponse>();
+				_responseSubject = new Subject<WebsocketResponseWrapper>();
 				var observable = await _getReceiveResultStream().ConfigureAwait(false);
 				observable.Subscribe(_responseSubject);
 
@@ -173,7 +173,7 @@ private async Task<IDisposable> _createResultStream(IObserver<GraphQLWebSocketRe
 			);
 		}
 
-		private async Task<IObservable<GraphQLWebSocketResponse>> _getReceiveResultStream()
+		private async Task<IObservable<WebsocketResponseWrapper>> _getReceiveResultStream()
 		{
 			await InitializeWebSocket().ConfigureAwait(false);
 			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
@@ -198,13 +198,13 @@ private async Task _connectAsync(CancellationToken token)
 		}
 
 
-		private Task<GraphQLWebSocketResponse> _receiveAsyncTask = null;
+		private Task<WebsocketResponseWrapper> _receiveAsyncTask = null;
 		private object _receiveTaskLocker = new object();
 		/// <summary>
 		/// wrapper method to pick up the existing request task if already running
 		/// </summary>
 		/// <returns></returns>
-		private Task<GraphQLWebSocketResponse> _getReceiveTask()
+		private Task<WebsocketResponseWrapper> _getReceiveTask()
 		{
 			lock (_receiveTaskLocker)
 			{
@@ -217,15 +217,15 @@ private Task<GraphQLWebSocketResponse> _getReceiveTask()
 			return _receiveAsyncTask;
 		}
 
-		private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
+		private async Task<WebsocketResponseWrapper> _receiveResultAsync()
 		{
 			try
 			{
 				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
-				WebSocketReceiveResult webSocketReceiveResult = null;
 
 				using (var ms = new MemoryStream())
 				{
+					WebSocketReceiveResult webSocketReceiveResult = null;
 					do
 					{
 						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
@@ -237,14 +237,14 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 					_cancellationTokenSource.Token.ThrowIfCancellationRequested();
 					ms.Seek(0, SeekOrigin.Begin);
 
-					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
-					{
-						using (var reader = new StreamReader(ms, Encoding.UTF8))
-						{
-							var stringResult = await reader.ReadToEndAsync();
-							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
-							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult, _options.JsonSerializerSettings);
-						}
+					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
+						var bytes = ms.ToArray();
+						var response =
+							System.Text.Json.JsonSerializer.Deserialize<WebsocketResponseWrapper>(bytes,
+								_options.JsonSerializerOptions);
+						response.MessageBytes = bytes;
+
+						return response;
 					}
 					else
 					{
diff --git a/src/GraphQL.Client.Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
similarity index 72%
rename from src/GraphQL.Client.Http/GraphQLHttpSubscriptionHelpers.cs
rename to src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index e10400cb..7a3af1f0 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -4,15 +4,16 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
 
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http.Websocket
 {
-	public static class GraphQLHttpSubscriptionHelpers
+	public static class GraphQLHttpWebsocketHelpers
 	{
-		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
+		internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
 			GraphQLHttpClientOptions options,
@@ -20,7 +21,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			CancellationToken cancellationToken = default)
 		{
 			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse>(async observer =>
+				Observable.Create<GraphQLResponse<TResponse>>(async observer =>
 				{
 					var startRequest = new GraphQLWebSocketRequest
 					{
@@ -28,18 +29,17 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GraphQLWebSocketMessageType.GQL_START,
 						Payload = request
 					};
-					var closeRequest = new GraphQLWebSocketRequest
-					{
+					var closeRequest = new GraphQLWebSocketRequest {
 						Id = startRequest.Id,
 						Type = GraphQLWebSocketMessageType.GQL_STOP
 					};
 
-					var observable = Observable.Create<GraphQLResponse>(o =>
-						graphQlHttpWebSocket.ResponseStream.Subscribe(response =>
+					var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
+						graphQlHttpWebSocket.ResponseStream
+							// ignore null values and messages for other requests
+							.Where(response => response != null && response.Id == startRequest.Id)
+							.Subscribe(response =>
 							{
-								// ignore null values and messages for other requests
-								if (response == null || response.Id != startRequest.Id) return;
-
 								// terminate the sequence when a 'complete' message is received
 								if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
 								{
@@ -50,7 +50,10 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 
 								// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
 								Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-								o.OnNext(((JObject)response.Payload)?.ToObject<GraphQLResponse>());
+								var typedResponse =
+									JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
+										options.JsonSerializerOptions);
+								o.OnNext(typedResponse.Payload);
 
 								// in case of a GraphQL error, terminate the sequence after the response has been posted
 								if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
@@ -71,7 +74,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 					catch (Exception e)
 					{
 						// subscribe observer to failed observable
-						return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+						return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
 					}
 
 					var disposable = new CompositeDisposable(
@@ -106,12 +109,12 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 					return disposable;
 				}))
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-				.Catch<GraphQLResponse, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLResponse>())
+				.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLResponse<TResponse>>())
 				// wrap results
-				.Select(response => new Tuple<GraphQLResponse, Exception>(response, null))
+				.Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
 				// do exception handling
-				.Catch<Tuple<GraphQLResponse, Exception>, Exception>(e =>
+				.Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e =>
 				{
 					try
 					{
@@ -128,13 +131,13 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						return cancellationToken.IsCancellationRequested
-							? Observable.Empty<Tuple<GraphQLResponse, Exception>>()
-							: Observable.Throw<Tuple<GraphQLResponse, Exception>>(e);
+							? Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>()
+							: Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
 					}
 					catch (Exception exception)
 					{
 						// wrap all other exceptions to be propagated behind retry
-						return Observable.Return(new Tuple<GraphQLResponse, Exception>(null, exception));
+						return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
 					}
 				})
 				// attempt to recreate the websocket for rethrown exceptions
@@ -144,22 +147,23 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				{
 					// if the result contains an exception, throw it on the observable
 					if (t.Item2 != null)
-						return Observable.Throw<GraphQLResponse>(t.Item2);
+						return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
 
 					return t.Item1 == null
-						? Observable.Empty<GraphQLResponse>()
+						? Observable.Empty<GraphQLResponse<TResponse>>()
 						: Observable.Return(t.Item1);
 				})
 				// transform to hot observable and auto-connect
 				.Publish().RefCount();
 		}
 
-		internal static Task<GraphQLResponse> Request(
+		internal static Task<GraphQLResponse<TResponse>> Request<TResponse>(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
+			GraphQLHttpClientOptions options,
 			CancellationToken cancellationToken = default)
 		{
-			return Observable.Create<GraphQLResponse>(async observer =>
+			return Observable.Create<GraphQLResponse<TResponse>>(async observer =>
 			{
 				var websocketRequest = new GraphQLWebSocketRequest
 				{
@@ -173,7 +177,10 @@ internal static Task<GraphQLResponse> Request(
 					.Select(response =>
 					{
 						Debug.WriteLine($"received response for request {websocketRequest.Id}");
-						return ((JObject) response?.Payload)?.ToObject<GraphQLResponse>();
+						var typedResponse =
+							JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
+								options.JsonSerializerOptions);
+						return typedResponse.Payload;
 					});
 
 				try
@@ -184,7 +191,7 @@ internal static Task<GraphQLResponse> Request(
 				catch (Exception e)
 				{
 					// subscribe observer to failed observable
-					return Observable.Throw<GraphQLResponse>(e).Subscribe(observer);
+					return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
 				}
 
 				var disposable = new CompositeDisposable(
@@ -206,8 +213,8 @@ internal static Task<GraphQLResponse> Request(
 				return disposable;
 			})
 			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-			.Catch<GraphQLResponse, OperationCanceledException>(exception =>
-				Observable.Empty<GraphQLResponse>())
+			.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+				Observable.Empty<GraphQLResponse<TResponse>>())
 			.FirstOrDefaultAsync()
 			.ToTask(cancellationToken);
 		}
diff --git a/src/GraphQL.Client.Http/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
similarity index 99%
rename from src/GraphQL.Client.Http/GraphQLWebSocketMessageType.cs
rename to src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
index 3258236e..df55a3b2 100644
--- a/src/GraphQL.Client.Http/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http.Websocket
 {
 	public static class GraphQLWebSocketMessageType
 	{
diff --git a/src/GraphQL.Client.Http/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
similarity index 93%
rename from src/GraphQL.Client.Http/GraphQLWebSocketRequest.cs
rename to src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
index 05a7993b..8bcdb7b6 100644
--- a/src/GraphQL.Client.Http/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http.Websocket {
 
 	/// <summary>
 	/// A Subscription Request
@@ -21,7 +21,7 @@ public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 		public string Type { get; set; }
 
 		/// <summary>
-		/// The Payload of the Request
+		/// The payload of the websocket request
 		/// </summary>
 		public GraphQLRequest Payload { get; set; }
 
@@ -77,7 +77,7 @@ public override int GetHashCode() {
 			var hashCode = 9958074;
 			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
 			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
-			hashCode = hashCode * -1521134295 + EqualityComparer<GraphQLRequest>.Default.GetHashCode(this.Payload);
+			hashCode = hashCode * -1521134295 + EqualityComparer<object>.Default.GetHashCode(this.Payload);
 			return hashCode;
 		}
 
diff --git a/src/GraphQL.Client.Http/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
similarity index 55%
rename from src/GraphQL.Client.Http/GraphQLWebSocketResponse.cs
rename to src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
index 7aeec637..9dbd9abf 100644
--- a/src/GraphQL.Client.Http/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http.Websocket {
 
 	/// <summary>
 	/// A Subscription Response
@@ -19,11 +19,6 @@ public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse> {
 		/// </summary>
 		public string Type { get; set; }
 
-		/// <summary>
-		/// The Payload of the Response
-		/// </summary>
-		public dynamic Payload { get; set; }
-
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
 
@@ -32,18 +27,19 @@ public bool Equals(GraphQLWebSocketResponse other) {
 			if (other == null) {
 				return false;
 			}
+
 			if (ReferenceEquals(this, other)) {
 				return true;
 			}
+
 			if (!Equals(this.Id, other.Id)) {
 				return false;
 			}
+
 			if (!Equals(this.Type, other.Type)) {
 				return false;
 			}
-			if (!Equals(this.Payload, other.Payload)) {
-				return false;
-			}
+
 			return true;
 		}
 
@@ -52,16 +48,43 @@ public override int GetHashCode() {
 			var hashCode = 9958074;
 			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
 			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
-			hashCode = hashCode * -1521134295 + EqualityComparer<GraphQLResponse>.Default.GetHashCode(this.Payload);
 			return hashCode;
 		}
 
 		/// <inheritdoc />
-		public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
+		public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
+			EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
 
 		/// <inheritdoc />
-		public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) => !(response1 == response2);
+		public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
+			!(response1 == response2);
 
 	}
 
+	public class GraphQLWebSocketResponse<TResponse> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TResponse>> {
+		public GraphQLHttpResponse<TResponse> Payload { get; set; }
+
+		public bool Equals(GraphQLWebSocketResponse<TResponse>? other)
+		{
+			if (ReferenceEquals(null, other)) return false;
+			if (ReferenceEquals(this, other)) return true;
+			return base.Equals(other) && Payload.Equals(other.Payload);
+		}
+
+		public override bool Equals(object? obj)
+		{
+			if (ReferenceEquals(null, obj)) return false;
+			if (ReferenceEquals(this, obj)) return true;
+			if (obj.GetType() != this.GetType()) return false;
+			return Equals((GraphQLWebSocketResponse<TResponse>) obj);
+		}
+
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				return (base.GetHashCode() * 397) ^ Payload.GetHashCode();
+			}
+		}
+	}
 }
diff --git a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
new file mode 100644
index 00000000..3d360eea
--- /dev/null
+++ b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
@@ -0,0 +1,9 @@
+using System.Text.Json.Serialization;
+
+namespace GraphQL.Client.Http.Websocket {
+	public class WebsocketResponseWrapper : GraphQLWebSocketResponse {
+		
+		[JsonIgnore]
+		public byte[] MessageBytes { get; set; }
+	}
+}
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client/GraphQLClientExtensions.cs
new file mode 100644
index 00000000..5f269032
--- /dev/null
+++ b/src/GraphQL.Client/GraphQLClientExtensions.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GraphQL.Client {
+	public static class GraphQLClientExtensions {
+		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse, TVariables>(this IGraphQLClient client,
+			string query, TVariables variables,
+			string? operationName = null, CancellationToken cancellationToken = default) {
+			return client.SendQueryAsync<TResponse>(GraphQLRequest.New(query, variables, operationName), cancellationToken);
+		}
+
+		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
+			string query, string? operationName = null, CancellationToken cancellationToken = default) {
+			return client.SendQueryAsync<TResponse>(GraphQLRequest.New(query, operationName), cancellationToken);
+		}
+
+
+		public static Task<GraphQLResponse> SendQueryAsync(this IGraphQLClient client,
+			string query, string? operationName = null, CancellationToken cancellationToken = default) {
+			return client.SendQueryAsync(GraphQLRequest.New(query, operationName), cancellationToken);
+		}
+	}
+}
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 4b0c84f8..ea11fc32 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -7,9 +7,9 @@ namespace GraphQL.Client {
 
 	public interface IGraphQLClient : IDisposable {
 
-		Task<GraphQLResponse<R>> SendQueryAsync<R>(GraphQLRequest request, CancellationToken cancellationToken = default);
+		Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
-		Task<GraphQLResponse<R>> SendMutationAsync<R>(GraphQLRequest request, CancellationToken cancellationToken = default);
+		Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
 		Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
@@ -22,7 +22,7 @@ public interface IGraphQLClient : IDisposable {
 		/// </summary>
 		/// <param name="request">the GraphQL request for this subscription</param>
 		/// <returns>an observable stream for the specified subscription</returns>
-		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
+		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request);
 
 		/// <summary>
 		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
@@ -34,7 +34,7 @@ public interface IGraphQLClient : IDisposable {
 		/// <param name="request">the GraphQL request for this subscription</param>
 		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
 		/// <returns>an observable stream for the specified subscription</returns>
-		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
+		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
 
 		/// <summary>
 		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
@@ -46,7 +46,7 @@ public interface IGraphQLClient : IDisposable {
 		/// <param name="request">the GraphQL request for this subscription</param>
 		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
 		/// <returns>an observable stream for the specified subscription</returns>
-		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler);
+		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler);
 
 		/// <summary>
 		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index dc1fbb2a..117a208d 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -6,7 +6,24 @@ namespace GraphQL {
 	/// <summary>
 	/// A GraphQL request
 	/// </summary>
-	public class GraphQLRequest<TVariables> : IEquatable<GraphQLRequest<TVariables>?> {
+	public abstract class GraphQLRequest : IEquatable<GraphQLRequest> {
+
+		/// <summary>
+		/// static factory for typed <see cref="GraphQLRequest"/>s
+		/// </summary>
+		/// <typeparam name="TVariables"></typeparam>
+		/// <param name="query"></param>
+		/// <param name="variables"></param>
+		/// <param name="operationName"></param>
+		/// <returns></returns>
+		public static GraphQLRequest<TVariables> New<TVariables>(string query, TVariables variables,
+			string? operationName = null) {
+			return new GraphQLRequest<TVariables>(query, variables, operationName);
+		}
+
+		public static GraphQLRequest<object?> New(string query, string? operationName = null) {
+			return new GraphQLRequest<object?>(query, null, operationName);
+		}
 
 		/// <summary>
 		/// The Query
@@ -18,30 +35,37 @@ public class GraphQLRequest<TVariables> : IEquatable<GraphQLRequest<TVariables>?
 		/// </summary>
 		public string? OperationName { get; set; }
 
-		/// <summary>
-		/// Represents the request variables
-		/// </summary>
-		public TVariables Variables { get; set; }
+
+		protected GraphQLRequest()
+		{
+		}
+
+		protected GraphQLRequest(string query, string? operationName = null) {
+			Query = query;
+			OperationName = operationName;
+		}
 
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
 		/// </summary>
 		/// <param name="obj">The object to compare with this instance</param>
 		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public override bool Equals(object? obj) => this.Equals(obj as GraphQLRequest<TVariables>);
+		public override bool Equals(object? obj) {
+			if (ReferenceEquals(null, obj)) return false;
+			if (ReferenceEquals(this, obj)) return true;
+			if (obj.GetType() != this.GetType()) return false;
+			return Equals((GraphQLRequest) obj);
+		}
 
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
 		/// </summary>
 		/// <param name="other">The object to compare with this instance</param>
 		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public bool Equals(GraphQLRequest<TVariables>? other) {
-			if (other == null) { return false; }
-			if (ReferenceEquals(this, other)) { return true; }
-			if (!EqualityComparer<string>.Default.Equals(this.Query, other.Query)) { return false; }
-			if (!EqualityComparer<string?>.Default.Equals(this.OperationName, other.OperationName)) { return false; }
-			if (!EqualityComparer<dynamic?>.Default.Equals(this.Variables, other.Variables)) { return false; }
-			return true;
+		public bool Equals(GraphQLRequest? other) {
+			if (ReferenceEquals(null, other)) return false;
+			if (ReferenceEquals(this, other)) return true;
+			return Query == other.Query && OperationName == other.OperationName;
 		}
 
 		/// <summary>
@@ -49,7 +73,7 @@ public bool Equals(GraphQLRequest<TVariables>? other) {
 		/// </summary>
 		public override int GetHashCode() {
 			unchecked {
-				return base.GetHashCode() * 397 ^ EqualityComparer<dynamic?>.Default.GetHashCode(this.Variables);
+				return (Query.GetHashCode() * 397) ^ (OperationName != null ? OperationName.GetHashCode() : 0);
 			}
 		}
 
@@ -59,7 +83,7 @@ public override int GetHashCode() {
 		/// <param name="left">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the left of the equality operator</param>
 		/// <param name="right">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the right of the equality operator</param>
 		/// <returns>true if left and right are equal; otherwise, false</returns>
-		public static bool operator ==(GraphQLRequest<TVariables>? left, GraphQLRequest<TVariables>? right) => EqualityComparer<GraphQLRequest<TVariables>?>.Default.Equals(left, right);
+		public static bool operator ==(GraphQLRequest? left, GraphQLRequest? right) => EqualityComparer<GraphQLRequest?>.Default.Equals(left, right);
 
 		/// <summary>
 		/// Tests whether two specified <see cref="GraphQLRequest{TVariables}"/> instances are not equal
@@ -67,20 +91,51 @@ public override int GetHashCode() {
 		/// <param name="left">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the left of the not equal operator</param>
 		/// <param name="right">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the right of the not equal operator</param>
 		/// <returns>true if left and right are unequal; otherwise, false</returns>
-		public static bool operator !=(GraphQLRequest<TVariables>? left, GraphQLRequest<TVariables>? right) => !(left == right);
+		public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
+
 
+		
 	}
 
 	/// <summary>
-	/// dynamic variant of a GraphQLRequest
+	/// a GraphQL Request with variables
 	/// </summary>
-	public class GraphQLRequest : GraphQLRequest<dynamic?> {
+	public class GraphQLRequest<TVariables> : GraphQLRequest, IEquatable<GraphQLRequest<TVariables>?> {
+
+		/// <summary>
+		/// Represents the request variables
+		/// </summary>
+		public TVariables Variables { get; set; }
+
 		public GraphQLRequest()
 		{
 		}
 
-		public GraphQLRequest(string query) {
-			Query = query;
+		public GraphQLRequest(string query, TVariables variables, string? operationName = null) : base(query, operationName) {
+			Variables = variables;
+		}
+
+		public bool Equals(GraphQLRequest<TVariables>? other)
+		{
+			if (ReferenceEquals(null, other)) return false;
+			if (ReferenceEquals(this, other)) return true;
+			return base.Equals(other) && EqualityComparer<TVariables>.Default.Equals(Variables, other.Variables);
+		}
+
+		public override bool Equals(object? obj)
+		{
+			if (ReferenceEquals(null, obj)) return false;
+			if (ReferenceEquals(this, obj)) return true;
+			if (obj.GetType() != this.GetType()) return false;
+			return Equals((GraphQLRequest<TVariables>) obj);
+		}
+
+		public override int GetHashCode()
+		{
+			unchecked
+			{
+				return (base.GetHashCode() * 397) ^ EqualityComparer<TVariables>.Default.GetHashCode(Variables);
+			}
 		}
 	}
 
diff --git a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
new file mode 100644
index 00000000..c50d7a51
--- /dev/null
+++ b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
@@ -0,0 +1,25 @@
+using System.Globalization;
+using Xunit;
+using System.Text.Json;
+
+namespace GraphQL.Client.Http.Tests {
+	public class JsonSerializationTests {
+
+		[Fact]
+		public void WebSocketResponseDeserialization() {
+			var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff"};
+			var json = JsonSerializer.Serialize(testObject);
+			var deserialized = JsonSerializer.Deserialize<TestObject>(json);
+
+		}
+
+		public class TestObject {
+			public string Id { get; set; }
+
+		}
+
+		public class ExtendedTestObject : TestObject {
+			public string OtherData { get; set; }
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
index c63a79bc..e129b57e 100644
--- a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
@@ -6,7 +6,7 @@ public class GraphQLRequestTest {
 
 		[Fact]
 		public void ConstructorFact() {
-			var graphQLRequest = new GraphQLRequest { Query = "{hero{name}}" };
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
 			Assert.NotNull(graphQLRequest.Query);
 			Assert.Null(graphQLRequest.OperationName);
 			Assert.Null(graphQLRequest.Variables);
@@ -14,13 +14,7 @@ public void ConstructorFact() {
 
 		[Fact]
 		public void ConstructorExtendedFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new {varName = "varValue"}, "operationName");
 			Assert.NotNull(graphQLRequest.Query);
 			Assert.NotNull(graphQLRequest.OperationName);
 			Assert.NotNull(graphQLRequest.Variables);
@@ -28,199 +22,120 @@ public void ConstructorExtendedFact() {
 
 		[Fact]
 		public void Equality1Fact() {
-			var graphQLRequest = new GraphQLRequest { Query = "{hero{name}}" };
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
 			Assert.Equal(graphQLRequest, graphQLRequest);
 		}
 
 		[Fact]
 		public void Equality2Fact() {
-			var graphQLRequest1 = new GraphQLRequest { Query = "{hero{name}}" };
-			var graphQLRequest2 = new GraphQLRequest { Query = "{hero{name}}" };
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}");
 			Assert.Equal(graphQLRequest1, graphQLRequest2);
 		}
 
 		[Fact]
 		public void Equality3Fact() {
-			var graphQLRequest1 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
-			var graphQLRequest2 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.Equal(graphQLRequest1, graphQLRequest2);
 		}
 
 		[Fact]
 		public void EqualityOperatorFact() {
-			var graphQLRequest1 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
-			var graphQLRequest2 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.True(graphQLRequest1 == graphQLRequest2);
 		}
 
 		[Fact]
 		public void InEquality1Fact() {
-			var graphQLRequest1 = new GraphQLRequest { Query = "{hero{name1}}" };
-			var graphQLRequest2 = new GraphQLRequest { Query = "{hero{name2}}" };
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name1}}");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name2}}");
 			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
 		}
 
 		[Fact]
 		public void InEquality2Fact() {
-			var graphQLRequest1 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue1"
-				}
-			};
-			var graphQLRequest2 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue2"
-				}
-			};
+			GraphQLRequest graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
+			GraphQLRequest graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue2" }, "operationName");
 			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
 		}
 
 		[Fact]
 		public void InEqualityOperatorFact() {
-			var graphQLRequest1 = new GraphQLRequest { Query = "{hero{name1}}" };
-			var graphQLRequest2 = new GraphQLRequest { Query = "{hero{name2}}" };
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name1}}");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name2}}");
 			Assert.True(graphQLRequest1 != graphQLRequest2);
 		}
 
 		[Fact]
 		public void GetHashCode1Fact() {
-			var graphQLRequest1 = new GraphQLRequest { Query = "{hero{name}}" };
-			var graphQLRequest2 = new GraphQLRequest { Query = "{hero{name}}" };
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}");
 			Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
 		}
 
 		[Fact]
 		public void GetHashCode2Fact() {
-			var graphQLRequest1 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
-			var graphQLRequest2 = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
 		}
 
+		[Fact]
+		public void GetHashCode3Fact() {
+			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
+			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue2" }, "operationName");
+			Assert.True(graphQLRequest1.GetHashCode() != graphQLRequest2.GetHashCode());
+		}
+
 		[Fact]
 		public void PropertyQueryGetFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
 			Assert.Equal("{hero{name}}", graphQLRequest.Query);
 		}
 
 		[Fact]
 		public void PropertyQuerySetFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = "{hero{name1}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
 			graphQLRequest.Query = "{hero{name2}}";
 			Assert.Equal("{hero{name2}}", graphQLRequest.Query);
 		}
 
 		[Fact]
 		public void PropertyOperationNameGetFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.Equal("operationName", graphQLRequest.OperationName);
 		}
 
 		[Fact]
 		public void PropertyOperationNameNullGetFact() {
-			var graphQLRequest = new GraphQLRequest { Query = "{hero{name}}" };
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
 			Assert.Null(graphQLRequest.OperationName);
 		}
 
 		[Fact]
 		public void PropertyOperationNameSetFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName1",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName1");
 			graphQLRequest.OperationName = "operationName2";
 			Assert.Equal("operationName2", graphQLRequest.OperationName);
 		}
 
 		[Fact]
 		public void PropertyVariableGetFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue"
-				}
-			};
-			Assert.Equal(new {
-				varName = "varValue"
-			}, graphQLRequest.Variables);
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			Assert.Equal(new { varName = "varValue" }, graphQLRequest.Variables);
 		}
 
 		[Fact]
 		public void PropertyVariableNullGetFact() {
-			var graphQLRequest = new GraphQLRequest { Query = "{hero{name}}" };
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
 			Assert.Null(graphQLRequest.Variables);
 		}
 
 		[Fact]
 		public void PropertyVariableSetFact() {
-			var graphQLRequest = new GraphQLRequest {
-				Query = "{hero{name}}",
-				OperationName = "operationName",
-				Variables = new {
-					varName = "varValue1"
-				}
-			};
+			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName1");
 			graphQLRequest.Variables = new {
 				varName = "varValue2"
 			};
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 25e38b7e..becaa7d4 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -22,7 +22,6 @@
   <ItemGroup>
     <ProjectReference Include="..\..\src\GraphQL.Client.Http\GraphQL.Client.Http.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
-    <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index bddb184d..b4e3b37a 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -9,41 +9,34 @@ public static class GraphQLClientExtensions
 	{
 		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
 		{
-			var graphQLRequest = new GraphQLRequest(@"
-				mutation($input: MessageInputType){
+			var graphQLRequest = GraphQLRequest.New(
+				@"mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
-				}")
-			{
-				Variables = new
-				{
-					input = new
-					{
+				}",
+				new {
+					input = new {
 						fromId = "2",
 						content = message,
 						sentAt = DateTime.Now
 					}
-				}
-			};
+				});
 			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
 		}
 
 		public static async Task<GraphQLResponse> JoinDeveloperUser(this GraphQLHttpClient client)
 		{
-			var graphQLRequest = new GraphQLRequest(@"
+			var graphQLRequest = GraphQLRequest.New(@"
 				mutation($userId: String){
 				  join(userId: $userId){
 				    displayName
 				    id
 				  }
-				}")
-			{
-				Variables = new
-				{
+				}",
+				new {
 					userId = "1"
-				}
-			};
+				});
 			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
 		}
 	}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index a3ea92e7..26b454ce 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -87,7 +87,7 @@ public async void CanHandleRequestErrorViaWebsocket()
 			{
 				var client = GetGraphQLClient(port, true);
 				const string message = "some random testing message";
-				var response = await client.SendQueryAsync(new GraphQLRequest("this query is formatted quite badly")).ConfigureAwait(false);
+				var response = await client.SendQueryAsync("this query is formatted quite badly").ConfigureAwait(false);
 
 				Assert.Single(response.Errors);
 			}
@@ -100,7 +100,7 @@ public async void CanHandleRequestErrorViaWebsocket()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
+		private readonly GraphQLRequest SubscriptionRequest = GraphQLRequest.New(SubscriptionQuery);
 
 		[Fact]
 		public async void CanCreateObservableSubscription()
@@ -110,7 +110,7 @@ public async void CanCreateObservableSubscription()
 			{
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -121,7 +121,7 @@ public async void CanCreateObservableSubscription()
 
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				const string message2 = "lorem ipsum dolor si amet";
@@ -129,7 +129,7 @@ public async void CanCreateObservableSubscription()
 				Assert.Equal(message2, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				// disposing the client should throw a TaskCanceledException on the subscription
@@ -138,6 +138,14 @@ public async void CanCreateObservableSubscription()
 			}
 		}
 
+		public class MessageAddedSubscriptionResult {
+			public MessageAddedContent MessageAdded { get; set; }
+
+			public class MessageAddedContent {
+				public string Content { get; set; }
+			}
+		}
+
 		[Fact]
 		public async void CanReconnectWithSameObservable()
 		{
@@ -147,7 +155,7 @@ public async void CanReconnectWithSameObservable()
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest);
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -157,7 +165,7 @@ public async void CanReconnectWithSameObservable()
 				Assert.Equal(message1, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message1, (string) gqlResponse.Data.MessageAdded.Content);
 				});
 
 				const string message2 = "How are you?";
@@ -165,7 +173,7 @@ public async void CanReconnectWithSameObservable()
 				Assert.Equal(message2, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message2, (string) gqlResponse.Data.MessageAdded.Content);
 				});
 
 				Debug.WriteLine("disposing subscription...");
@@ -174,14 +182,14 @@ public async void CanReconnectWithSameObservable()
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
 				tester.ShouldHaveReceivedUpdate(
-					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.messageAdded.content.Value); },
+					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.MessageAdded.Content); },
 					TimeSpan.FromSeconds(10));
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, (string) response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string) gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message3, (string) gqlResponse.Data.MessageAdded.Content);
 				});
 
 				// disposing the client should complete the subscription
@@ -198,7 +206,17 @@ public async void CanReconnectWithSameObservable()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
+		public class UserJoinedSubscriptionResult {
+			public UserJoinedContent UserJoined { get; set; }
+
+			public class UserJoinedContent {
+				public string DisplayName { get; set; }
+				public string Id { get; set; }
+			}
+
+		}
+
+		private readonly GraphQLRequest SubscriptionRequest2 = GraphQLRequest.New(SubscriptionQuery2);
 
 		[Fact]
 		public async void CanConnectTwoSubscriptionsSimultaneously()
@@ -211,8 +229,8 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable1 = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
-				IObservable<GraphQLResponse> observable2 = client.CreateSubscriptionStream(SubscriptionRequest2, callbackTester2.Callback);
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable1 = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable1.SubscribeTester();
@@ -223,7 +241,7 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 				Assert.Equal(message1, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message1, (string)gqlResponse.Data.MessageAdded.Content);
 				});
 
 				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
@@ -233,8 +251,8 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal("1", (string)gqlResponse.Data.userJoined.id.Value);
-					Assert.Equal("developer", (string)gqlResponse.Data.userJoined.displayName.Value);
+					Assert.Equal("1", (string)gqlResponse.Data.UserJoined.Id);
+					Assert.Equal("developer", (string)gqlResponse.Data.UserJoined.DisplayName);
 				});
 				
 				Debug.WriteLine("disposing subscription...");
@@ -245,7 +263,7 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 				Assert.Equal(message3, (string)response.Data.addMessage.content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string)gqlResponse.Data.messageAdded.content.Value);
+					Assert.Equal(message3, (string)gqlResponse.Data.MessageAdded.Content);
 				});
 
 				// disposing the client should complete the subscription
@@ -263,7 +281,7 @@ public async void CanHandleConnectionTimeout()
 
 			var client = GetGraphQLClient(port);
 			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(SubscriptionRequest, callbackTester.Callback);
+			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
 
 			Debug.WriteLine("subscribing...");
 			var tester = observable.SubscribeTester();
@@ -274,7 +292,7 @@ public async void CanHandleConnectionTimeout()
 
 			tester.ShouldHaveReceivedUpdate(gqlResponse =>
 			{
-				Assert.Equal(message1, (string)gqlResponse.Data.messageAdded.content.Value);
+				Assert.Equal(message1, (string)gqlResponse.Data.MessageAdded.Content);
 			});
 
 			Debug.WriteLine("stopping web host...");
@@ -309,8 +327,8 @@ public async void CanHandleSubscriptionError()
 			{
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(
-					new GraphQLRequest(@"
+				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
+					GraphQLRequest.New(@"
 						subscription {
 						  failImmediately {
 						    content
@@ -336,10 +354,13 @@ public async void CanHandleQueryErrorInSubscription()
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
+
+				var test = GraphQLRequest.New("tset", new { test = "blaa"});
+
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(
-					new GraphQLRequest(@"
+				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
+					GraphQLRequest.New(@"
 						subscription {
 						  fieldDoesNotExist {
 						    content

From 8fc6a7017e6d8f7a37f07f5de370fc16926c8622 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 12:07:10 +0100
Subject: [PATCH 050/455] eliminate generic variant for GraphQLRequest

---
 .../GraphQL.Client.Http.Examples/Program.cs   |   4 +-
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  |  14 +--
 src/GraphQL.Client.Http/GraphQLHttpRequest.cs |   6 +-
 src/GraphQL.Client/GraphQLClientExtensions.cs |  18 +---
 src/GraphQL.Client/GraphQLResponse.cs         |   5 +-
 src/GraphQL.Client/IGraphQLClient.cs          |   8 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      | 100 +++++-------------
 .../GraphQLRequestTest.cs                     |  66 +++++++-----
 .../GraphQLResponseTest.cs                    |  30 +++---
 .../GraphQLClientExtensions.cs                |  43 --------
 .../GraphQLClientTestExtensions.cs            |  60 +++++++++++
 .../SubscriptionsTest.cs                      |  67 ++++++------
 12 files changed, 187 insertions(+), 234 deletions(-)
 delete mode 100644 tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
 create mode 100644 tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs

diff --git a/examples/GraphQL.Client.Http.Examples/Program.cs b/examples/GraphQL.Client.Http.Examples/Program.cs
index a8f42500..0cce0283 100644
--- a/examples/GraphQL.Client.Http.Examples/Program.cs
+++ b/examples/GraphQL.Client.Http.Examples/Program.cs
@@ -12,10 +12,10 @@ public class Program {
 			AllowSynchronousIO = true
 		};
 
-		public async static Task Main(string[] args) {
+		public static async Task Main(string[] args) {
 			using var httpClient = testServer.CreateClient();
 			using var graphqlClient = httpClient.AsGraphQLClient($"{testServer.BaseAddress}graphql");
-			var graphQLRequest = GraphQLRequest.New(
+			var graphQLRequest = new GraphQLRequest(
 				@"
 					{
 						repository(owner: ""graphql-dotnet"", name: ""graphql-client"") {
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 98c6e039..c78b386f 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -51,26 +51,20 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 		
-		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null,
+			CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
 				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
 				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
-		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null,
+			CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
 				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
 				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
-		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			throw new NotImplementedException();
-		}
-
-		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			throw new NotImplementedException();
-		}
-
 		/// <inheritdoc />
 		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) {
 			if (disposed)
diff --git a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
index 86c0b211..635d8da7 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
@@ -1,9 +1,5 @@
 namespace GraphQL.Client.Http {
 
-	public class GraphQLHttpRequest<T> : GraphQLRequest<T> {
+	public class GraphQLHttpRequest : GraphQLRequest {
 	}
-
-	public class GraphQLHttpRequest : GraphQLHttpRequest<dynamic?> {
-	}
-
 }
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client/GraphQLClientExtensions.cs
index 5f269032..5ea54bdf 100644
--- a/src/GraphQL.Client/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLClientExtensions.cs
@@ -1,26 +1,18 @@
 using System;
 using System.Collections.Generic;
+using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client {
 	public static class GraphQLClientExtensions {
-		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse, TVariables>(this IGraphQLClient client,
-			string query, TVariables variables,
-			string? operationName = null, CancellationToken cancellationToken = default) {
-			return client.SendQueryAsync<TResponse>(GraphQLRequest.New(query, variables, operationName), cancellationToken);
-		}
 
+		
 		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
-			string query, string? operationName = null, CancellationToken cancellationToken = default) {
-			return client.SendQueryAsync<TResponse>(GraphQLRequest.New(query, operationName), cancellationToken);
-		}
-
-
-		public static Task<GraphQLResponse> SendQueryAsync(this IGraphQLClient client,
-			string query, string? operationName = null, CancellationToken cancellationToken = default) {
-			return client.SendQueryAsync(GraphQLRequest.New(query, operationName), cancellationToken);
+			string query, object? variables = null,
+			string? operationName = null, CancellationToken cancellationToken = default) {
+			return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
 		}
 	}
 }
diff --git a/src/GraphQL.Client/GraphQLResponse.cs b/src/GraphQL.Client/GraphQLResponse.cs
index 1f203156..7834d2ab 100644
--- a/src/GraphQL.Client/GraphQLResponse.cs
+++ b/src/GraphQL.Client/GraphQLResponse.cs
@@ -54,9 +54,6 @@ public override int GetHashCode() {
 
 	}
 
-	/// <summary>
-	/// The dynamic version of <see cref="GraphQLResponse{T}"/>
-	/// </summary>
-	public class GraphQLResponse : GraphQLResponse<dynamic?> { }
+	
 
 }
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index ea11fc32..59483ac5 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -7,13 +7,9 @@ namespace GraphQL.Client {
 
 	public interface IGraphQLClient : IDisposable {
 
-		Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
+		Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default);
 
-		Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
-
-		Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
-
-		Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
+		Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 117a208d..dcd5d93e 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -6,25 +6,8 @@ namespace GraphQL {
 	/// <summary>
 	/// A GraphQL request
 	/// </summary>
-	public abstract class GraphQLRequest : IEquatable<GraphQLRequest> {
-
-		/// <summary>
-		/// static factory for typed <see cref="GraphQLRequest"/>s
-		/// </summary>
-		/// <typeparam name="TVariables"></typeparam>
-		/// <param name="query"></param>
-		/// <param name="variables"></param>
-		/// <param name="operationName"></param>
-		/// <returns></returns>
-		public static GraphQLRequest<TVariables> New<TVariables>(string query, TVariables variables,
-			string? operationName = null) {
-			return new GraphQLRequest<TVariables>(query, variables, operationName);
-		}
-
-		public static GraphQLRequest<object?> New(string query, string? operationName = null) {
-			return new GraphQLRequest<object?>(query, null, operationName);
-		}
-
+	public class GraphQLRequest : IEquatable<GraphQLRequest?> {
+		
 		/// <summary>
 		/// The Query
 		/// </summary>
@@ -35,13 +18,19 @@ public static GraphQLRequest<TVariables> New<TVariables>(string query, TVariable
 		/// </summary>
 		public string? OperationName { get; set; }
 
+		/// <summary>
+		/// Represents the request variables
+		/// </summary>
+		public virtual object? Variables { get; set; }
+
 
-		protected GraphQLRequest()
+		public GraphQLRequest()
 		{
 		}
 
-		protected GraphQLRequest(string query, string? operationName = null) {
+		public GraphQLRequest(string query, object? variables = null, string? operationName = null) {
 			Query = query;
+			Variables = variables;
 			OperationName = operationName;
 		}
 
@@ -54,7 +43,7 @@ public override bool Equals(object? obj) {
 			if (ReferenceEquals(null, obj)) return false;
 			if (ReferenceEquals(this, obj)) return true;
 			if (obj.GetType() != this.GetType()) return false;
-			return Equals((GraphQLRequest) obj);
+			return Equals((GraphQLRequest)obj);
 		}
 
 		/// <summary>
@@ -62,10 +51,12 @@ public override bool Equals(object? obj) {
 		/// </summary>
 		/// <param name="other">The object to compare with this instance</param>
 		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public bool Equals(GraphQLRequest? other) {
+		public virtual bool Equals(GraphQLRequest? other) {
 			if (ReferenceEquals(null, other)) return false;
 			if (ReferenceEquals(this, other)) return true;
-			return Query == other.Query && OperationName == other.OperationName;
+			return Query == other.Query
+			       && OperationName == other.OperationName
+			       && EqualityComparer<object>.Default.Equals(Variables, other.Variables);
 		}
 
 		/// <summary>
@@ -73,70 +64,29 @@ public bool Equals(GraphQLRequest? other) {
 		/// </summary>
 		public override int GetHashCode() {
 			unchecked {
-				return (Query.GetHashCode() * 397) ^ (OperationName != null ? OperationName.GetHashCode() : 0);
+				var hashCode = Query.GetHashCode();
+				hashCode = (hashCode * 397) ^ OperationName?.GetHashCode() ?? 0;
+				hashCode = (hashCode * 397) ^ Variables?.GetHashCode() ?? 0;
+				return hashCode;
 			}
 		}
 
 		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest{TVariables}"/> instances are equivalent
+		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
 		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the left of the equality operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the right of the equality operator</param>
+		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the equality operator</param>
+		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the equality operator</param>
 		/// <returns>true if left and right are equal; otherwise, false</returns>
 		public static bool operator ==(GraphQLRequest? left, GraphQLRequest? right) => EqualityComparer<GraphQLRequest?>.Default.Equals(left, right);
 
 		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest{TVariables}"/> instances are not equal
+		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are not equal
 		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the left of the not equal operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest{TVariables}"/> instance that is to the right of the not equal operator</param>
+		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the not equal operator</param>
+		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the not equal operator</param>
 		/// <returns>true if left and right are unequal; otherwise, false</returns>
 		public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
-
-
-		
 	}
 
-	/// <summary>
-	/// a GraphQL Request with variables
-	/// </summary>
-	public class GraphQLRequest<TVariables> : GraphQLRequest, IEquatable<GraphQLRequest<TVariables>?> {
-
-		/// <summary>
-		/// Represents the request variables
-		/// </summary>
-		public TVariables Variables { get; set; }
-
-		public GraphQLRequest()
-		{
-		}
-
-		public GraphQLRequest(string query, TVariables variables, string? operationName = null) : base(query, operationName) {
-			Variables = variables;
-		}
-
-		public bool Equals(GraphQLRequest<TVariables>? other)
-		{
-			if (ReferenceEquals(null, other)) return false;
-			if (ReferenceEquals(this, other)) return true;
-			return base.Equals(other) && EqualityComparer<TVariables>.Default.Equals(Variables, other.Variables);
-		}
-
-		public override bool Equals(object? obj)
-		{
-			if (ReferenceEquals(null, obj)) return false;
-			if (ReferenceEquals(this, obj)) return true;
-			if (obj.GetType() != this.GetType()) return false;
-			return Equals((GraphQLRequest<TVariables>) obj);
-		}
-
-		public override int GetHashCode()
-		{
-			unchecked
-			{
-				return (base.GetHashCode() * 397) ^ EqualityComparer<TVariables>.Default.GetHashCode(Variables);
-			}
-		}
-	}
 
 }
diff --git a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
index e129b57e..0888f9f8 100644
--- a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
@@ -6,7 +6,7 @@ public class GraphQLRequestTest {
 
 		[Fact]
 		public void ConstructorFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}");
 			Assert.NotNull(graphQLRequest.Query);
 			Assert.Null(graphQLRequest.OperationName);
 			Assert.Null(graphQLRequest.Variables);
@@ -14,7 +14,7 @@ public void ConstructorFact() {
 
 		[Fact]
 		public void ConstructorExtendedFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new {varName = "varValue"}, "operationName");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new {varName = "varValue"}, "operationName");
 			Assert.NotNull(graphQLRequest.Query);
 			Assert.NotNull(graphQLRequest.OperationName);
 			Assert.NotNull(graphQLRequest.Variables);
@@ -22,120 +22,128 @@ public void ConstructorExtendedFact() {
 
 		[Fact]
 		public void Equality1Fact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}");
 			Assert.Equal(graphQLRequest, graphQLRequest);
 		}
 
 		[Fact]
 		public void Equality2Fact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
 			Assert.Equal(graphQLRequest1, graphQLRequest2);
 		}
 
 		[Fact]
 		public void Equality3Fact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.Equal(graphQLRequest1, graphQLRequest2);
 		}
 
+
+		[Fact]
+		public void Equality4Fact() {
+			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+		}
+
 		[Fact]
 		public void EqualityOperatorFact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.True(graphQLRequest1 == graphQLRequest2);
 		}
 
 		[Fact]
 		public void InEquality1Fact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name1}}");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name2}}");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
 			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
 		}
 
 		[Fact]
 		public void InEquality2Fact() {
-			GraphQLRequest graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
-			GraphQLRequest graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue2" }, "operationName");
+			GraphQLRequest graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+			GraphQLRequest graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
 			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
 		}
 
 		[Fact]
 		public void InEqualityOperatorFact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name1}}");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name2}}");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
 			Assert.True(graphQLRequest1 != graphQLRequest2);
 		}
 
 		[Fact]
 		public void GetHashCode1Fact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
 			Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
 		}
 
 		[Fact]
 		public void GetHashCode2Fact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
 		}
 
 		[Fact]
 		public void GetHashCode3Fact() {
-			var graphQLRequest1 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
-			var graphQLRequest2 = GraphQLRequest.New("{hero{name}}", new { varName = "varValue2" }, "operationName");
+			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
 			Assert.True(graphQLRequest1.GetHashCode() != graphQLRequest2.GetHashCode());
 		}
 
 		[Fact]
 		public void PropertyQueryGetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
 			Assert.Equal("{hero{name}}", graphQLRequest.Query);
 		}
 
 		[Fact]
 		public void PropertyQuerySetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
 			graphQLRequest.Query = "{hero{name2}}";
 			Assert.Equal("{hero{name2}}", graphQLRequest.Query);
 		}
 
 		[Fact]
 		public void PropertyOperationNameGetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.Equal("operationName", graphQLRequest.OperationName);
 		}
 
 		[Fact]
 		public void PropertyOperationNameNullGetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}");
 			Assert.Null(graphQLRequest.OperationName);
 		}
 
 		[Fact]
 		public void PropertyOperationNameSetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName1");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1");
 			graphQLRequest.OperationName = "operationName2";
 			Assert.Equal("operationName2", graphQLRequest.OperationName);
 		}
 
 		[Fact]
 		public void PropertyVariableGetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue" }, "operationName");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.Equal(new { varName = "varValue" }, graphQLRequest.Variables);
 		}
 
 		[Fact]
 		public void PropertyVariableNullGetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}");
 			Assert.Null(graphQLRequest.Variables);
 		}
 
 		[Fact]
 		public void PropertyVariableSetFact() {
-			var graphQLRequest = GraphQLRequest.New("{hero{name}}", new { varName = "varValue1" }, "operationName1");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1");
 			graphQLRequest.Variables = new {
 				varName = "varValue2"
 			};
diff --git a/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
index e124d134..fc792a1d 100644
--- a/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
@@ -6,14 +6,14 @@ public class GraphQLResponseTest {
 
 		[Fact]
 		public void Constructor1Fact() {
-			var graphQLResponse = new GraphQLResponse();
+			var graphQLResponse = new GraphQLResponse<object>();
 			Assert.Null(graphQLResponse.Data);
 			Assert.Null(graphQLResponse.Errors);
 		}
 
 		[Fact]
 		public void Constructor2Fact() {
-			var graphQLResponse = new GraphQLResponse {
+			var graphQLResponse = new GraphQLResponse<object> {
 				Data = new { a = 1 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
@@ -23,24 +23,24 @@ public void Constructor2Fact() {
 
 		[Fact]
 		public void Equality1Fact() {
-			var graphQLResponse = new GraphQLResponse();
+			var graphQLResponse = new GraphQLResponse<object>();
 			Assert.Equal(graphQLResponse, graphQLResponse);
 		}
 
 		[Fact]
 		public void Equality2Fact() {
-			var graphQLResponse1 = new GraphQLResponse();
-			var graphQLResponse2 = new GraphQLResponse();
+			var graphQLResponse1 = new GraphQLResponse<object>();
+			var graphQLResponse2 = new GraphQLResponse<object>();
 			Assert.Equal(graphQLResponse1, graphQLResponse2);
 		}
 
 		[Fact]
 		public void Equality3Fact() {
-			var graphQLResponse1 = new GraphQLResponse {
+			var graphQLResponse1 = new GraphQLResponse<object> {
 				Data = new { a = 1 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
-			var graphQLResponse2 = new GraphQLResponse {
+			var graphQLResponse2 = new GraphQLResponse<object> {
 				Data = new { a = 1 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
@@ -49,18 +49,18 @@ public void Equality3Fact() {
 
 		[Fact]
 		public void EqualityOperatorFact() {
-			var graphQLResponse1 = new GraphQLResponse();
-			var graphQLResponse2 = new GraphQLResponse();
+			var graphQLResponse1 = new GraphQLResponse<object>();
+			var graphQLResponse2 = new GraphQLResponse<object>();
 			Assert.True(graphQLResponse1 == graphQLResponse2);
 		}
 
 		[Fact]
 		public void InEqualityFact() {
-			var graphQLResponse1 = new GraphQLResponse {
+			var graphQLResponse1 = new GraphQLResponse<object> {
 				Data = new { a = 1 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
-			var graphQLResponse2 = new GraphQLResponse {
+			var graphQLResponse2 = new GraphQLResponse<object> {
 				Data = new { a = 2 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
@@ -69,11 +69,11 @@ public void InEqualityFact() {
 
 		[Fact]
 		public void InEqualityOperatorFact() {
-			var graphQLResponse1 = new GraphQLResponse {
+			var graphQLResponse1 = new GraphQLResponse<object> {
 				Data = new { a = 1 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
-			var graphQLResponse2 = new GraphQLResponse {
+			var graphQLResponse2 = new GraphQLResponse<object> {
 				Data = new { a = 2 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
@@ -82,11 +82,11 @@ public void InEqualityOperatorFact() {
 
 		[Fact]
 		public void GetHashCodeFact() {
-			var graphQLResponse1 = new GraphQLResponse {
+			var graphQLResponse1 = new GraphQLResponse<object> {
 				Data = new { a = 1 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
-			var graphQLResponse2 = new GraphQLResponse {
+			var graphQLResponse2 = new GraphQLResponse<object> {
 				Data = new { a = 1 },
 				Errors = new[] { new GraphQLError { Message = "message" } }
 			};
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
deleted file mode 100644
index b4e3b37a..00000000
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using GraphQL.Client;
-using GraphQL.Client.Http;
-
-namespace GraphQL.Integration.Tests
-{
-	public static class GraphQLClientExtensions
-	{
-		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
-		{
-			var graphQLRequest = GraphQLRequest.New(
-				@"mutation($input: MessageInputType){
-				  addMessage(message: $input){
-				    content
-				  }
-				}",
-				new {
-					input = new {
-						fromId = "2",
-						content = message,
-						sentAt = DateTime.Now
-					}
-				});
-			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
-		}
-
-		public static async Task<GraphQLResponse> JoinDeveloperUser(this GraphQLHttpClient client)
-		{
-			var graphQLRequest = GraphQLRequest.New(@"
-				mutation($userId: String){
-				  join(userId: $userId){
-				    displayName
-				    id
-				  }
-				}",
-				new {
-					userId = "1"
-				});
-			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
-		}
-	}
-}
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
new file mode 100644
index 00000000..89c95546
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Threading.Tasks;
+using GraphQL.Client;
+using GraphQL.Client.Http;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class GraphQLClientTestExtensions
+	{
+		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this GraphQLHttpClient client, string message)
+		{
+			var graphQLRequest = new GraphQLRequest(
+				@"mutation($input: MessageInputType){
+				  addMessage(message: $input){
+				    content
+				  }
+				}",
+				new {
+					input = new {
+						fromId = "2",
+						content = message,
+						sentAt = DateTime.Now
+					}
+				});
+			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
+		}
+
+		public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this GraphQLHttpClient client)
+		{
+			var graphQLRequest = new GraphQLRequest(@"
+				mutation($userId: String){
+				  join(userId: $userId){
+				    displayName
+				    id
+				  }
+				}",
+				new {
+					userId = "1"
+				});
+			return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
+		}
+
+	}
+
+
+	public class AddMessageMutationResult {
+		public AddMessageContent AddMessage { get; set; }
+		public class AddMessageContent {
+			public string Content { get; set; }
+		}
+	}
+
+	public class JoinDeveloperMutationResult {
+		public JoinContent Join { get; set; }
+		public class JoinContent {
+			public string DisplayName { get; set; }
+			public string Id { get; set; }
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 26b454ce..8f4d5786 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -9,11 +9,14 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace GraphQL.Integration.Tests
 {
 	public class SubscriptionsTest
 	{
+		private readonly ITestOutputHelper output;
+
 		public static IWebHost CreateServer(int port)
 		{
 			var configBuilder = new ConfigurationBuilder();
@@ -38,8 +41,8 @@ public static IWebHost CreateServer(int port)
 
 		private readonly IWebHost _server;
 
-		public SubscriptionsTest()
-		{
+		public SubscriptionsTest(ITestOutputHelper output) {
+			this.output = output;
 		}
 
 		private GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
@@ -61,7 +64,7 @@ public async void AssertTestingHarness()
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
-				Assert.Equal(message, (string) response.Data.addMessage.content);
+				Assert.Equal(message, response.Data.AddMessage.Content);
 			}
 		}
 
@@ -75,7 +78,7 @@ public async void CanSendRequestViaWebsocket()
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
-				Assert.Equal(message, (string)response.Data.addMessage.content);
+				Assert.Equal(message, response.Data.AddMessage.Content);
 			}
 		}
 
@@ -87,7 +90,7 @@ public async void CanHandleRequestErrorViaWebsocket()
 			{
 				var client = GetGraphQLClient(port, true);
 				const string message = "some random testing message";
-				var response = await client.SendQueryAsync("this query is formatted quite badly").ConfigureAwait(false);
+				var response = await client.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
 
 				Assert.Single(response.Errors);
 			}
@@ -100,7 +103,7 @@ public async void CanHandleRequestErrorViaWebsocket()
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest = GraphQLRequest.New(SubscriptionQuery);
+		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
 		[Fact]
 		public async void CanCreateObservableSubscription()
@@ -117,7 +120,7 @@ public async void CanCreateObservableSubscription()
 				const string message1 = "Hello World";
 
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, (string) response.Data.addMessage.content);
+				Assert.Equal(message1, response.Data.AddMessage.Content);
 
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
@@ -126,7 +129,7 @@ public async void CanCreateObservableSubscription()
 
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string) response.Data.addMessage.content);
+				Assert.Equal(message2, response.Data.AddMessage.Content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
 					Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content);
@@ -162,18 +165,18 @@ public async void CanReconnectWithSameObservable()
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, (string) response.Data.addMessage.content);
+				Assert.Equal(message1, response.Data.AddMessage.Content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string) gqlResponse.Data.MessageAdded.Content);
+					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, (string) response.Data.addMessage.content);
+				Assert.Equal(message2, response.Data.AddMessage.Content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message2, (string) gqlResponse.Data.MessageAdded.Content);
+					Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				Debug.WriteLine("disposing subscription...");
@@ -182,14 +185,14 @@ public async void CanReconnectWithSameObservable()
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
 				tester.ShouldHaveReceivedUpdate(
-					gqlResponse => { Assert.Equal(message2, (string) gqlResponse.Data.MessageAdded.Content); },
+					gqlResponse => { Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content); },
 					TimeSpan.FromSeconds(10));
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
-				Assert.Equal(message3, (string) response.Data.addMessage.content);
+				Assert.Equal(message3, response.Data.AddMessage.Content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string) gqlResponse.Data.MessageAdded.Content);
+					Assert.Equal(message3, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				// disposing the client should complete the subscription
@@ -216,7 +219,7 @@ public class UserJoinedContent {
 
 		}
 
-		private readonly GraphQLRequest SubscriptionRequest2 = GraphQLRequest.New(SubscriptionQuery2);
+		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
 		public async void CanConnectTwoSubscriptionsSimultaneously()
@@ -238,21 +241,21 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, (string)response.Data.addMessage.content);
+				Assert.Equal(message1, response.Data.AddMessage.Content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message1, (string)gqlResponse.Data.MessageAdded.Content);
+					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
 
-				response = await client.JoinDeveloperUser().ConfigureAwait(false);
-				Assert.Equal("developer", (string)response.Data.join.displayName.Value);
+				var joinResponse = await client.JoinDeveloperUser().ConfigureAwait(false);
+				Assert.Equal("developer", joinResponse.Data.Join.DisplayName);
 
 				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal("1", (string)gqlResponse.Data.UserJoined.Id);
-					Assert.Equal("developer", (string)gqlResponse.Data.UserJoined.DisplayName);
+					Assert.Equal("1", gqlResponse.Data.UserJoined.Id);
+					Assert.Equal("developer", gqlResponse.Data.UserJoined.DisplayName);
 				});
 				
 				Debug.WriteLine("disposing subscription...");
@@ -260,10 +263,10 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
-				Assert.Equal(message3, (string)response.Data.addMessage.content);
+				Assert.Equal(message3, response.Data.AddMessage.Content);
 				tester.ShouldHaveReceivedUpdate(gqlResponse =>
 				{
-					Assert.Equal(message3, (string)gqlResponse.Data.MessageAdded.Content);
+					Assert.Equal(message3, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				// disposing the client should complete the subscription
@@ -288,11 +291,11 @@ public async void CanHandleConnectionTimeout()
 			const string message1 = "Hello World";
 
 			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-			Assert.Equal(message1, (string)response.Data.addMessage.content);
+			Assert.Equal(message1, response.Data.AddMessage.Content);
 
 			tester.ShouldHaveReceivedUpdate(gqlResponse =>
 			{
-				Assert.Equal(message1, (string)gqlResponse.Data.MessageAdded.Content);
+				Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 			});
 
 			Debug.WriteLine("stopping web host...");
@@ -310,7 +313,7 @@ public async void CanHandleConnectionTimeout()
 			}
 			catch (Exception e)
 			{
-				Console.WriteLine(e);
+				output.WriteLine($"failed to restart server: {e}");
 			}
 
 			// disposing the client should complete the subscription
@@ -320,7 +323,7 @@ public async void CanHandleConnectionTimeout()
 		}
 		
 		[Fact]
-		public async void CanHandleSubscriptionError()
+		public void CanHandleSubscriptionError()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
@@ -328,7 +331,7 @@ public async void CanHandleSubscriptionError()
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
-					GraphQLRequest.New(@"
+					new GraphQLRequest(@"
 						subscription {
 						  failImmediately {
 						    content
@@ -349,18 +352,18 @@ public async void CanHandleSubscriptionError()
 		}
 
 		[Fact]
-		public async void CanHandleQueryErrorInSubscription()
+		public void CanHandleQueryErrorInSubscription()
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port))
 			{
 
-				var test = GraphQLRequest.New("tset", new { test = "blaa"});
+				var test = new GraphQLRequest("tset", new { test = "blaa"});
 
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
-					GraphQLRequest.New(@"
+					new GraphQLRequest(@"
 						subscription {
 						  fieldDoesNotExist {
 						    content

From 826948d72d21534f211ef03c0bc0c08bd356c402 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 12:22:31 +0100
Subject: [PATCH 051/455] run dotnet format

---
 .github/workflows/workflow.yml                |   6 +-
 dotnet-tools.json                             |   2 +-
 root.props                                    |   2 +-
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  |  16 +--
 .../GraphQLHttpClientOptions.cs               |   3 +-
 .../GraphQLSerializationExtensions.cs         |   4 +-
 .../GraphQLSubscriptionException.cs           |  15 +--
 .../HttpClientExtensions.cs                   |   2 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 122 ++++++-----------
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  |  81 ++++-------
 .../Websocket/GraphQLWebSocketMessageType.cs  |   6 +-
 .../Websocket/GraphQLWebSocketResponse.cs     |  14 +-
 .../Websocket/WebsocketResponseWrapper.cs     |   2 +-
 src/GraphQL.Client/GraphQLClientExtensions.cs |   6 +-
 src/GraphQL.Client/GraphQLResponse.cs         |   2 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |   9 +-
 .../JsonSerializationTests.cs                 |   2 +-
 .../GraphQLRequestTest.cs                     |   2 +-
 .../CallbackTester.cs                         |  32 ++---
 .../GraphQLClientTestExtensions.cs            |  12 +-
 .../NetworkHelpers.cs                         |   9 +-
 .../ObservableTester.cs                       |  62 +++------
 .../SubscriptionsTest.cs                      | 114 ++++++----------
 .../WebApplicationFactoryExtensions.cs        |   9 +-
 .../ChatSchema/ChatMutation.cs                |  49 +++----
 .../ChatSchema/ChatQuery.cs                   |  15 +--
 .../ChatSchema/ChatSchema.cs                  |  19 ++-
 .../ChatSchema/ChatSubscriptions.cs           | 109 +++++++--------
 .../IntegrationTestServer/ChatSchema/IChat.cs | 127 ++++++++----------
 .../ChatSchema/Message.cs                     |  16 +--
 .../ChatSchema/MessageFrom.cs                 |  12 +-
 .../ChatSchema/MessageFromType.cs             |  17 +--
 .../ChatSchema/MessageType.cs                 |  30 ++---
 .../ChatSchema/ReceivedMessage.cs             |  14 +-
 tests/IntegrationTestServer/Program.cs        |  11 +-
 tests/IntegrationTestServer/Startup.cs        |  36 ++---
 36 files changed, 384 insertions(+), 605 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 268c5532..b12287b3 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -14,6 +14,7 @@ jobs:
     - run: dotnet restore
     - run: dotnet build
     - run: dotnet pack
+
   test:
     name: Test
     needs: build
@@ -26,6 +27,7 @@ jobs:
     - run: dotnet restore
     - run: dotnet build
     - run: dotnet test
+
   publish:
     name: Publish
     needs: test
@@ -38,5 +40,5 @@ jobs:
     - run: dotnet restore
     - run: dotnet build --configuration Release
     - run: dotnet pack --configuration Release
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.2.0.0-alpha.4.nupkg --api-key $GITHUB_TOKEN --source https://nuget.pkg.github.com/graphql-dotnet/graphql-client/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.2.0.0-alpha.4.nupkg --api-key $GITHUB_TOKEN --source https://nuget.pkg.github.com/graphql-dotnet/graphql-client/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key $GITHUB_TOKEN --source https://nuget.pkg.github.com/graphql-dotnet/graphql-client/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.*.nupkg --api-key $GITHUB_TOKEN --source https://nuget.pkg.github.com/graphql-dotnet/graphql-client/index.json
diff --git a/dotnet-tools.json b/dotnet-tools.json
index 80b96672..d745d3cf 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -5,7 +5,7 @@
 			"commands": [
 				"dotnet-format"
 			],
-			"version": "3.1.37601"
+			"version": "3.2.107702"
 		}
 	}
 }
diff --git a/root.props b/root.props
index 9b280c29..c9489974 100644
--- a/root.props
+++ b/root.props
@@ -2,7 +2,7 @@
 <Project>
 
 	<PropertyGroup>
-		<Authors>Deinok,graphql-dotnet</Authors>
+		<Authors>Deinok,Alexander Rose,graphql-dotnet</Authors>
 		<Description>A GraphQL Client for .NET Standard</Description>
 		<GenerateAssemblyInfo>True</GenerateAssemblyInfo>
 		<GenerateDocumentationFile>True</GenerateDocumentationFile>
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index c78b386f..27eb27d8 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -26,12 +26,10 @@ public class GraphQLHttpClient : IGraphQLClient {
 		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
 
 
-		public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint))
-		{ }
+		public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint)) { }
+
+		public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
 
-		public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint)
-		{ }
-		
 		public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
 			Options = new GraphQLHttpClientOptions();
 			configure(Options);
@@ -50,7 +48,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 			this.httpClient = httpClient;
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
-		
+
 		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null,
 			CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
@@ -73,7 +71,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
 
 			if (subscriptionStreams.ContainsKey(key))
-				return (IObservable<GraphQLResponse<TResponse>>) subscriptionStreams[key];
+				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, Options, cancellationToken: cancellationTokenSource.Token);
 
@@ -102,7 +100,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
 
 			if (subscriptionStreams.ContainsKey(key))
-				return (IObservable<GraphQLResponse<TResponse>>) subscriptionStreams[key];
+				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, Options, exceptionHandler, cancellationTokenSource.Token);
 			subscriptionStreams.TryAdd(key, observable);
@@ -121,7 +119,7 @@ private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TRespons
 			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
 			return await bodyStream.DeserializeFromJsonAsync<GraphQLHttpResponse<TResponse>>(Options, cancellationToken);
 		}
-		
+
 		private HttpRequestMessage GenerateHttpRequestMessage(string requestString) {
 			return new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
 				Content = new StringContent(requestString, Encoding.UTF8, "application/json")
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index 73a0a591..bf0502dc 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -51,8 +51,7 @@ public class GraphQLHttpClientOptions {
 		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
 		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
 		/// </summary>
-		public Func<int, TimeSpan> BackOffStrategy = n =>
-		{
+		public Func<int, TimeSpan> BackOffStrategy = n => {
 			var rnd = new Random();
 			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
 		};
diff --git a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
index 90d4d6b3..a0a6d271 100644
--- a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
+++ b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
@@ -10,12 +10,12 @@ public static string SerializeToJson(this GraphQLRequest request,
 			GraphQLHttpClientOptions options) {
 			return JsonSerializer.Serialize(request, options.JsonSerializerOptions);
 		}
-		
+
 		public static TGraphQLResponse DeserializeFromJson<TGraphQLResponse>(this string jsonString,
 			GraphQLHttpClientOptions options) {
 			return JsonSerializer.Deserialize<TGraphQLResponse>(jsonString, options.JsonSerializerOptions);
 		}
-		
+
 		public static ValueTask<TGraphQLResponse> DeserializeFromJsonAsync<TGraphQLResponse>(this Stream stream,
 			GraphQLHttpClientOptions options, CancellationToken cancellationToken = default) {
 			return JsonSerializer.DeserializeAsync<TGraphQLResponse>(stream, options.JsonSerializerOptions, cancellationToken);
diff --git a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
index 465ad5f3..8607c5be 100644
--- a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
@@ -1,11 +1,9 @@
 using System;
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Http
-{
+namespace GraphQL.Client.Http {
 	[Serializable]
-	public class GraphQLSubscriptionException : Exception
-	{
+	public class GraphQLSubscriptionException : Exception {
 		//
 		// For guidelines regarding the creation of new exception types, see
 		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
@@ -13,18 +11,15 @@ public class GraphQLSubscriptionException : Exception
 		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
 		//
 
-		public GraphQLSubscriptionException()
-		{
+		public GraphQLSubscriptionException() {
 		}
 
-		public GraphQLSubscriptionException(object error) : base(error.ToString())
-		{
+		public GraphQLSubscriptionException(object error) : base(error.ToString()) {
 		}
 
 		protected GraphQLSubscriptionException(
 			SerializationInfo info,
-			StreamingContext context) : base(info, context)
-		{
+			StreamingContext context) : base(info, context) {
 		}
 	}
 }
diff --git a/src/GraphQL.Client.Http/HttpClientExtensions.cs b/src/GraphQL.Client.Http/HttpClientExtensions.cs
index 3b4aa2de..7e78cae3 100644
--- a/src/GraphQL.Client.Http/HttpClientExtensions.cs
+++ b/src/GraphQL.Client.Http/HttpClientExtensions.cs
@@ -9,7 +9,7 @@ public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, stri
 			httpClient.AsGraphQLClient(new Uri(endPoint));
 
 		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
-			new GraphQLHttpClient(new GraphQLHttpClientOptions{EndPoint = endPoint}, httpClient);
+			new GraphQLHttpClient(new GraphQLHttpClientOptions { EndPoint = endPoint }, httpClient);
 
 		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
 			new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
index 566234b3..7678cc59 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
@@ -11,10 +11,8 @@
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
-namespace GraphQL.Client.Http.Websocket
-{
-	internal class GraphQLHttpWebSocket: IDisposable
-	{
+namespace GraphQL.Client.Http.Websocket {
+	internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly Uri webSocketUri;
 		private readonly GraphQLHttpClientOptions _options;
 		private readonly ArraySegment<byte> buffer;
@@ -30,8 +28,7 @@ internal class GraphQLHttpWebSocket: IDisposable
 		private WebSocket clientWebSocket = null;
 		private int _connectionAttempt = 0;
 
-		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
-		{
+		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options) {
 			this.webSocketUri = webSocketUri;
 			_options = options;
 			buffer = new ArraySegment<byte>(new byte[8192]);
@@ -46,18 +43,14 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		public IObservable<WebsocketResponseWrapper> _responseStream;
 		//private IDisposable _responseStreamConnection;
 
-		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
-		{
+		public Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
 			_requestSubject.OnNext(request);
 			return request.SendTask();
 		}
 
-		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
-		{
-			try
-			{
-				if (_cancellationTokenSource.Token.IsCancellationRequested)
-				{
+		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request) {
+			try {
+				if (_cancellationTokenSource.Token.IsCancellationRequested) {
 					request.SendCanceled();
 					return;
 				}
@@ -71,8 +64,7 @@ await this.clientWebSocket.SendAsync(
 					_cancellationTokenSource.Token).ConfigureAwait(false);
 				request.SendCompleted();
 			}
-			catch (Exception e)
-			{
+			catch (Exception e) {
 				request.SendFailed(e);
 			}
 		}
@@ -83,27 +75,24 @@ await this.clientWebSocket.SendAsync(
 
 		#region Private Methods
 
-		private Task _backOff()
-		{
+		private Task _backOff() {
 			_connectionAttempt++;
 
-			if(_connectionAttempt == 1) return Task.CompletedTask;
+			if (_connectionAttempt == 1) return Task.CompletedTask;
 
 			var delay = _options.BackOffStrategy(_connectionAttempt - 1);
 			Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
 			return Task.Delay(delay);
 		}
 
-		public Task InitializeWebSocket()
-		{
+		public Task InitializeWebSocket() {
 			// do not attempt to initialize if cancellation is requested
-			if(_disposed != null)
+			if (_disposed != null)
 				throw new OperationCanceledException();
 
-			lock (_initializeLock)
-			{
+			lock (_initializeLock) {
 				// if an initialization task is already running, return that
-				if(InitializeWebSocketTask != null &&
+				if (InitializeWebSocketTask != null &&
 				   !InitializeWebSocketTask.IsFaulted &&
 				   !InitializeWebSocketTask.IsCompleted)
 					return InitializeWebSocketTask;
@@ -119,8 +108,7 @@ public Task InitializeWebSocket()
 				// fix websocket not supported on win 7 using
 				// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
 				clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
-				switch (clientWebSocket)
-				{
+				switch (clientWebSocket) {
 					case ClientWebSocket nativeWebSocket:
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
 						break;
@@ -134,25 +122,21 @@ public Task InitializeWebSocket()
 				return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 			}
 		}
-		
-		private IObservable<WebsocketResponseWrapper> _createResponseStream()
-		{
+
+		private IObservable<WebsocketResponseWrapper> _createResponseStream() {
 			return Observable.Create<WebsocketResponseWrapper>(_createResultStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
 				.Catch<WebsocketResponseWrapper, OperationCanceledException>(exception =>
 					Observable.Empty<WebsocketResponseWrapper>());
 		}
 
-		private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseWrapper> observer, CancellationToken token)
-		{
-			if (_responseSubject == null || _responseSubject.IsDisposed)
-			{
+		private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseWrapper> observer, CancellationToken token) {
+			if (_responseSubject == null || _responseSubject.IsDisposed) {
 				_responseSubject = new Subject<WebsocketResponseWrapper>();
 				var observable = await _getReceiveResultStream().ConfigureAwait(false);
 				observable.Subscribe(_responseSubject);
 
-				_responseSubject.Subscribe(_ => { }, ex =>
-				{
+				_responseSubject.Subscribe(_ => { }, ex => {
 					_exceptionSubject.OnNext(ex);
 					_responseSubject?.Dispose();
 					_responseSubject = null;
@@ -162,27 +146,23 @@ private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseW
 					_responseSubject = null;
 				});
 			}
-					   
+
 			return new CompositeDisposable
 			(
 				_responseSubject.Subscribe(observer),
-				Disposable.Create(() =>
-				{
+				Disposable.Create(() => {
 					Debug.WriteLine("response stream disposed");
 				})
 			);
 		}
 
-		private async Task<IObservable<WebsocketResponseWrapper>> _getReceiveResultStream()
-		{
+		private async Task<IObservable<WebsocketResponseWrapper>> _getReceiveResultStream() {
 			await InitializeWebSocket().ConfigureAwait(false);
 			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
 		}
 
-		private async Task _connectAsync(CancellationToken token)
-		{
-			try
-			{
+		private async Task _connectAsync(CancellationToken token) {
+			try {
 				await _backOff().ConfigureAwait(false);
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
@@ -190,8 +170,7 @@ private async Task _connectAsync(CancellationToken token)
 				//_responseStreamConnection = _responseStream.Connect();
 				_connectionAttempt = 1;
 			}
-			catch (Exception e)
-			{
+			catch (Exception e) {
 				_exceptionSubject.OnNext(e);
 				throw;
 			}
@@ -204,30 +183,24 @@ private async Task _connectAsync(CancellationToken token)
 		/// wrapper method to pick up the existing request task if already running
 		/// </summary>
 		/// <returns></returns>
-		private Task<WebsocketResponseWrapper> _getReceiveTask()
-		{
-			lock (_receiveTaskLocker)
-			{
+		private Task<WebsocketResponseWrapper> _getReceiveTask() {
+			lock (_receiveTaskLocker) {
 				if (_receiveAsyncTask == null ||
-				    _receiveAsyncTask.IsFaulted ||
-				    _receiveAsyncTask.IsCompleted)
+					_receiveAsyncTask.IsFaulted ||
+					_receiveAsyncTask.IsCompleted)
 					_receiveAsyncTask = _receiveResultAsync();
 			}
 
 			return _receiveAsyncTask;
 		}
 
-		private async Task<WebsocketResponseWrapper> _receiveResultAsync()
-		{
-			try
-			{
+		private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
+			try {
 				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
 
-				using (var ms = new MemoryStream())
-				{
+				using (var ms = new MemoryStream()) {
 					WebSocketReceiveResult webSocketReceiveResult = null;
-					do
-					{
+					do {
 						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
 						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
 						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
@@ -246,29 +219,25 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync()
 
 						return response;
 					}
-					else
-					{
+					else {
 						throw new NotSupportedException("binary websocket messages are not supported");
 					}
-				}				
+				}
 			}
-			catch (Exception e)
-			{
+			catch (Exception e) {
 				Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
 				throw;
 			}
 		}
 
-		private async Task _closeAsync(CancellationToken cancellationToken = default)
-		{
-			if(clientWebSocket == null)
+		private async Task _closeAsync(CancellationToken cancellationToken = default) {
+			if (clientWebSocket == null)
 				return;
 
 			// don't attempt to close the websocket if it is in a failed state
 			if (this.clientWebSocket.State != WebSocketState.Open &&
-			    this.clientWebSocket.State != WebSocketState.CloseReceived &&
-			    this.clientWebSocket.State != WebSocketState.CloseSent)
-			{
+				this.clientWebSocket.State != WebSocketState.CloseReceived &&
+				this.clientWebSocket.State != WebSocketState.CloseSent) {
 				Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
 				return;
 			}
@@ -283,17 +252,14 @@ private async Task _closeAsync(CancellationToken cancellationToken = default)
 
 		private Task _disposed;
 		private object _disposedLocker = new object();
-		public void Dispose()
-		{
+		public void Dispose() {
 			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			lock (_disposedLocker)
-			{
+			lock (_disposedLocker) {
 				if (_disposed == null) _disposed = DisposeAsync();
 			}
 		}
 
-		private async Task DisposeAsync()
-		{
+		private async Task DisposeAsync() {
 			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index 7a3af1f0..4f357a3e 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -9,22 +9,17 @@
 using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
 
-namespace GraphQL.Client.Http.Websocket
-{
-	public static class GraphQLHttpWebsocketHelpers
-	{
+namespace GraphQL.Client.Http.Websocket {
+	public static class GraphQLHttpWebsocketHelpers {
 		internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
 			GraphQLHttpClientOptions options,
 			Action<Exception> exceptionHandler = null,
-			CancellationToken cancellationToken = default)
-		{
+			CancellationToken cancellationToken = default) {
 			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse<TResponse>>(async observer =>
-				{
-					var startRequest = new GraphQLWebSocketRequest
-					{
+				Observable.Create<GraphQLResponse<TResponse>>(async observer => {
+					var startRequest = new GraphQLWebSocketRequest {
 						Id = Guid.NewGuid().ToString("N"),
 						Type = GraphQLWebSocketMessageType.GQL_START,
 						Payload = request
@@ -38,11 +33,9 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 						graphQlHttpWebSocket.ResponseStream
 							// ignore null values and messages for other requests
 							.Where(response => response != null && response.Id == startRequest.Id)
-							.Subscribe(response =>
-							{
+							.Subscribe(response => {
 								// terminate the sequence when a 'complete' message is received
-								if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-								{
+								if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE) {
 									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
 									o.OnCompleted();
 									return;
@@ -56,8 +49,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 								o.OnNext(typedResponse.Payload);
 
 								// in case of a GraphQL error, terminate the sequence after the response has been posted
-								if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
-								{
+								if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR) {
 									Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
 									o.OnCompleted();
 								}
@@ -66,26 +58,22 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 							o.OnCompleted)
 					);
 
-					try
-					{
+					try {
 						// initialize websocket (completes immediately if socket is already open)
 						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
 					}
-					catch (Exception e)
-					{
+					catch (Exception e) {
 						// subscribe observer to failed observable
 						return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
 					}
 
 					var disposable = new CompositeDisposable(
 						observable.Subscribe(observer),
-						Disposable.Create(async () =>
-						{
+						Disposable.Create(async () => {
 							// only try to send close request on open websocket
 							if (graphQlHttpWebSocket.WebSocketState != WebSocketState.Open) return;
 
-							try
-							{
+							try {
 								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
 								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
 							}
@@ -96,12 +84,10 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 
 					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
 					// send subscription request
-					try
-					{
+					try {
 						await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
 					}
-					catch (Exception e)
-					{
+					catch (Exception e) {
 						Console.WriteLine(e);
 						throw;
 					}
@@ -114,17 +100,14 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 				// wrap results
 				.Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
 				// do exception handling
-				.Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e =>
-				{
-					try
-					{
+				.Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e => {
+					try {
 						if (exceptionHandler == null) {
 							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
 							// this will ensure that the client tries to re-establish subscriptions on connection loss
 							if (!(e is WebSocketException)) throw e;
 						}
-						else
-						{
+						else {
 							// exceptions thrown by the handler will propagate to OnError()
 							exceptionHandler?.Invoke(e);
 						}
@@ -134,8 +117,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 							? Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>()
 							: Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
 					}
-					catch (Exception exception)
-					{
+					catch (Exception exception) {
 						// wrap all other exceptions to be propagated behind retry
 						return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
 					}
@@ -143,8 +125,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 				// attempt to recreate the websocket for rethrown exceptions
 				.Retry()
 				// unwrap and push results or throw wrapped exceptions
-				.SelectMany(t =>
-				{
+				.SelectMany(t => {
 					// if the result contains an exception, throw it on the observable
 					if (t.Item2 != null)
 						return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
@@ -161,12 +142,9 @@ internal static Task<GraphQLResponse<TResponse>> Request<TResponse>(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
 			GraphQLHttpClientOptions options,
-			CancellationToken cancellationToken = default)
-		{
-			return Observable.Create<GraphQLResponse<TResponse>>(async observer =>
-			{
-				var websocketRequest = new GraphQLWebSocketRequest
-				{
+			CancellationToken cancellationToken = default) {
+			return Observable.Create<GraphQLResponse<TResponse>>(async observer => {
+				var websocketRequest = new GraphQLWebSocketRequest {
 					Id = Guid.NewGuid().ToString("N"),
 					Type = GraphQLWebSocketMessageType.GQL_START,
 					Payload = request
@@ -174,8 +152,7 @@ internal static Task<GraphQLResponse<TResponse>> Request<TResponse>(
 				var observable = graphQlHttpWebSocket.ResponseStream
 					.Where(response => response != null && response.Id == websocketRequest.Id)
 					.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-					.Select(response =>
-					{
+					.Select(response => {
 						Debug.WriteLine($"received response for request {websocketRequest.Id}");
 						var typedResponse =
 							JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
@@ -183,13 +160,11 @@ internal static Task<GraphQLResponse<TResponse>> Request<TResponse>(
 						return typedResponse.Payload;
 					});
 
-				try
-				{
+				try {
 					// intialize websocket (completes immediately if socket is already open)
 					await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
 				}
-				catch (Exception e)
-				{
+				catch (Exception e) {
 					// subscribe observer to failed observable
 					return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
 				}
@@ -200,12 +175,10 @@ internal static Task<GraphQLResponse<TResponse>> Request<TResponse>(
 
 				Debug.WriteLine($"submitting request {websocketRequest.Id}");
 				// send request
-				try
-				{
+				try {
 					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
 				}
-				catch (Exception e)
-				{
+				catch (Exception e) {
 					Console.WriteLine(e);
 					throw;
 				}
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
index df55a3b2..755a075b 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
@@ -1,7 +1,5 @@
-namespace GraphQL.Client.Http.Websocket
-{
-	public static class GraphQLWebSocketMessageType
-	{
+namespace GraphQL.Client.Http.Websocket {
+	public static class GraphQLWebSocketMessageType {
 
 		/// <summary>
 		///     Client sends this message after plain websocket connection to start the communication with the server
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
index 9dbd9abf..9d791cfc 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
@@ -64,25 +64,21 @@ public override int GetHashCode() {
 	public class GraphQLWebSocketResponse<TResponse> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TResponse>> {
 		public GraphQLHttpResponse<TResponse> Payload { get; set; }
 
-		public bool Equals(GraphQLWebSocketResponse<TResponse>? other)
-		{
+		public bool Equals(GraphQLWebSocketResponse<TResponse>? other) {
 			if (ReferenceEquals(null, other)) return false;
 			if (ReferenceEquals(this, other)) return true;
 			return base.Equals(other) && Payload.Equals(other.Payload);
 		}
 
-		public override bool Equals(object? obj)
-		{
+		public override bool Equals(object? obj) {
 			if (ReferenceEquals(null, obj)) return false;
 			if (ReferenceEquals(this, obj)) return true;
 			if (obj.GetType() != this.GetType()) return false;
-			return Equals((GraphQLWebSocketResponse<TResponse>) obj);
+			return Equals((GraphQLWebSocketResponse<TResponse>)obj);
 		}
 
-		public override int GetHashCode()
-		{
-			unchecked
-			{
+		public override int GetHashCode() {
+			unchecked {
 				return (base.GetHashCode() * 397) ^ Payload.GetHashCode();
 			}
 		}
diff --git a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
index 3d360eea..fe237889 100644
--- a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
+++ b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
@@ -2,7 +2,7 @@
 
 namespace GraphQL.Client.Http.Websocket {
 	public class WebsocketResponseWrapper : GraphQLWebSocketResponse {
-		
+
 		[JsonIgnore]
 		public byte[] MessageBytes { get; set; }
 	}
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client/GraphQLClientExtensions.cs
index 5ea54bdf..a452560c 100644
--- a/src/GraphQL.Client/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLClientExtensions.cs
@@ -1,14 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Net.WebSockets;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client {
 	public static class GraphQLClientExtensions {
 
-		
+
 		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
 			string query, object? variables = null,
 			string? operationName = null, CancellationToken cancellationToken = default) {
diff --git a/src/GraphQL.Client/GraphQLResponse.cs b/src/GraphQL.Client/GraphQLResponse.cs
index 7834d2ab..81c163d5 100644
--- a/src/GraphQL.Client/GraphQLResponse.cs
+++ b/src/GraphQL.Client/GraphQLResponse.cs
@@ -54,6 +54,6 @@ public override int GetHashCode() {
 
 	}
 
-	
+
 
 }
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index dcd5d93e..dd8a180a 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -7,7 +7,7 @@ namespace GraphQL {
 	/// A GraphQL request
 	/// </summary>
 	public class GraphQLRequest : IEquatable<GraphQLRequest?> {
-		
+
 		/// <summary>
 		/// The Query
 		/// </summary>
@@ -24,8 +24,7 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		public virtual object? Variables { get; set; }
 
 
-		public GraphQLRequest()
-		{
+		public GraphQLRequest() {
 		}
 
 		public GraphQLRequest(string query, object? variables = null, string? operationName = null) {
@@ -55,8 +54,8 @@ public virtual bool Equals(GraphQLRequest? other) {
 			if (ReferenceEquals(null, other)) return false;
 			if (ReferenceEquals(this, other)) return true;
 			return Query == other.Query
-			       && OperationName == other.OperationName
-			       && EqualityComparer<object>.Default.Equals(Variables, other.Variables);
+				   && OperationName == other.OperationName
+				   && EqualityComparer<object>.Default.Equals(Variables, other.Variables);
 		}
 
 		/// <summary>
diff --git a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
index c50d7a51..21a659fe 100644
--- a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
@@ -7,7 +7,7 @@ public class JsonSerializationTests {
 
 		[Fact]
 		public void WebSocketResponseDeserialization() {
-			var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff"};
+			var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff" };
 			var json = JsonSerializer.Serialize(testObject);
 			var deserialized = JsonSerializer.Deserialize<TestObject>(json);
 
diff --git a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
index 0888f9f8..c3a22357 100644
--- a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
@@ -14,7 +14,7 @@ public void ConstructorFact() {
 
 		[Fact]
 		public void ConstructorExtendedFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new {varName = "varValue"}, "operationName");
+			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
 			Assert.NotNull(graphQLRequest.Query);
 			Assert.NotNull(graphQLRequest.OperationName);
 			Assert.NotNull(graphQLRequest.Variables);
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
index 91995feb..936543ce 100644
--- a/tests/GraphQL.Integration.Tests/CallbackTester.cs
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -2,10 +2,8 @@
 using System.Threading;
 using Xunit;
 
-namespace GraphQL.Integration.Tests
-{
-	public class CallbackTester<T>
-	{
+namespace GraphQL.Integration.Tests {
+	public class CallbackTester<T> {
 		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
 
 		/// <summary>
@@ -22,8 +20,7 @@ public class CallbackTester<T>
 		/// </summary>
 		public T LastPayload { get; private set; }
 
-		public void Callback(T param)
-		{
+		public void Callback(T param) {
 			LastPayload = param;
 			_callbackInvoked.Set();
 		}
@@ -33,17 +30,14 @@ public void Callback(T param)
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null)
-		{
-			try
-			{
+		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null) {
+			try {
 				if (!_callbackInvoked.Wait(timeout ?? Timeout))
 					Assert.True(false, $"callback not invoked within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertPayload?.Invoke(LastPayload);
 			}
-			finally
-			{
+			finally {
 				Reset();
 			}
 		}
@@ -52,16 +46,13 @@ public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSp
 		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null)
-		{
-			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
-			try
-			{
+		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null) {
+			if (!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
+			try {
 				if (_callbackInvoked.Wait(timeout.Value))
 					Assert.True(false, "callback was inadvertently invoked pushed!");
 			}
-			finally
-			{
+			finally {
 				Reset();
 			}
 		}
@@ -69,8 +60,7 @@ public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null)
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
-		public void Reset()
-		{
+		public void Reset() {
 			LastPayload = default(T);
 			_callbackInvoked.Reset();
 		}
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
index 89c95546..1a187011 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
@@ -3,12 +3,9 @@
 using GraphQL.Client;
 using GraphQL.Client.Http;
 
-namespace GraphQL.Integration.Tests
-{
-	public static class GraphQLClientTestExtensions
-	{
-		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this GraphQLHttpClient client, string message)
-		{
+namespace GraphQL.Integration.Tests {
+	public static class GraphQLClientTestExtensions {
+		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this GraphQLHttpClient client, string message) {
 			var graphQLRequest = new GraphQLRequest(
 				@"mutation($input: MessageInputType){
 				  addMessage(message: $input){
@@ -25,8 +22,7 @@ public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(th
 			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
 		}
 
-		public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this GraphQLHttpClient client)
-		{
+		public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this GraphQLHttpClient client) {
 			var graphQLRequest = new GraphQLRequest(@"
 				mutation($userId: String){
 				  join(userId: $userId){
diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
index 1462767e..c917deee 100644
--- a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
@@ -1,12 +1,9 @@
 using System.Net;
 using System.Net.Sockets;
 
-namespace GraphQL.Integration.Tests
-{
-	public static class NetworkHelpers
-	{
-		public static int GetFreeTcpPortNumber()
-		{
+namespace GraphQL.Integration.Tests {
+	public static class NetworkHelpers {
+		public static int GetFreeTcpPortNumber() {
 			var l = new TcpListener(IPAddress.Loopback, 0);
 			l.Start();
 			var port = ((IPEndPoint)l.LocalEndpoint).Port;
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index 5478825b..611c250d 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -2,10 +2,8 @@
 using System.Threading;
 using Xunit;
 
-namespace GraphQL.Integration.Tests
-{
-	public class ObservableTester<T> : IDisposable
-	{
+namespace GraphQL.Integration.Tests {
+	public class ObservableTester<T> : IDisposable {
 		private readonly IDisposable _subscription;
 		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
 		private ManualResetEventSlim _completed { get; } = new ManualResetEventSlim();
@@ -31,15 +29,13 @@ public class ObservableTester<T> : IDisposable
 		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
-		public ObservableTester(IObservable<T> observable)
-		{
+		public ObservableTester(IObservable<T> observable) {
 			_subscription = observable.Subscribe(
 				obj => {
 					LastPayload = obj;
 					_updateReceived.Set();
 				},
-				ex =>
-				{
+				ex => {
 					Error = ex;
 					_error.Set();
 				},
@@ -52,17 +48,14 @@ public ObservableTester(IObservable<T> observable)
 		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
 		/// </summary>
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? timeout = null)
-		{
-			try
-			{
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? timeout = null) {
+			try {
 				if (!_updateReceived.Wait(timeout ?? Timeout))
 					Assert.True(false, $"no update received within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertPayload?.Invoke(LastPayload);
 			}
-			finally
-			{
+			finally {
 				_reset();
 			}
 		}
@@ -71,16 +64,13 @@ public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? t
 		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
 		/// </summary>
 		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null)
-		{
-			if(!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
-			try
-			{
+		public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null) {
+			if (!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
+			try {
 				if (_updateReceived.Wait(timeout.Value))
 					Assert.True(false, "update was inadvertently pushed!");
 			}
-			finally
-			{
+			finally {
 				_reset();
 			}
 		}
@@ -88,15 +78,12 @@ public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null)
 		/// <summary>
 		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveCompleted(TimeSpan? timeout = null)
-		{
-			try
-			{
+		public void ShouldHaveCompleted(TimeSpan? timeout = null) {
+			try {
 				if (!_completed.Wait(timeout ?? Timeout))
 					Assert.True(false, $"subscription did not complete within {(timeout ?? Timeout).TotalSeconds} s!");
 			}
-			finally
-			{
+			finally {
 				_reset();
 			}
 		}
@@ -104,17 +91,14 @@ public void ShouldHaveCompleted(TimeSpan? timeout = null)
 		/// <summary>
 		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
 		/// </summary>
-		public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan? timeout = null)
-		{
-			try
-			{
+		public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan? timeout = null) {
+			try {
 				if (!_error.Wait(timeout ?? Timeout))
 					Assert.True(false, $"subscription did not throw an error within {(timeout ?? Timeout).TotalSeconds} s!");
 
 				assertError?.Invoke(Error);
 			}
-			finally
-			{
+			finally {
 				_reset();
 			}
 		}
@@ -122,8 +106,7 @@ public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
-		private void _reset()
-		{
+		private void _reset() {
 			//if (_completed.IsSet)
 			//	throw new InvalidOperationException(
 			//		"the subscription sequence has completed. this tester instance cannot be reused");
@@ -133,16 +116,13 @@ private void _reset()
 		}
 
 		/// <inheritdoc />
-		public void Dispose()
-		{
+		public void Dispose() {
 			_subscription?.Dispose();
 		}
 	}
 
-	public static class ObservableExtensions
-	{
-		public static ObservableTester<T> SubscribeTester<T>(this IObservable<T> observable)
-		{
+	public static class ObservableExtensions {
+		public static ObservableTester<T> SubscribeTester<T>(this IObservable<T> observable) {
 			return new ObservableTester<T>(observable);
 		}
 	}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8f4d5786..70fc16e9 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -11,22 +11,18 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GraphQL.Integration.Tests
-{
-	public class SubscriptionsTest
-	{
+namespace GraphQL.Integration.Tests {
+	public class SubscriptionsTest {
 		private readonly ITestOutputHelper output;
 
-		public static IWebHost CreateServer(int port)
-		{
+		public static IWebHost CreateServer(int port) {
 			var configBuilder = new ConfigurationBuilder();
 			configBuilder.AddInMemoryCollection();
 			var config = configBuilder.Build();
 			config["server.urls"] = $"http://localhost:{port}";
 
 			var host = new WebHostBuilder()
-				.ConfigureLogging((ctx, logging) =>
-				{
+				.ConfigureLogging((ctx, logging) => {
 					logging.AddDebug();
 				})
 				.UseConfiguration(config)
@@ -46,19 +42,16 @@ public SubscriptionsTest(ITestOutputHelper output) {
 		}
 
 		private GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
-			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
-			{
+			=> new GraphQLHttpClient(new GraphQLHttpClientOptions {
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
 				UseWebSocketForQueriesAndMutations = requestsViaWebsocket
 			});
 
 
 		[Fact]
-		public async void AssertTestingHarness()
-		{
+		public async void AssertTestingHarness() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port);
 
 				const string message = "some random testing message";
@@ -69,11 +62,9 @@ public async void AssertTestingHarness()
 		}
 
 		[Fact]
-		public async void CanSendRequestViaWebsocket()
-		{
+		public async void CanSendRequestViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port, true);
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
@@ -83,11 +74,9 @@ public async void CanSendRequestViaWebsocket()
 		}
 
 		[Fact]
-		public async void CanHandleRequestErrorViaWebsocket()
-		{
+		public async void CanHandleRequestErrorViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port, true);
 				const string message = "some random testing message";
 				var response = await client.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
@@ -106,11 +95,9 @@ public async void CanHandleRequestErrorViaWebsocket()
 		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
 		[Fact]
-		public async void CanCreateObservableSubscription()
-		{
+		public async void CanCreateObservableSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
@@ -122,16 +109,14 @@ public async void CanCreateObservableSubscription()
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
 				Assert.Equal(message1, response.Data.AddMessage.Content);
 
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				const string message2 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
 				Assert.Equal(message2, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content);
 				});
 
@@ -150,11 +135,9 @@ public class MessageAddedContent {
 		}
 
 		[Fact]
-		public async void CanReconnectWithSameObservable()
-		{
+		public async void CanReconnectWithSameObservable() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
@@ -166,16 +149,14 @@ public async void CanReconnectWithSameObservable()
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
 				Assert.Equal(message1, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 				});
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
 				Assert.Equal(message2, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content);
 				});
 
@@ -190,8 +171,7 @@ public async void CanReconnectWithSameObservable()
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal(message3, gqlResponse.Data.MessageAdded.Content);
 				});
 
@@ -222,13 +202,11 @@ public class UserJoinedContent {
 		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 		[Fact]
-		public async void CanConnectTwoSubscriptionsSimultaneously()
-		{
+		public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackTester<Exception>();
 			var callbackTester2 = new CallbackTester<Exception>();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
@@ -242,8 +220,7 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
 				Assert.Equal(message1, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 				});
 
@@ -252,20 +229,18 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 				var joinResponse = await client.JoinDeveloperUser().ConfigureAwait(false);
 				Assert.Equal("developer", joinResponse.Data.Join.DisplayName);
 
-				tester2.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester2.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal("1", gqlResponse.Data.UserJoined.Id);
 					Assert.Equal("developer", gqlResponse.Data.UserJoined.DisplayName);
 				});
-				
+
 				Debug.WriteLine("disposing subscription...");
 				tester2.Dispose();
 
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
 				Assert.Equal(message3, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Equal(message3, gqlResponse.Data.MessageAdded.Content);
 				});
 
@@ -276,8 +251,7 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
 		}
 
 		[Fact]
-		public async void CanHandleConnectionTimeout()
-		{
+		public async void CanHandleConnectionTimeout() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var server = CreateServer(port);
 			var callbackTester = new CallbackTester<Exception>();
@@ -293,8 +267,7 @@ public async void CanHandleConnectionTimeout()
 			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
 			Assert.Equal(message1, response.Data.AddMessage.Content);
 
-			tester.ShouldHaveReceivedUpdate(gqlResponse =>
-			{
+			tester.ShouldHaveReceivedUpdate(gqlResponse => {
 				Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
 			});
 
@@ -302,17 +275,14 @@ public async void CanHandleConnectionTimeout()
 			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
 			Debug.WriteLine("web host stopped...");
 
-			callbackTester.CallbackShouldHaveBeenInvoked(exception =>
-			{
+			callbackTester.CallbackShouldHaveBeenInvoked(exception => {
 				Assert.IsType<WebSocketException>(exception);
 			}, TimeSpan.FromSeconds(10));
 
-			try
-			{
+			try {
 				server.Start();
 			}
-			catch (Exception e)
-			{
+			catch (Exception e) {
 				output.WriteLine($"failed to restart server: {e}");
 			}
 
@@ -321,13 +291,11 @@ public async void CanHandleConnectionTimeout()
 			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
 			server.Dispose();
 		}
-		
+
 		[Fact]
-		public void CanHandleSubscriptionError()
-		{
+		public void CanHandleSubscriptionError() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
@@ -341,8 +309,7 @@ public void CanHandleSubscriptionError()
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Single(gqlResponse.Errors);
 				});
 				tester.ShouldHaveCompleted();
@@ -352,13 +319,11 @@ public void CanHandleSubscriptionError()
 		}
 
 		[Fact]
-		public void CanHandleQueryErrorInSubscription()
-		{
+		public void CanHandleQueryErrorInSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port))
-			{
+			using (CreateServer(port)) {
 
-				var test = new GraphQLRequest("tset", new { test = "blaa"});
+				var test = new GraphQLRequest("tset", new { test = "blaa" });
 
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
@@ -373,8 +338,7 @@ public void CanHandleQueryErrorInSubscription()
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
-				tester.ShouldHaveReceivedUpdate(gqlResponse =>
-				{
+				tester.ShouldHaveReceivedUpdate(gqlResponse => {
 					Assert.Single(gqlResponse.Errors);
 				});
 				tester.ShouldHaveCompleted();
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
index 32b32e61..b2f7e765 100644
--- a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -2,13 +2,10 @@
 using GraphQL.Client.Http;
 using Microsoft.AspNetCore.Mvc.Testing;
 
-namespace GraphQL.Integration.Tests
-{
-	public static class WebApplicationFactoryExtensions
-	{
+namespace GraphQL.Integration.Tests {
+	public static class WebApplicationFactoryExtensions {
 		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
-			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint: class
-		{
+			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint : class {
 			var httpClient = factory.CreateClient();
 			var uriBuilder = new UriBuilder(httpClient.BaseAddress);
 			uriBuilder.Path = graphQlSchemaUrl;
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
index 0ca1dfbd..43895aec 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -1,42 +1,35 @@
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class ChatMutation : ObjectGraphType<object>
-    {
-        public ChatMutation(IChat chat)
-        {
-            Field<MessageType>("addMessage",
-                arguments: new QueryArguments(
-                    new QueryArgument<MessageInputType> {Name = "message"}
-                ),
-                resolve: context =>
-                {
-                    var receivedMessage = context.GetArgument<ReceivedMessage>("message");
-                    var message = chat.AddMessage(receivedMessage);
-                    return message;
-                });
+namespace IntegrationTestServer.ChatSchema {
+	public class ChatMutation : ObjectGraphType<object> {
+		public ChatMutation(IChat chat) {
+			Field<MessageType>("addMessage",
+				arguments: new QueryArguments(
+					new QueryArgument<MessageInputType> { Name = "message" }
+				),
+				resolve: context => {
+					var receivedMessage = context.GetArgument<ReceivedMessage>("message");
+					var message = chat.AddMessage(receivedMessage);
+					return message;
+				});
 
 			Field<MessageFromType>("join",
 				arguments: new QueryArguments(
 					new QueryArgument<StringGraphType> { Name = "userId" }
 				),
-				resolve: context =>
-				{
+				resolve: context => {
 					var userId = context.GetArgument<string>("userId");
 					var userJoined = chat.Join(userId);
 					return userJoined;
 				});
 		}
-    }
+	}
 
-    public class MessageInputType : InputObjectGraphType
-    {
-        public MessageInputType()
-        {
-            Field<StringGraphType>("fromId");
-            Field<StringGraphType>("content");
-            Field<DateGraphType>("sentAt");
-        }
-    }
+	public class MessageInputType : InputObjectGraphType {
+		public MessageInputType() {
+			Field<StringGraphType>("fromId");
+			Field<StringGraphType>("content");
+			Field<DateGraphType>("sentAt");
+		}
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
index 579c364f..6620c19c 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
@@ -1,13 +1,10 @@
 using System.Linq;
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class ChatQuery : ObjectGraphType
-    {
-        public ChatQuery(IChat chat)
-        {
-            Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
-        }
-    }
+namespace IntegrationTestServer.ChatSchema {
+	public class ChatQuery : ObjectGraphType {
+		public ChatQuery(IChat chat) {
+			Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+		}
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
index 904623a2..3878bcf5 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
@@ -1,14 +1,11 @@
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class ChatSchema : Schema
-    {
-        public ChatSchema(IChat chat) 
-        {
-            Query = new ChatQuery(chat);
-            Mutation = new ChatMutation(chat);
-            Subscription = new ChatSubscriptions(chat);
-        }
-    }
+namespace IntegrationTestServer.ChatSchema {
+	public class ChatSchema : Schema {
+		public ChatSchema(IChat chat) {
+			Query = new ChatQuery(chat);
+			Mutation = new ChatMutation(chat);
+			Subscription = new ChatSubscriptions(chat);
+		}
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 178d2b78..8f3c43ed 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -8,44 +8,37 @@
 using GraphQL.Subscription;
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class ChatSubscriptions : ObjectGraphType<object>
-    {
-        private readonly IChat _chat;
-
-        public ChatSubscriptions(IChat chat)
-        {
-            _chat = chat;
-            AddField(new EventStreamFieldType
-            {
-                Name = "messageAdded",
-                Type = typeof(MessageType),
-                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                Subscriber = new EventStreamResolver<Message>(Subscribe)
-            });
-
-			AddField(new EventStreamFieldType
-			{
+namespace IntegrationTestServer.ChatSchema {
+	public class ChatSubscriptions : ObjectGraphType<object> {
+		private readonly IChat _chat;
+
+		public ChatSubscriptions(IChat chat) {
+			_chat = chat;
+			AddField(new EventStreamFieldType {
+				Name = "messageAdded",
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(Subscribe)
+			});
+
+			AddField(new EventStreamFieldType {
 				Name = "contentAdded",
 				Type = typeof(MessageType),
 				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
 				Subscriber = new EventStreamResolver<Message>(Subscribe)
 			});
 
-			AddField(new EventStreamFieldType
-            {
-                Name = "messageAddedByUser",
-                Arguments = new QueryArguments(
-                    new QueryArgument<NonNullGraphType<StringGraphType>> {Name = "id"}
-                ),
-                Type = typeof(MessageType),
-                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                Subscriber = new EventStreamResolver<Message>(SubscribeById)
-            });
-
-			AddField(new EventStreamFieldType
-			{
+			AddField(new EventStreamFieldType {
+				Name = "messageAddedByUser",
+				Arguments = new QueryArguments(
+					new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id" }
+				),
+				Type = typeof(MessageType),
+				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+				Subscriber = new EventStreamResolver<Message>(SubscribeById)
+			});
+
+			AddField(new EventStreamFieldType {
 				Name = "userJoined",
 				Type = typeof(MessageFromType),
 				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
@@ -53,8 +46,7 @@ public ChatSubscriptions(IChat chat)
 			});
 
 
-			AddField(new EventStreamFieldType
-			{
+			AddField(new EventStreamFieldType {
 				Name = "failImmediately",
 				Type = typeof(MessageType),
 				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
@@ -62,38 +54,35 @@ public ChatSubscriptions(IChat chat)
 			});
 		}
 
-        private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
-        {
-            var messageContext = context.UserContext.As<MessageHandlingContext>();
-            var user = messageContext.Get<ClaimsPrincipal>("user");
+		private IObservable<Message> SubscribeById(ResolveEventStreamContext context) {
+			var messageContext = context.UserContext.As<MessageHandlingContext>();
+			var user = messageContext.Get<ClaimsPrincipal>("user");
 
-            var sub = "Anonymous";
-            if (user != null)
-                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+			var sub = "Anonymous";
+			if (user != null)
+				sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
 
-            var messages = _chat.Messages(sub);
+			var messages = _chat.Messages(sub);
 
-            var id = context.GetArgument<string>("id");
-            return messages.Where(message => message.From.Id == id);
-        }
+			var id = context.GetArgument<string>("id");
+			return messages.Where(message => message.From.Id == id);
+		}
 
-        private Message ResolveMessage(ResolveFieldContext context)
-        {
-            var message = context.Source as Message;
+		private Message ResolveMessage(ResolveFieldContext context) {
+			var message = context.Source as Message;
 
-            return message;
-        }
+			return message;
+		}
 
-        private IObservable<Message> Subscribe(ResolveEventStreamContext context)
-        {
-            var messageContext = context.UserContext.As<MessageHandlingContext>();
-            var user = messageContext.Get<ClaimsPrincipal>("user");
+		private IObservable<Message> Subscribe(ResolveEventStreamContext context) {
+			var messageContext = context.UserContext.As<MessageHandlingContext>();
+			var user = messageContext.Get<ClaimsPrincipal>("user");
 
-            var sub = "Anonymous";
-            if (user != null)
-                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+			var sub = "Anonymous";
+			if (user != null)
+				sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
 
-            return _chat.Messages(sub);
-        }
-    }
+			return _chat.Messages(sub);
+		}
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
index e52c0432..ef1bd08f 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -3,13 +3,11 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public interface IChat
-    {
-        ConcurrentStack<Message> AllMessages { get; }
+namespace IntegrationTestServer.ChatSchema {
+	public interface IChat {
+		ConcurrentStack<Message> AllMessages { get; }
 
-        Message AddMessage(Message message);
+		Message AddMessage(Message message);
 
 		MessageFrom Join(string userId);
 
@@ -17,57 +15,47 @@ public interface IChat
 		IObservable<MessageFrom> UserJoined();
 
 		Message AddMessage(ReceivedMessage message);
-    }
+	}
 
-    public class Chat : IChat
-    {
-        private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+	public class Chat : IChat {
+		private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
 		private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
-		public Chat()
-        {
-            AllMessages = new ConcurrentStack<Message>();
-            Users = new ConcurrentDictionary<string, string>
-            {
-                ["1"] = "developer",
-                ["2"] = "tester"
-            };
-        }
-
-        public ConcurrentDictionary<string, string> Users { get; set; }
-
-        public ConcurrentStack<Message> AllMessages { get; }
-
-        public Message AddMessage(ReceivedMessage message)
-        {
-            if (!Users.TryGetValue(message.FromId, out var displayName))
-            {
-                displayName = "(unknown)";
-            }
-
-            return AddMessage(new Message
-            {
-                Content = message.Content,
-                SentAt = message.SentAt,
-                From = new MessageFrom
-                {
-                    DisplayName = displayName,
-                    Id = message.FromId
-                }
-            });
-        }
-
-        public Message AddMessage(Message message)
-        {
-            AllMessages.Push(message);
-            _messageStream.OnNext(message);
-            return message;
+		public Chat() {
+			AllMessages = new ConcurrentStack<Message>();
+			Users = new ConcurrentDictionary<string, string> {
+				["1"] = "developer",
+				["2"] = "tester"
+			};
 		}
 
-		public MessageFrom Join(string userId)
-		{
-			if (!Users.TryGetValue(userId, out var displayName))
-			{
+		public ConcurrentDictionary<string, string> Users { get; set; }
+
+		public ConcurrentStack<Message> AllMessages { get; }
+
+		public Message AddMessage(ReceivedMessage message) {
+			if (!Users.TryGetValue(message.FromId, out var displayName)) {
+				displayName = "(unknown)";
+			}
+
+			return AddMessage(new Message {
+				Content = message.Content,
+				SentAt = message.SentAt,
+				From = new MessageFrom {
+					DisplayName = displayName,
+					Id = message.FromId
+				}
+			});
+		}
+
+		public Message AddMessage(Message message) {
+			AllMessages.Push(message);
+			_messageStream.OnNext(message);
+			return message;
+		}
+
+		public MessageFrom Join(string userId) {
+			if (!Users.TryGetValue(userId, out var displayName)) {
 				displayName = "(unknown)";
 			}
 
@@ -80,30 +68,25 @@ public MessageFrom Join(string userId)
 			return joinedUser;
 		}
 
-		public IObservable<Message> Messages(string user)
-        {
-            return _messageStream
-                .Select(message =>
-                {
-                    message.Sub = user;
-                    return message;
-                })
-                .AsObservable();
-        }
-
-        public void AddError(Exception exception)
-        {
-            _messageStream.OnError(exception);
-        }
-
-		public IObservable<MessageFrom> UserJoined()
-		{
+		public IObservable<Message> Messages(string user) {
+			return _messageStream
+				.Select(message => {
+					message.Sub = user;
+					return message;
+				})
+				.AsObservable();
+		}
+
+		public void AddError(Exception exception) {
+			_messageStream.OnError(exception);
+		}
+
+		public IObservable<MessageFrom> UserJoined() {
 			return _userJoined.AsObservable();
 		}
 	}
 
-	public class User
-	{
+	public class User {
 		public string Id { get; set; }
 		public string Name { get; set; }
 	}
diff --git a/tests/IntegrationTestServer/ChatSchema/Message.cs b/tests/IntegrationTestServer/ChatSchema/Message.cs
index f3b90cb1..93451aaa 100644
--- a/tests/IntegrationTestServer/ChatSchema/Message.cs
+++ b/tests/IntegrationTestServer/ChatSchema/Message.cs
@@ -1,15 +1,13 @@
 using System;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class Message
-    {
-        public MessageFrom From { get; set; }
+namespace IntegrationTestServer.ChatSchema {
+	public class Message {
+		public MessageFrom From { get; set; }
 
-        public string Sub { get; set; }
+		public string Sub { get; set; }
 
-        public string Content { get; set; }
+		public string Content { get; set; }
 
-        public DateTime SentAt { get; set; }
-    }
+		public DateTime SentAt { get; set; }
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
index 5346cb6b..8dff8852 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
@@ -1,9 +1,7 @@
-namespace IntegrationTestServer.ChatSchema
-{
-    public class MessageFrom
-    {
-        public string Id { get; set; }
+namespace IntegrationTestServer.ChatSchema {
+	public class MessageFrom {
+		public string Id { get; set; }
 
-        public string DisplayName { get; set; }
-    }
+		public string DisplayName { get; set; }
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
index 98830475..da243ee9 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
@@ -1,13 +1,10 @@
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class MessageFromType : ObjectGraphType<MessageFrom>
-    {
-        public MessageFromType()
-        {
-            Field(o => o.Id);
-            Field(o => o.DisplayName);
-        }
-    }
+namespace IntegrationTestServer.ChatSchema {
+	public class MessageFromType : ObjectGraphType<MessageFrom> {
+		public MessageFromType() {
+			Field(o => o.Id);
+			Field(o => o.DisplayName);
+		}
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageType.cs b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
index 320f5b55..6740189a 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageType.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
@@ -1,21 +1,17 @@
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class MessageType : ObjectGraphType<Message>
-    {
-        public MessageType()
-        {
-            Field(o => o.Content);
-            Field(o => o.SentAt);
-            Field(o => o.Sub);
-            Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
-        }
+namespace IntegrationTestServer.ChatSchema {
+	public class MessageType : ObjectGraphType<Message> {
+		public MessageType() {
+			Field(o => o.Content);
+			Field(o => o.SentAt);
+			Field(o => o.Sub);
+			Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
+		}
 
-        private MessageFrom ResolveFrom(ResolveFieldContext<Message> context)
-        {
-            var message = context.Source;
-            return message.From;
-        }
-    }
+		private MessageFrom ResolveFrom(ResolveFieldContext<Message> context) {
+			var message = context.Source;
+			return message.From;
+		}
+	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
index 0f1a409a..a3d9025b 100644
--- a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
@@ -1,13 +1,11 @@
 using System;
 
-namespace IntegrationTestServer.ChatSchema
-{
-    public class ReceivedMessage
-    {
-        public string FromId { get; set; }
+namespace IntegrationTestServer.ChatSchema {
+	public class ReceivedMessage {
+		public string FromId { get; set; }
 
-        public string Content { get; set; }
+		public string Content { get; set; }
 
-        public DateTime SentAt { get; set; }
-    }
+		public DateTime SentAt { get; set; }
+	}
 }
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index 9b0392b7..ec3530e1 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -2,18 +2,15 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Logging;
 
-namespace IntegrationTestServer
-{
-	public class Program
-	{
-		public static void Main(string[] args)
-		{
+namespace IntegrationTestServer {
+	public class Program {
+		public static void Main(string[] args) {
 			CreateWebHostBuilder(args).Build().Run();
 		}
 
 		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
 			WebHost.CreateDefaultBuilder(args)
 				.UseStartup<Startup>()
-			    .ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
+				.ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 	}
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 166bf202..f51f3482 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -8,12 +8,9 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace IntegrationTestServer
-{
-	public class Startup
-	{
-		public Startup(IConfiguration configuration, IHostingEnvironment environment)
-		{
+namespace IntegrationTestServer {
+	public class Startup {
+		public Startup(IConfiguration configuration, IHostingEnvironment environment) {
 			Configuration = configuration;
 			Environment = environment;
 		}
@@ -23,8 +20,7 @@ public Startup(IConfiguration configuration, IHostingEnvironment environment)
 
 		// This method gets called by the runtime. Use this method to add services to the container.
 		// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
-		public void ConfigureServices(IServiceCollection services)
-		{
+		public void ConfigureServices(IServiceCollection services) {
 			services.AddSingleton<IChat, Chat>();
 			services.AddSingleton<ChatSchema.ChatSchema>();
 			services.AddSingleton<ChatQuery>();
@@ -33,39 +29,33 @@ public void ConfigureServices(IServiceCollection services)
 			services.AddSingleton<MessageType>();
 			services.AddSingleton<MessageInputType>();
 
-			services.AddGraphQL(options =>
-				{
-					options.EnableMetrics = true;
-					options.ExposeExceptions = Environment.IsDevelopment();
-				})
+			services.AddGraphQL(options => {
+				options.EnableMetrics = true;
+				options.ExposeExceptions = Environment.IsDevelopment();
+			})
 				.AddWebSockets();
 
 			services.AddMvc();
 		}
 
 		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
-		public void Configure(IApplicationBuilder app, IHostingEnvironment env)
-		{
-			if (env.IsDevelopment())
-			{
+		public void Configure(IApplicationBuilder app, IHostingEnvironment env) {
+			if (env.IsDevelopment()) {
 				app.UseDeveloperExceptionPage();
 			}
 
 			app.UseWebSockets();
 			app.UseGraphQLWebSockets<ChatSchema.ChatSchema>("/graphql");
 			app.UseGraphQL<ChatSchema.ChatSchema>("/graphql");
-			app.UseGraphiQLServer(new GraphiQLOptions
-			{
+			app.UseGraphiQLServer(new GraphiQLOptions {
 				GraphiQLPath = "/ui/graphiql",
 				GraphQLEndPoint = "/graphql"
 			});
-			app.UseGraphQLVoyager(new GraphQLVoyagerOptions()
-			{
+			app.UseGraphQLVoyager(new GraphQLVoyagerOptions() {
 				GraphQLEndPoint = "/graphql",
 				Path = "/ui/voyager"
 			});
-			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
-			{
+			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions {
 				Path = "/ui/playground"
 			});
 			app.UseMvc();

From aa047cec61cd6835d987dc378b9c28939bcfed72 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 12:32:00 +0100
Subject: [PATCH 052/455] add BOM to files to enforce utf-8 encoding

---
 .editorconfig                                                  | 2 +-
 examples/GraphQL.Client.Http.Examples/Program.cs               | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpClient.cs                   | 3 +--
 src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs            | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpException.cs                | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpRequest.cs                  | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpResponse.cs                 | 2 +-
 src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs      | 2 +-
 src/GraphQL.Client.Http/GraphQLSubscriptionException.cs        | 2 +-
 src/GraphQL.Client.Http/HttpClientExtensions.cs                | 2 +-
 src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs      | 2 +-
 .../Websocket/GraphQLHttpWebsocketHelpers.cs                   | 2 +-
 .../Websocket/GraphQLWebSocketMessageType.cs                   | 2 +-
 src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs   | 2 +-
 src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs  | 2 +-
 src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs  | 2 +-
 src/GraphQL.Client/GraphQLClientExtensions.cs                  | 2 +-
 src/GraphQL.Client/GraphQLException.cs                         | 2 +-
 src/GraphQL.Client/GraphQLResponse.cs                          | 2 +-
 src/GraphQL.Client/IGraphQLClient.cs                           | 2 +-
 tests/GraphQL.Client.Http.Tests/BaseTest.cs                    | 2 +-
 tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs      | 2 +-
 tests/GraphQL.Client.Tests/GraphQLLocationTest.cs              | 2 +-
 tests/GraphQL.Client.Tests/GraphQLRequestTest.cs               | 2 +-
 tests/GraphQL.Client.Tests/GraphQLResponseTest.cs              | 2 +-
 tests/GraphQL.Client.Tests/Model/Person.cs                     | 2 +-
 tests/GraphQL.Integration.Tests/CallbackTester.cs              | 2 +-
 tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs | 2 +-
 tests/GraphQL.Integration.Tests/NetworkHelpers.cs              | 2 +-
 tests/GraphQL.Integration.Tests/ObservableTester.cs            | 2 +-
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs           | 2 +-
 .../WebApplicationFactoryExtensions.cs                         | 2 +-
 tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs         | 2 +-
 tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs         | 2 +-
 tests/GraphQL.Server.Test/GraphQL/Storage.cs                   | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestMutation.cs              | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestQuery.cs                 | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestSchema.cs                | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs          | 2 +-
 tests/GraphQL.Server.Test/Program.cs                           | 2 +-
 tests/GraphQL.Server.Test/Startup.cs                           | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatMutation.cs         | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatQuery.cs            | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatSchema.cs           | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs    | 2 +-
 tests/IntegrationTestServer/ChatSchema/IChat.cs                | 2 +-
 tests/IntegrationTestServer/ChatSchema/Message.cs              | 2 +-
 tests/IntegrationTestServer/ChatSchema/MessageFrom.cs          | 2 +-
 tests/IntegrationTestServer/ChatSchema/MessageFromType.cs      | 2 +-
 tests/IntegrationTestServer/ChatSchema/MessageType.cs          | 2 +-
 tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs      | 2 +-
 tests/IntegrationTestServer/Program.cs                         | 2 +-
 tests/IntegrationTestServer/Startup.cs                         | 2 +-
 53 files changed, 53 insertions(+), 54 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index d8898a08..f542d676 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -3,7 +3,7 @@ root = true
 
 # Default Code Style
 [*]
-charset = utf-8
+charset = utf-8-bom
 end_of_line = lf
 indent_size = 4
 indent_style = tab
diff --git a/examples/GraphQL.Client.Http.Examples/Program.cs b/examples/GraphQL.Client.Http.Examples/Program.cs
index 0cce0283..9bd760a9 100644
--- a/examples/GraphQL.Client.Http.Examples/Program.cs
+++ b/examples/GraphQL.Client.Http.Examples/Program.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Text.Json;
 using System.Threading.Tasks;
 using GraphQL.Server.Test.GraphQL.Models;
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 27eb27d8..f7c4395a 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -1,9 +1,8 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Net.Http;
 using System.Net.WebSockets;
 using System.Text;
-using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Websocket;
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index bf0502dc..39d56e84 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
diff --git a/src/GraphQL.Client.Http/GraphQLHttpException.cs b/src/GraphQL.Client.Http/GraphQLHttpException.cs
index b40807ca..b55ea615 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpException.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpException.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net.Http;
 
 namespace GraphQL.Client.Http {
diff --git a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
index 635d8da7..f6a7de77 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http {
 
 	public class GraphQLHttpRequest : GraphQLRequest {
 	}
diff --git a/src/GraphQL.Client.Http/GraphQLHttpResponse.cs b/src/GraphQL.Client.Http/GraphQLHttpResponse.cs
index 1e7c8424..50071ce5 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpResponse.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http {
 
 	public class GraphQLHttpResponse<T> : GraphQLResponse<T> {
 	}
diff --git a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
index a0a6d271..c5838e58 100644
--- a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
+++ b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
index 8607c5be..902edef7 100644
--- a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.Serialization;
 
 namespace GraphQL.Client.Http {
diff --git a/src/GraphQL.Client.Http/HttpClientExtensions.cs b/src/GraphQL.Client.Http/HttpClientExtensions.cs
index 7e78cae3..c73a6b71 100644
--- a/src/GraphQL.Client.Http/HttpClientExtensions.cs
+++ b/src/GraphQL.Client.Http/HttpClientExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net.Http;
 
 namespace GraphQL.Client.Http {
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
index 7678cc59..ef439eb9 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.IO;
 using System.Net.WebSockets;
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index 4f357a3e..3b782514 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
index 755a075b..547295e7 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http.Websocket {
+namespace GraphQL.Client.Http.Websocket {
 	public static class GraphQLWebSocketMessageType {
 
 		/// <summary>
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
index 8bcdb7b6..ea7f39de 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
index 9d791cfc..1f5cce64 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace GraphQL.Client.Http.Websocket {
diff --git a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
index fe237889..61f31b77 100644
--- a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
+++ b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
@@ -1,4 +1,4 @@
-using System.Text.Json.Serialization;
+using System.Text.Json.Serialization;
 
 namespace GraphQL.Client.Http.Websocket {
 	public class WebsocketResponseWrapper : GraphQLWebSocketResponse {
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client/GraphQLClientExtensions.cs
index a452560c..cbbb0b99 100644
--- a/src/GraphQL.Client/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLClientExtensions.cs
@@ -1,4 +1,4 @@
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client {
diff --git a/src/GraphQL.Client/GraphQLException.cs b/src/GraphQL.Client/GraphQLException.cs
index 613ab2ac..1966c027 100644
--- a/src/GraphQL.Client/GraphQLException.cs
+++ b/src/GraphQL.Client/GraphQLException.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace GraphQL.Client {
 
diff --git a/src/GraphQL.Client/GraphQLResponse.cs b/src/GraphQL.Client/GraphQLResponse.cs
index 81c163d5..9316427c 100644
--- a/src/GraphQL.Client/GraphQLResponse.cs
+++ b/src/GraphQL.Client/GraphQLResponse.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 59483ac5..5cadd56b 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/tests/GraphQL.Client.Http.Tests/BaseTest.cs b/tests/GraphQL.Client.Http.Tests/BaseTest.cs
index ba47cdea..0832498f 100644
--- a/tests/GraphQL.Client.Http.Tests/BaseTest.cs
+++ b/tests/GraphQL.Client.Http.Tests/BaseTest.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using Microsoft.AspNetCore.TestHost;
 
 namespace GraphQL.Client.Http.Tests {
diff --git a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
index 21a659fe..cef3c91b 100644
--- a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
@@ -1,4 +1,4 @@
-using System.Globalization;
+using System.Globalization;
 using Xunit;
 using System.Text.Json;
 
diff --git a/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs b/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs
index 468d521e..59f54793 100644
--- a/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Client.Tests {
 
diff --git a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
index c3a22357..78ed4bcf 100644
--- a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Client.Tests {
 
diff --git a/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
index fc792a1d..2ee883e8 100644
--- a/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Client.Tests {
 
diff --git a/tests/GraphQL.Client.Tests/Model/Person.cs b/tests/GraphQL.Client.Tests/Model/Person.cs
index 23b86a43..f0b81fca 100644
--- a/tests/GraphQL.Client.Tests/Model/Person.cs
+++ b/tests/GraphQL.Client.Tests/Model/Person.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Tests.Model {
+namespace GraphQL.Client.Tests.Model {
 
 	public class Person {
 
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
index 936543ce..c451b3a2 100644
--- a/tests/GraphQL.Integration.Tests/CallbackTester.cs
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
index 1a187011..0273d225 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using GraphQL.Client;
 using GraphQL.Client.Http;
diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
index c917deee..9c794056 100644
--- a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
@@ -1,4 +1,4 @@
-using System.Net;
+using System.Net;
 using System.Net.Sockets;
 
 namespace GraphQL.Integration.Tests {
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index 611c250d..6d484aa7 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 70fc16e9..8f52424b 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
index b2f7e765..76df07ae 100644
--- a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using GraphQL.Client.Http;
 using Microsoft.AspNetCore.Mvc.Testing;
 
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
index 3b13b068..3658472e 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Primitives.Tests {
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
index 15889373..040db5b5 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL.Models {
diff --git a/tests/GraphQL.Server.Test/GraphQL/Storage.cs b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
index 175390db..e79d16e9 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Storage.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using GraphQL.Server.Test.GraphQL.Models;
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
index 07e801e4..1acdcc9b 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL {
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index 1950c967..036a5a68 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 using GraphQL.Server.Test.GraphQL.Models;
 using GraphQL.Types;
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
index 1457cf03..1bd54ecd 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL {
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
index c85a14ce..e305dd92 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL {
 
diff --git a/tests/GraphQL.Server.Test/Program.cs b/tests/GraphQL.Server.Test/Program.cs
index 29155449..765b4ba4 100644
--- a/tests/GraphQL.Server.Test/Program.cs
+++ b/tests/GraphQL.Server.Test/Program.cs
@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index f2b257c1..e4534552 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -1,4 +1,4 @@
-using GraphQL.Server.Test.GraphQL;
+using GraphQL.Server.Test.GraphQL;
 using GraphQL.Server.Ui.GraphiQL;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
index 43895aec..92ca4338 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class ChatMutation : ObjectGraphType<object> {
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
index 6620c19c..104184b4 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
index 3878bcf5..eb4e96ca 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class ChatSchema : Schema {
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 8f3c43ed..18e5f74b 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Reactive.Linq;
 using System.Security.Claims;
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
index ef1bd08f..71741ece 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
diff --git a/tests/IntegrationTestServer/ChatSchema/Message.cs b/tests/IntegrationTestServer/ChatSchema/Message.cs
index 93451aaa..78777e8b 100644
--- a/tests/IntegrationTestServer/ChatSchema/Message.cs
+++ b/tests/IntegrationTestServer/ChatSchema/Message.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class Message {
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
index 8dff8852..783b5314 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
@@ -1,4 +1,4 @@
-namespace IntegrationTestServer.ChatSchema {
+namespace IntegrationTestServer.ChatSchema {
 	public class MessageFrom {
 		public string Id { get; set; }
 
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
index da243ee9..ec2b2bf9 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class MessageFromType : ObjectGraphType<MessageFrom> {
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageType.cs b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
index 6740189a..07be6967 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageType.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class MessageType : ObjectGraphType<Message> {
diff --git a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
index a3d9025b..aadf87ed 100644
--- a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class ReceivedMessage {
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index ec3530e1..0141976b 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,4 +1,4 @@
-using Microsoft.AspNetCore;
+using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Logging;
 
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index f51f3482..d8aa937a 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,4 +1,4 @@
-using GraphQL.Server;
+using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
 using GraphQL.Server.Ui.Playground;

From ef34264b630171387e827568f6b20972aeb11612 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 12:38:03 +0100
Subject: [PATCH 053/455] remove bom, skip dotnet format in workflow

---
 .editorconfig                                                   | 2 +-
 .github/workflows/workflow.yml                                  | 2 +-
 examples/GraphQL.Client.Http.Examples/Program.cs                | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpClient.cs                    | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs             | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpException.cs                 | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpRequest.cs                   | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpResponse.cs                  | 2 +-
 src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs       | 2 +-
 src/GraphQL.Client.Http/GraphQLSubscriptionException.cs         | 2 +-
 src/GraphQL.Client.Http/HttpClientExtensions.cs                 | 2 +-
 src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs       | 2 +-
 .../Websocket/GraphQLHttpWebsocketHelpers.cs                    | 2 +-
 .../Websocket/GraphQLWebSocketMessageType.cs                    | 2 +-
 src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs    | 2 +-
 src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs   | 2 +-
 src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs   | 2 +-
 src/GraphQL.Client/GraphQLClientExtensions.cs                   | 2 +-
 src/GraphQL.Client/GraphQLException.cs                          | 2 +-
 src/GraphQL.Client/GraphQLResponse.cs                           | 2 +-
 src/GraphQL.Client/IGraphQLClient.cs                            | 2 +-
 tests/GraphQL.Client.Http.Tests/BaseTest.cs                     | 2 +-
 tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs       | 2 +-
 tests/GraphQL.Client.Tests/GraphQLLocationTest.cs               | 2 +-
 tests/GraphQL.Client.Tests/GraphQLRequestTest.cs                | 2 +-
 tests/GraphQL.Client.Tests/GraphQLResponseTest.cs               | 2 +-
 tests/GraphQL.Client.Tests/Model/Person.cs                      | 2 +-
 tests/GraphQL.Integration.Tests/CallbackTester.cs               | 2 +-
 tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs  | 2 +-
 tests/GraphQL.Integration.Tests/NetworkHelpers.cs               | 2 +-
 tests/GraphQL.Integration.Tests/ObservableTester.cs             | 2 +-
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs            | 2 +-
 .../WebApplicationFactoryExtensions.cs                          | 2 +-
 tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs          | 2 +-
 tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs          | 2 +-
 tests/GraphQL.Server.Test/GraphQL/Storage.cs                    | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestMutation.cs               | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestQuery.cs                  | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestSchema.cs                 | 2 +-
 tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs           | 2 +-
 tests/GraphQL.Server.Test/Program.cs                            | 2 +-
 tests/GraphQL.Server.Test/Startup.cs                            | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatMutation.cs          | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatQuery.cs             | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatSchema.cs            | 2 +-
 tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs     | 2 +-
 tests/IntegrationTestServer/ChatSchema/IChat.cs                 | 2 +-
 tests/IntegrationTestServer/ChatSchema/Message.cs               | 2 +-
 tests/IntegrationTestServer/ChatSchema/MessageFrom.cs           | 2 +-
 tests/IntegrationTestServer/ChatSchema/MessageFromType.cs       | 2 +-
 tests/IntegrationTestServer/ChatSchema/MessageType.cs           | 2 +-
 tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs       | 2 +-
 tests/IntegrationTestServer/Program.cs                          | 2 +-
 tests/IntegrationTestServer/Startup.cs                          | 2 +-
 54 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index f542d676..d8898a08 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -3,7 +3,7 @@ root = true
 
 # Default Code Style
 [*]
-charset = utf-8-bom
+charset = utf-8
 end_of_line = lf
 indent_size = 4
 indent_style = tab
diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index b12287b3..504c8f40 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -10,7 +10,7 @@ jobs:
       with:
         dotnet-version: '3.1.100'
     - run: dotnet tool restore
-    - run: dotnet format --check --dry-run
+#    - run: dotnet format --check --dry-run
     - run: dotnet restore
     - run: dotnet build
     - run: dotnet pack
diff --git a/examples/GraphQL.Client.Http.Examples/Program.cs b/examples/GraphQL.Client.Http.Examples/Program.cs
index 9bd760a9..0cce0283 100644
--- a/examples/GraphQL.Client.Http.Examples/Program.cs
+++ b/examples/GraphQL.Client.Http.Examples/Program.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Text.Json;
 using System.Threading.Tasks;
 using GraphQL.Server.Test.GraphQL.Models;
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index f7c4395a..f4cc6408 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Net.Http;
 using System.Net.WebSockets;
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index 39d56e84..bf0502dc 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
diff --git a/src/GraphQL.Client.Http/GraphQLHttpException.cs b/src/GraphQL.Client.Http/GraphQLHttpException.cs
index b55ea615..b40807ca 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpException.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpException.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net.Http;
 
 namespace GraphQL.Client.Http {
diff --git a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
index f6a7de77..635d8da7 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http {
 
 	public class GraphQLHttpRequest : GraphQLRequest {
 	}
diff --git a/src/GraphQL.Client.Http/GraphQLHttpResponse.cs b/src/GraphQL.Client.Http/GraphQLHttpResponse.cs
index 50071ce5..1e7c8424 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpResponse.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http {
 
 	public class GraphQLHttpResponse<T> : GraphQLResponse<T> {
 	}
diff --git a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
index c5838e58..a0a6d271 100644
--- a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
+++ b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
index 902edef7..8607c5be 100644
--- a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.Serialization;
 
 namespace GraphQL.Client.Http {
diff --git a/src/GraphQL.Client.Http/HttpClientExtensions.cs b/src/GraphQL.Client.Http/HttpClientExtensions.cs
index c73a6b71..7e78cae3 100644
--- a/src/GraphQL.Client.Http/HttpClientExtensions.cs
+++ b/src/GraphQL.Client.Http/HttpClientExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net.Http;
 
 namespace GraphQL.Client.Http {
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
index ef439eb9..7678cc59 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.IO;
 using System.Net.WebSockets;
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index 3b782514..4f357a3e 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
index 547295e7..755a075b 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http.Websocket {
+namespace GraphQL.Client.Http.Websocket {
 	public static class GraphQLWebSocketMessageType {
 
 		/// <summary>
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
index ea7f39de..8bcdb7b6 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
index 1f5cce64..9d791cfc 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 
 namespace GraphQL.Client.Http.Websocket {
diff --git a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
index 61f31b77..fe237889 100644
--- a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
+++ b/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
@@ -1,4 +1,4 @@
-using System.Text.Json.Serialization;
+using System.Text.Json.Serialization;
 
 namespace GraphQL.Client.Http.Websocket {
 	public class WebsocketResponseWrapper : GraphQLWebSocketResponse {
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client/GraphQLClientExtensions.cs
index cbbb0b99..a452560c 100644
--- a/src/GraphQL.Client/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLClientExtensions.cs
@@ -1,4 +1,4 @@
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client {
diff --git a/src/GraphQL.Client/GraphQLException.cs b/src/GraphQL.Client/GraphQLException.cs
index 1966c027..613ab2ac 100644
--- a/src/GraphQL.Client/GraphQLException.cs
+++ b/src/GraphQL.Client/GraphQLException.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace GraphQL.Client {
 
diff --git a/src/GraphQL.Client/GraphQLResponse.cs b/src/GraphQL.Client/GraphQLResponse.cs
index 9316427c..81c163d5 100644
--- a/src/GraphQL.Client/GraphQLResponse.cs
+++ b/src/GraphQL.Client/GraphQLResponse.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 5cadd56b..59483ac5 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/tests/GraphQL.Client.Http.Tests/BaseTest.cs b/tests/GraphQL.Client.Http.Tests/BaseTest.cs
index 0832498f..ba47cdea 100644
--- a/tests/GraphQL.Client.Http.Tests/BaseTest.cs
+++ b/tests/GraphQL.Client.Http.Tests/BaseTest.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using Microsoft.AspNetCore.TestHost;
 
 namespace GraphQL.Client.Http.Tests {
diff --git a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
index cef3c91b..21a659fe 100644
--- a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
@@ -1,4 +1,4 @@
-using System.Globalization;
+using System.Globalization;
 using Xunit;
 using System.Text.Json;
 
diff --git a/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs b/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs
index 59f54793..468d521e 100644
--- a/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Client.Tests {
 
diff --git a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
index 78ed4bcf..c3a22357 100644
--- a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Client.Tests {
 
diff --git a/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
index 2ee883e8..fc792a1d 100644
--- a/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
+++ b/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Client.Tests {
 
diff --git a/tests/GraphQL.Client.Tests/Model/Person.cs b/tests/GraphQL.Client.Tests/Model/Person.cs
index f0b81fca..23b86a43 100644
--- a/tests/GraphQL.Client.Tests/Model/Person.cs
+++ b/tests/GraphQL.Client.Tests/Model/Person.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Tests.Model {
+namespace GraphQL.Client.Tests.Model {
 
 	public class Person {
 
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/CallbackTester.cs
index c451b3a2..936543ce 100644
--- a/tests/GraphQL.Integration.Tests/CallbackTester.cs
+++ b/tests/GraphQL.Integration.Tests/CallbackTester.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
index 0273d225..1a187011 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using GraphQL.Client;
 using GraphQL.Client.Http;
diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
index 9c794056..c917deee 100644
--- a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
@@ -1,4 +1,4 @@
-using System.Net;
+using System.Net;
 using System.Net.Sockets;
 
 namespace GraphQL.Integration.Tests {
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index 6d484aa7..611c250d 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 8f52424b..70fc16e9 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
index 76df07ae..b2f7e765 100644
--- a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using GraphQL.Client.Http;
 using Microsoft.AspNetCore.Mvc.Testing;
 
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
index 3658472e..3b13b068 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
@@ -1,4 +1,4 @@
-using Xunit;
+using Xunit;
 
 namespace GraphQL.Primitives.Tests {
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
index 040db5b5..15889373 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL.Models {
diff --git a/tests/GraphQL.Server.Test/GraphQL/Storage.cs b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
index e79d16e9..175390db 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Storage.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using GraphQL.Server.Test.GraphQL.Models;
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
index 1acdcc9b..07e801e4 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL {
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index 036a5a68..1950c967 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 using GraphQL.Server.Test.GraphQL.Models;
 using GraphQL.Types;
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
index 1bd54ecd..1457cf03 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL {
 
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
index e305dd92..c85a14ce 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL {
 
diff --git a/tests/GraphQL.Server.Test/Program.cs b/tests/GraphQL.Server.Test/Program.cs
index 765b4ba4..29155449 100644
--- a/tests/GraphQL.Server.Test/Program.cs
+++ b/tests/GraphQL.Server.Test/Program.cs
@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index e4534552..f2b257c1 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -1,4 +1,4 @@
-using GraphQL.Server.Test.GraphQL;
+using GraphQL.Server.Test.GraphQL;
 using GraphQL.Server.Ui.GraphiQL;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
index 92ca4338..43895aec 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class ChatMutation : ObjectGraphType<object> {
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
index 104184b4..6620c19c 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
@@ -1,4 +1,4 @@
-using System.Linq;
+using System.Linq;
 using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
index eb4e96ca..3878bcf5 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class ChatSchema : Schema {
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
index 18e5f74b..8f3c43ed 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Reactive.Linq;
 using System.Security.Claims;
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
index 71741ece..ef1bd08f 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
diff --git a/tests/IntegrationTestServer/ChatSchema/Message.cs b/tests/IntegrationTestServer/ChatSchema/Message.cs
index 78777e8b..93451aaa 100644
--- a/tests/IntegrationTestServer/ChatSchema/Message.cs
+++ b/tests/IntegrationTestServer/ChatSchema/Message.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class Message {
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
index 783b5314..8dff8852 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
@@ -1,4 +1,4 @@
-namespace IntegrationTestServer.ChatSchema {
+namespace IntegrationTestServer.ChatSchema {
 	public class MessageFrom {
 		public string Id { get; set; }
 
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
index ec2b2bf9..da243ee9 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class MessageFromType : ObjectGraphType<MessageFrom> {
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageType.cs b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
index 07be6967..6740189a 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageType.cs
+++ b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
@@ -1,4 +1,4 @@
-using GraphQL.Types;
+using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class MessageType : ObjectGraphType<Message> {
diff --git a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
index aadf87ed..a3d9025b 100644
--- a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class ReceivedMessage {
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index 0141976b..ec3530e1 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,4 +1,4 @@
-using Microsoft.AspNetCore;
+using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Logging;
 
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index d8aa937a..f51f3482 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,4 +1,4 @@
-using GraphQL.Server;
+using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
 using GraphQL.Server.Ui.Playground;

From 216cb0055ea7af22f6f3112c181ffeaf4eb78f2c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 14:06:24 +0100
Subject: [PATCH 054/455] move integrationTest projects to netcoreapp3.1

---
 .../GraphQL.Integration.Tests.csproj                     | 4 ++--
 tests/GraphQL.Server.Test/libman.json                    | 5 +++++
 tests/IntegrationTestServer/Startup.cs                   | 9 +++++++--
 3 files changed, 14 insertions(+), 4 deletions(-)
 create mode 100644 tests/GraphQL.Server.Test/libman.json

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index becaa7d4..ee396921 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.5" />
+    <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="2.1.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />
diff --git a/tests/GraphQL.Server.Test/libman.json b/tests/GraphQL.Server.Test/libman.json
new file mode 100644
index 00000000..ceee2710
--- /dev/null
+++ b/tests/GraphQL.Server.Test/libman.json
@@ -0,0 +1,5 @@
+{
+  "version": "1.0",
+  "defaultProvider": "cdnjs",
+  "libraries": []
+}
\ No newline at end of file
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index f51f3482..88fa64f5 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -5,6 +5,7 @@
 using IntegrationTestServer.ChatSchema;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -21,6 +22,10 @@ public Startup(IConfiguration configuration, IHostingEnvironment environment) {
 		// This method gets called by the runtime. Use this method to add services to the container.
 		// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
 		public void ConfigureServices(IServiceCollection services) {
+			services.Configure<KestrelServerOptions>(options =>
+			{
+				options.AllowSynchronousIO = true;
+			});
 			services.AddSingleton<IChat, Chat>();
 			services.AddSingleton<ChatSchema.ChatSchema>();
 			services.AddSingleton<ChatQuery>();
@@ -35,7 +40,7 @@ public void ConfigureServices(IServiceCollection services) {
 			})
 				.AddWebSockets();
 
-			services.AddMvc();
+			//services.AddMvc();
 		}
 
 		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
@@ -58,7 +63,7 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env) {
 			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions {
 				Path = "/ui/playground"
 			});
-			app.UseMvc();
+			//app.UseMvc();
 		}
 	}
 }

From f1803db452f6e715d7dc2326ac298e3f32b7531b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 14:14:04 +0100
Subject: [PATCH 055/455] fix integration test framework dependencies

---
 .../GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj | 1 -
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs           | 3 ---
 2 files changed, 4 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index ee396921..191e1b31 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.App" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="2.1.3" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 70fc16e9..2d5f6b9e 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -35,8 +35,6 @@ public static IWebHost CreateServer(int port) {
 			return host;
 		}
 
-		private readonly IWebHost _server;
-
 		public SubscriptionsTest(ITestOutputHelper output) {
 			this.output = output;
 		}
@@ -78,7 +76,6 @@ public async void CanHandleRequestErrorViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port, true);
-				const string message = "some random testing message";
 				var response = await client.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
 
 				Assert.Single(response.Errors);

From 03afb40cbf79838016ac09383bca74a6ef52777e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 14:23:10 +0100
Subject: [PATCH 056/455] try to disable parallel test runs

---
 .github/workflows/workflow.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 504c8f40..efec9492 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -11,9 +11,9 @@ jobs:
         dotnet-version: '3.1.100'
     - run: dotnet tool restore
 #    - run: dotnet format --check --dry-run
-    - run: dotnet restore
+    # - run: dotnet restore
     - run: dotnet build
-    - run: dotnet pack
+    # - run: dotnet pack
 
   test:
     name: Test
@@ -24,9 +24,9 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - run: dotnet restore
-    - run: dotnet build
-    - run: dotnet test
+    # - run: dotnet restore
+    # - run: dotnet build
+    - run: dotnet test -p:ParallelizeTestCollections=false
 
   publish:
     name: Publish

From 48339b18ef4238ec68f75cde9b1515dbd20ad0b6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 14:39:09 +0100
Subject: [PATCH 057/455] cleanup workflow

---
 .github/workflows/workflow.yml | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index efec9492..d9311792 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -10,10 +10,7 @@ jobs:
       with:
         dotnet-version: '3.1.100'
     - run: dotnet tool restore
-#    - run: dotnet format --check --dry-run
-    # - run: dotnet restore
-    - run: dotnet build
-    # - run: dotnet pack
+    - run: dotnet build -c Release
 
   test:
     name: Test
@@ -24,9 +21,7 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    # - run: dotnet restore
-    # - run: dotnet build
-    - run: dotnet test -p:ParallelizeTestCollections=false
+    - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
   publish:
     name: Publish
@@ -37,8 +32,7 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - run: dotnet restore
-    - run: dotnet build --configuration Release
-    - run: dotnet pack --configuration Release
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key $GITHUB_TOKEN --source https://nuget.pkg.github.com/graphql-dotnet/graphql-client/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.*.nupkg --api-key $GITHUB_TOKEN --source https://nuget.pkg.github.com/graphql-dotnet/graphql-client/index.json
+    - run: dotnet pack -c Release
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"

From 332bdf1eec1b16e322c59e19e60b36ca7a8ffa40 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 14:48:39 +0100
Subject: [PATCH 058/455] use dotnet build to create packages

---
 .github/workflows/workflow.yml                                  | 2 +-
 .../GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index d9311792..8453d8c8 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -32,7 +32,7 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - run: dotnet pack -c Release
+    - run: dotnet build -c Release
     - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
     - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
     - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
diff --git a/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj b/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
index 3114fa2d..64ce8f5e 100644
--- a/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
+++ b/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
@@ -4,7 +4,7 @@
 
 	<PropertyGroup>
         <TargetFramework>netcoreapp3.1</TargetFramework>
-    </PropertyGroup>
+	</PropertyGroup>
 
     <ItemGroup>
 		<PackageReference Include="Microsoft.AspNetCore.TestHost" Version="3.1.0" />

From befedf8b6cff91171904f338e2e5158131377c16 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 14:55:52 +0100
Subject: [PATCH 059/455] fix nuget source

---
 .github/workflows/workflow.yml | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 8453d8c8..a24c43ec 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -27,12 +27,14 @@ jobs:
     name: Publish
     needs: test
     runs-on: ubuntu-latest
+    env:
+      SOURCE: https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json
     steps:
     - uses: actions/checkout@master
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
     - run: dotnet build -c Release
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "github"
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "$SOURCE"
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "$SOURCE"
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "$SOURCE"

From 2f793df682789913d2a242d953b53e10e960b110 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 15:01:04 +0100
Subject: [PATCH 060/455] fix environment vars

---
 .github/workflows/workflow.yml | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index a24c43ec..9672e140 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -27,14 +27,12 @@ jobs:
     name: Publish
     needs: test
     runs-on: ubuntu-latest
-    env:
-      SOURCE: https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json
     steps:
     - uses: actions/checkout@master
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
     - run: dotnet build -c Release
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "$SOURCE"
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "$SOURCE"
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "$SOURCE"
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json"
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json"
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json"

From ffd1f3ceadd5ef64e9ea2c4a868c1beba931570d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 15:12:54 +0100
Subject: [PATCH 061/455] restructure integration test

---
 .../GraphQL.Client.Http.csproj                |   8 -
 .../GraphQLHttpClient_SubscriptionApi.cs      | 216 ------------------
 .../GraphQLClientTestExtensions.cs            |   2 +-
 .../WebApplicationFactoryExtensions.cs        |   2 +-
 .../GraphQL.Integration.Tests.csproj          |   8 +-
 .../{ => Helpers}/CallbackTester.cs           |   2 +-
 .../{ => Helpers}/NetworkHelpers.cs           |   2 +-
 .../{ => Helpers}/ObservableTester.cs         |   2 +-
 .../SubscriptionsTest.cs                      |   2 +
 9 files changed, 11 insertions(+), 233 deletions(-)
 delete mode 100644 src/GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs
 rename tests/GraphQL.Integration.Tests/{ => Extensions}/GraphQLClientTestExtensions.cs (96%)
 rename tests/GraphQL.Integration.Tests/{ => Extensions}/WebApplicationFactoryExtensions.cs (92%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/CallbackTester.cs (98%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/NetworkHelpers.cs (85%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/ObservableTester.cs (98%)

diff --git a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
index adf84a10..05900a76 100644
--- a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
+++ b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
@@ -6,14 +6,6 @@
 		<TargetFramework>netstandard2.0</TargetFramework>
     </PropertyGroup>
 
-    <ItemGroup>
-      <Compile Remove="GraphQLHttpClient_SubscriptionApi.cs" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <None Include="GraphQLHttpClient_SubscriptionApi.cs" />
-    </ItemGroup>
-
     <ItemGroup>
       <ProjectReference Include="..\GraphQL.Client\GraphQL.Client.csproj" />
     </ItemGroup>
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs b/src/GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs
deleted file mode 100644
index 1d43a90a..00000000
--- a/src/GraphQL.Client.Http/GraphQLHttpClient_SubscriptionApi.cs
+++ /dev/null
@@ -1,216 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Net.Http;
-using System.Net.Http.Headers;
-using System.Net.WebSockets;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Client.Http.Internal;
-
-namespace GraphQL.Client.Http {
-
-	/// <summary>
-	/// A Client to access GraphQL EndPoints
-	/// </summary>
-	public class GraphQLHttpClient_SubscriptionApi : IGraphQLClient {
-
-		#region Properties
-
-		/// <summary>
-		/// Gets the headers which should be sent with each request.
-		/// </summary>
-		public HttpRequestHeaders DefaultRequestHeaders => this.graphQLHttpHandler.HttpClient.DefaultRequestHeaders;
-
-		/// <summary>
-		/// The GraphQL EndPoint to be used
-		/// </summary>
-		public Uri EndPoint {
-			get => this.Options.EndPoint;
-			set => this.Options.EndPoint = value;
-		}
-
-		/// <summary>
-		/// The Options	to be used
-		/// </summary>
-		public GraphQLHttpClientOptions Options {
-			get => this.graphQLHttpHandler.Options;
-			set => this.graphQLHttpHandler.Options = value;
-		}
-
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL")]
-		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
-
-		#endregion
-
-		internal readonly GraphQLHttpHandler graphQLHttpHandler;
-		internal readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
-		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
-
-		/// <summary>
-		/// Initializes a new instance
-		/// </summary>
-		/// <param name="endPoint">The EndPoint to be used</param>
-		public GraphQLHttpClient_SubscriptionApi(string endPoint) : this(new Uri(endPoint)) { }
-
-		/// <summary>
-		/// Initializes a new instance
-		/// </summary>
-		/// <param name="endPoint">The EndPoint to be used</param>
-		public GraphQLHttpClient_SubscriptionApi(Uri endPoint) : this(new GraphQLHttpClientOptions { EndPoint = endPoint }) { }
-
-		/// <summary>
-		/// Initializes a new instance
-		/// </summary>
-		/// <param name="endPoint">The EndPoint to be used</param>
-		/// <param name="options">The Options to be used</param>
-		public GraphQLHttpClient_SubscriptionApi(string endPoint, GraphQLHttpClientOptions options) : this(new Uri(endPoint), options) { }
-
-		/// <summary>
-		/// Initializes a new instance
-		/// </summary>
-		/// <param name="endPoint">The EndPoint to be used</param>
-		/// <param name="options">The Options to be used</param>
-		public GraphQLHttpClient_SubscriptionApi(Uri endPoint, GraphQLHttpClientOptions options) {
-
-			options.EndPoint = endPoint ?? throw new ArgumentNullException(nameof(endPoint));
-
-			if (options == null) { throw new ArgumentNullException(nameof(options)); }
-			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
-			if (options.HttpMessageHandler == null) { throw new ArgumentNullException(nameof(options.HttpMessageHandler)); }
-			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
-
-			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
-		}
-
-		/// <summary>
-		/// Initializes a new instance
-		/// </summary>
-		/// <param name="options">The Options to be used</param>
-		public GraphQLHttpClient_SubscriptionApi(GraphQLHttpClientOptions options) {
-			if (options == null) { throw new ArgumentNullException(nameof(options)); }
-			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
-			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
-			if (options.HttpMessageHandler == null) { throw new ArgumentNullException(nameof(options.HttpMessageHandler)); }
-			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
-
-			this.graphQLHttpHandler = new GraphQLHttpHandler(options);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
-		}
-
-		internal GraphQLHttpClient_SubscriptionApi(GraphQLHttpClientOptions options, HttpClient httpClient) {
-			if (options == null) { throw new ArgumentNullException(nameof(options)); }
-			if (options.EndPoint == null) { throw new ArgumentNullException(nameof(options.EndPoint)); }
-			if (options.JsonSerializerSettings == null) { throw new ArgumentNullException(nameof(options.JsonSerializerSettings)); }
-			if (options.HttpMessageHandler == null) { throw new ArgumentNullException(nameof(options.HttpMessageHandler)); }
-			if (options.MediaType == null) { throw new ArgumentNullException(nameof(options.MediaType)); }
-
-			this.graphQLHttpHandler = new GraphQLHttpHandler(options, httpClient);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(_getWebSocketUri(), options);
-		}
-
-		public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendQueryAsync(new GraphQLRequest(query), cancellationToken);
-
-		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
-		{
-			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
-				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
-		}
-
-		public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken cancellationToken = default) =>
-			this.SendMutationAsync(new GraphQLRequest(query), cancellationToken);
-
-		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
-		{
-			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
-				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
-		}
-		
-		private Uri _getWebSocketUri()
-		{
-			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
-			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
-		}
-
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
-		{
-			if (_disposed)
-				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
-			if (subscriptionStreams.ContainsKey(request))
-				return subscriptionStreams[request];
-
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
-
-			subscriptionStreams.TryAdd(request, observable);
-			return observable;
-		}
-
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
-		{
-			if (_disposed)
-				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-					   
-			return CreateSubscriptionStream(request, e =>
-			{
-				if (e is WebSocketException webSocketException)
-					webSocketExceptionHandler(webSocketException);
-				else
-					throw e;
-			});
-		}
-
-		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
-		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<Exception> exceptionHandler)
-		{
-			if (_disposed)
-				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
-			if(subscriptionStreams.ContainsKey(request))
-				return subscriptionStreams[request];
-
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
-			subscriptionStreams.TryAdd(request, observable);
-			return observable;
-		}
-
-		private ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
-
-		/// <summary>
-		/// Releases unmanaged resources
-		/// </summary>
-		public void Dispose()
-		{
-			lock (_disposeLocker)
-			{
-				if (!_disposed)
-				{
-					_dispose();
-				}
-			}
-		}
-
-		private bool _disposed = false;
-		private object _disposeLocker = new object();
-
-		private void _dispose()
-		{
-			_disposed = true;
-			this.graphQLHttpHandler.Dispose();
-			this.graphQlHttpWebSocket.Dispose();
-			_cancellationTokenSource.Cancel();
-			_cancellationTokenSource.Dispose();
-		}
-	}
-
-}
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
similarity index 96%
rename from tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
rename to tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
index 1a187011..f698b247 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientTestExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
@@ -3,7 +3,7 @@
 using GraphQL.Client;
 using GraphQL.Client.Http;
 
-namespace GraphQL.Integration.Tests {
+namespace GraphQL.Integration.Tests.Extensions {
 	public static class GraphQLClientTestExtensions {
 		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this GraphQLHttpClient client, string message) {
 			var graphQLRequest = new GraphQLRequest(
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
similarity index 92%
rename from tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
rename to tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
index b2f7e765..de4848fc 100644
--- a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
@@ -2,7 +2,7 @@
 using GraphQL.Client.Http;
 using Microsoft.AspNetCore.Mvc.Testing;
 
-namespace GraphQL.Integration.Tests {
+namespace GraphQL.Integration.Tests.Extensions {
 	public static class WebApplicationFactoryExtensions {
 		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
 			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint : class {
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 191e1b31..9848d12b 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,10 +7,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="2.1.3" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
-    <PackageReference Include="System.Reactive" Version="4.1.2" />
-    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="System.Reactive" Version="4.3.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
       <PrivateAssets>all</PrivateAssets>
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs
similarity index 98%
rename from tests/GraphQL.Integration.Tests/CallbackTester.cs
rename to tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs
index 936543ce..e0d46b5f 100644
--- a/tests/GraphQL.Integration.Tests/CallbackTester.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs
@@ -2,7 +2,7 @@
 using System.Threading;
 using Xunit;
 
-namespace GraphQL.Integration.Tests {
+namespace GraphQL.Integration.Tests.Helpers {
 	public class CallbackTester<T> {
 		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
 
diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs
similarity index 85%
rename from tests/GraphQL.Integration.Tests/NetworkHelpers.cs
rename to tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs
index c917deee..6995ee54 100644
--- a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs
@@ -1,7 +1,7 @@
 using System.Net;
 using System.Net.Sockets;
 
-namespace GraphQL.Integration.Tests {
+namespace GraphQL.Integration.Tests.Helpers {
 	public static class NetworkHelpers {
 		public static int GetFreeTcpPortNumber() {
 			var l = new TcpListener(IPAddress.Loopback, 0);
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
similarity index 98%
rename from tests/GraphQL.Integration.Tests/ObservableTester.cs
rename to tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
index 611c250d..5135e417 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
@@ -2,7 +2,7 @@
 using System.Threading;
 using Xunit;
 
-namespace GraphQL.Integration.Tests {
+namespace GraphQL.Integration.Tests.Helpers {
 	public class ObservableTester<T> : IDisposable {
 		private readonly IDisposable _subscription;
 		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 2d5f6b9e..d81d79c1 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -5,6 +5,8 @@
 using System.Threading.Tasks;
 using GraphQL.Client;
 using GraphQL.Client.Http;
+using GraphQL.Integration.Tests.Extensions;
+using GraphQL.Integration.Tests.Helpers;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;

From 2830197605811a39836409dac3e32178b472f0bf Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 15:19:17 +0100
Subject: [PATCH 062/455] use the GITHUB_REPOSITORY var instead og GITHUB_ACTOR

---
 .github/workflows/workflow.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 9672e140..b78702ee 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -33,6 +33,6 @@ jobs:
       with:
         dotnet-version: '3.1.100'
     - run: dotnet build -c Release
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json"
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json"
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source "https://nuget.pkg.github.com/$GITHUB_ACTOR/index.json"
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$GITHUB_REPOSITORY/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$GITHUB_REPOSITORY/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$GITHUB_REPOSITORY/index.json

From 4e3b7380e620bc2dcd69e40072fc2ca58b7f3a33 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 15:35:12 +0100
Subject: [PATCH 063/455] try windows runner

---
 .github/workflows/workflow.yml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index b78702ee..da13ecc5 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -3,7 +3,7 @@ on: [push]
 jobs:
   build:
     name: Build
-    runs-on: ubuntu-latest
+    runs-on: windows-latest
     steps:
     - uses: actions/checkout@master
     - uses: actions/setup-dotnet@master
@@ -15,7 +15,7 @@ jobs:
   test:
     name: Test
     needs: build
-    runs-on: ubuntu-latest
+    runs-on: windows-latest
     steps:
     - uses: actions/checkout@master
     - uses: actions/setup-dotnet@master
@@ -26,13 +26,13 @@ jobs:
   publish:
     name: Publish
     needs: test
-    runs-on: ubuntu-latest
+    runs-on: windows-latest
     steps:
     - uses: actions/checkout@master
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
     - run: dotnet build -c Release
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$GITHUB_REPOSITORY/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$GITHUB_REPOSITORY/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$GITHUB_REPOSITORY/index.json
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:GITHUB_REPOSITORY/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:GITHUB_REPOSITORY/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:GITHUB_REPOSITORY/index.json

From f310af2534346f096774b8c1c514f153682849b4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 15:55:36 +0100
Subject: [PATCH 064/455] try user/password variant

---
 .github/workflows/workflow.yml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index da13ecc5..05732b4d 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -32,7 +32,8 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
+    - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
     - run: dotnet build -c Release
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:GITHUB_REPOSITORY/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:GITHUB_REPOSITORY/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --api-key ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:GITHUB_REPOSITORY/index.json
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json

From 6735a9e572db7c432c99ae0e67289ae9ec71a169 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 16:19:11 +0100
Subject: [PATCH 065/455] exclude publish job

---
 .github/workflows/workflow.yml | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 05732b4d..08a46941 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -23,17 +23,17 @@ jobs:
         dotnet-version: '3.1.100'
     - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
-  publish:
-    name: Publish
-    needs: test
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@master
-    - uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
-    - run: dotnet build -c Release
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
+  # publish:
+  #   name: Publish
+  #   needs: test
+  #   runs-on: windows-latest
+  #   steps:
+  #   - uses: actions/checkout@master
+  #   - uses: actions/setup-dotnet@master
+  #     with:
+  #       dotnet-version: '3.1.100'
+  #   - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
+  #   - run: dotnet build -c Release
+  #   - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
+  #   - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
+  #   - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json

From 5fb73e269f88885e5a0e5dd789ac11ade65e42be Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 16:46:01 +0100
Subject: [PATCH 066/455] cleanup IGraphQLClient

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  | 21 ++-----------
 .../GraphQLHttpClientExtensions.cs            | 31 +++++++++++++++++++
 src/GraphQL.Client/GraphQLClientExtensions.cs | 27 ++++++++++++++--
 src/GraphQL.Client/IGraphQLClient.cs          | 18 ++---------
 4 files changed, 61 insertions(+), 36 deletions(-)
 create mode 100644 src/GraphQL.Client.Http/GraphQLHttpClientExtensions.cs

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index f4cc6408..71ca2568 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -48,15 +48,13 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
-		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null,
-			CancellationToken cancellationToken = default) {
+		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
 				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
 				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
-		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null,
-			CancellationToken cancellationToken = default) {
+		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
 				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
 				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
@@ -77,20 +75,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			subscriptionStreams.TryAdd(key, observable);
 			return observable;
 		}
-
-		/// <inheritdoc />
-		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) {
-			if (disposed)
-				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
-			return CreateSubscriptionStream<TResponse>(request, e => {
-				if (e is WebSocketException webSocketException)
-					webSocketExceptionHandler(webSocketException);
-				else
-					throw e;
-			});
-		}
-
+		
 		/// <inheritdoc />
 		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler) {
 			if (disposed)
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientExtensions.cs
new file mode 100644
index 00000000..4535c1e0
--- /dev/null
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientExtensions.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Net.WebSockets;
+
+namespace GraphQL.Client.Http {
+	public static class GraphQLHttpClientExtensions {
+		/// <summary>
+		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+		/// All subscriptions made to this stream share the same hot observable.<br/>
+		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+		/// </summary>
+		/// <param name="client">the GraphQL client</param>
+		/// <param name="request">the GraphQL request for this subscription</param>
+		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+		/// <returns>an observable stream for the specified subscription</returns>
+		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(this IGraphQLClient client,
+			GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) {
+			return client.CreateSubscriptionStream<TResponse>(request, e => {
+				if (e is WebSocketException webSocketException)
+					webSocketExceptionHandler(webSocketException);
+				else
+					throw e;
+			});
+		}
+
+		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+			this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
+			=> client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
+	}
+}
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client/GraphQLClientExtensions.cs
index a452560c..a1731e87 100644
--- a/src/GraphQL.Client/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLClientExtensions.cs
@@ -1,14 +1,35 @@
+using System;
+using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client {
 	public static class GraphQLClientExtensions {
-
-
 		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
 			string query, object? variables = null,
-			string? operationName = null, CancellationToken cancellationToken = default) {
+			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
 			return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
 		}
+		public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
+			string query, object? variables = null,
+			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
+			return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
+		}
+
+		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
+			GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+			=> client.SendQueryAsync<TResponse>(request, cancellationToken);
+
+		public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
+			GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+			=> client.SendMutationAsync<TResponse>(request, cancellationToken);
+
+		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+			this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
+			=> client.CreateSubscriptionStream<TResponse>(request);
+
+		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+			this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<Exception> exceptionHandler)
+			=> client.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
 	}
 }
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 59483ac5..c4565e78 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -7,9 +7,9 @@ namespace GraphQL.Client {
 
 	public interface IGraphQLClient : IDisposable {
 
-		Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default);
+		Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
-		Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default);
+		Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
 		/// <summary>
 		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
@@ -19,19 +19,7 @@ public interface IGraphQLClient : IDisposable {
 		/// <param name="request">the GraphQL request for this subscription</param>
 		/// <returns>an observable stream for the specified subscription</returns>
 		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request);
-
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
-		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
-		/// </summary>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler);
-
+		
 		/// <summary>
 		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
 		/// All subscriptions made to this stream share the same hot observable.<br/>

From 0882753ff53e6a4a1424695acccd7049a264ee37 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 16:49:36 +0100
Subject: [PATCH 067/455] move integration test server to netcoreapp3.1

---
 tests/IntegrationTestServer/IntegrationTestServer.csproj | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index cfba48cd..86bfb9ec 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -15,8 +15,6 @@
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
-    <PackageReference Include="Microsoft.AspNetCore.App" />
-    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
   </ItemGroup>

From cd1cc6342fdb6659463e83e7bd5530b4f58fcc97 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:12:12 +0100
Subject: [PATCH 068/455] use GitVersion to generate version number

---
 .github/workflows/workflow.yml           |  3 +++
 dotnet-tools.json                        | 26 +++++++++++++++---------
 root.props                               |  1 -
 src/GraphQL.Client/GraphQL.Client.csproj |  2 +-
 src/src.props                            | 26 ++++++++++++++++++++++++
 5 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 08a46941..94327ccc 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -9,6 +9,7 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
+    - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet tool restore
     - run: dotnet build -c Release
 
@@ -21,6 +22,7 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
+    - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
   # publish:
@@ -33,6 +35,7 @@ jobs:
   #     with:
   #       dotnet-version: '3.1.100'
   #   - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
+  #   - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
   #   - run: dotnet build -c Release
   #   - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
   #   - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
diff --git a/dotnet-tools.json b/dotnet-tools.json
index d745d3cf..6d123e6b 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -1,11 +1,17 @@
 {
-	"isRoot": true,
-	"tools": {
-		"dotnet-format": {
-			"commands": [
-				"dotnet-format"
-			],
-			"version": "3.2.107702"
-		}
-	}
-}
+  "isRoot": true,
+  "tools": {
+    "dotnet-format": {
+      "version": "3.2.107702",
+      "commands": [
+        "dotnet-format"
+      ]
+    },
+    "gitversion.tool": {
+      "version": "5.1.3",
+      "commands": [
+        "dotnet-gitversion"
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/root.props b/root.props
index c9489974..77846382 100644
--- a/root.props
+++ b/root.props
@@ -18,7 +18,6 @@
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<Version>2.0.0-alpha.4.subscription-api.10</Version>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 6ac1865d..bc004365 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../src.props" />
 
diff --git a/src/src.props b/src/src.props
index d9a5800d..19e1fafb 100644
--- a/src/src.props
+++ b/src/src.props
@@ -7,4 +7,30 @@
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 	</PropertyGroup>
 
+	<ItemGroup>
+		<PackageReference Include="GitVersionTask" Version="5.1.2">
+			<PrivateAssets>all</PrivateAssets>
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+		</PackageReference>
+	</ItemGroup>
+
+	<PropertyGroup Condition=" '$(GitVersion_SemVer)' != ''">
+		<GetVersion>false</GetVersion>
+		<WriteVersionInfoToBuildLog>false</WriteVersionInfoToBuildLog>
+		<UpdateAssemblyInfo>false</UpdateAssemblyInfo>
+		<GenerateGitVersionInformation>false</GenerateGitVersionInformation>
+
+		<Version>$(GitVersion_FullSemVer)</Version>
+		<VersionPrefix>$(GitVersion_MajorMinorPatch)</VersionPrefix>
+		<VersionSuffix Condition=" '$(UseFullSemVerForNuGet)' == 'false' ">$(GitVersion_NuGetPreReleaseTag)</VersionSuffix>
+		<VersionSuffix Condition=" '$(UseFullSemVerForNuGet)' == 'true' ">$(GitVersion_PreReleaseTag)</VersionSuffix>
+		<PackageVersion Condition=" '$(UseFullSemVerForNuGet)' == 'false' ">$(GitVersion_NuGetVersion)</PackageVersion>
+		<PackageVersion Condition=" '$(UseFullSemVerForNuGet)' == 'true' ">$(GitVersion_FullSemVer)</PackageVersion>
+		<InformationalVersion Condition=" '$(InformationalVersion)' == '' ">$(GitVersion_InformationalVersion)</InformationalVersion>
+		<AssemblyVersion Condition=" '$(AssemblyVersion)' == '' ">$(GitVersion_AssemblySemVer)</AssemblyVersion>
+		<FileVersion Condition=" '$(FileVersion)' == '' ">$(GitVersion_AssemblySemFileVer)</FileVersion>
+		<RepositoryBranch Condition=" '$(RepositoryBranch)' == '' ">$(GitVersion_BranchName)</RepositoryBranch>
+		<RepositoryCommit Condition=" '$(RepositoryCommit)' == '' ">$(GitVersion_Sha)</RepositoryCommit>
+	</PropertyGroup>
+
 </Project>

From ce902e9b32ca19481110b316710ee586d1c832e3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:14:33 +0100
Subject: [PATCH 069/455] fix workflow command order

---
 .github/workflows/workflow.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 94327ccc..0b404ea1 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -9,8 +9,8 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet tool restore
+    - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet build -c Release
 
   test:
@@ -22,6 +22,7 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
+    - run: dotnet tool restore
     - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
@@ -35,6 +36,7 @@ jobs:
   #     with:
   #       dotnet-version: '3.1.100'
   #   - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
+  #   - run: dotnet tool restore
   #   - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
   #   - run: dotnet build -c Release
   #   - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json

From 0f07900229930473d3634738f643741397620c11 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:28:10 +0100
Subject: [PATCH 070/455] use gitversion.json artifact

---
 .github/workflows/workflow.yml | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 0b404ea1..878cf65f 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -1,6 +1,21 @@
 name: Main workflow
 on: [push]
 jobs:
+  jobs:
+    name: GenerateVersionInfo
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@master
+    - uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+    - run: dotnet tool restore
+    - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
+    - uses: actions/upload-artifact@v1
+      with:
+        name: gitversion
+        path: gitversion.json
+
   build:
     name: Build
     runs-on: windows-latest
@@ -9,8 +24,10 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - run: dotnet tool restore
-    - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+    - uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet build -c Release
 
   test:
@@ -22,8 +39,10 @@ jobs:
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - run: dotnet tool restore
-    - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+    - uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
   # publish:
@@ -36,8 +55,7 @@ jobs:
   #     with:
   #       dotnet-version: '3.1.100'
   #   - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
-  #   - run: dotnet tool restore
-  #   - run: dotnet dotnet-gitversion /output json | Out-String | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+  #   - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
   #   - run: dotnet build -c Release
   #   - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
   #   - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json

From 66ea9b8295d998258dccfc4ac1254baec7ee7907 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:34:50 +0100
Subject: [PATCH 071/455] depend jobs on eachother

---
 .github/workflows/workflow.yml | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 878cf65f..1c4cbebd 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -1,7 +1,7 @@
 name: Main workflow
 on: [push]
 jobs:
-  jobs:
+  generateVersionInfo:  
     name: GenerateVersionInfo
     runs-on: windows-latest
     steps:
@@ -10,6 +10,7 @@ jobs:
       with:
         dotnet-version: '3.1.100'
     - run: dotnet tool restore
+    - run: dotnet dotnet-gitversion /output buildserver
     - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
     - uses: actions/upload-artifact@v1
       with:
@@ -18,6 +19,7 @@ jobs:
 
   build:
     name: Build
+    needs: generateVersionInfo
     runs-on: windows-latest
     steps:
     - uses: actions/checkout@master
@@ -32,7 +34,7 @@ jobs:
 
   test:
     name: Test
-    needs: build
+    needs: [build, generateVersionInfo]
     runs-on: windows-latest
     steps:
     - uses: actions/checkout@master
@@ -47,7 +49,7 @@ jobs:
 
   # publish:
   #   name: Publish
-  #   needs: test
+  #   needs: [test, generateVersionInfo]
   #   runs-on: windows-latest
   #   steps:
   #   - uses: actions/checkout@master

From 78a238413a5385c88839a6f81ad27a24b5041098 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:43:56 +0100
Subject: [PATCH 072/455] modify checkout on gitversion job

---
 .github/workflows/workflow.yml | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 1c4cbebd..bb99f2f1 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -5,7 +5,10 @@ jobs:
     name: GenerateVersionInfo
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@master
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+        ref: ${{ github.ref }}
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
@@ -22,7 +25,7 @@ jobs:
     needs: generateVersionInfo
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@master
+    - uses: actions/checkout@v2
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
@@ -37,7 +40,7 @@ jobs:
     needs: [build, generateVersionInfo]
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@master
+    - uses: actions/checkout@v2
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
@@ -52,7 +55,7 @@ jobs:
   #   needs: [test, generateVersionInfo]
   #   runs-on: windows-latest
   #   steps:
-  #   - uses: actions/checkout@master
+  #   - uses: actions/checkout@v2
   #   - uses: actions/setup-dotnet@master
   #     with:
   #       dotnet-version: '3.1.100'

From 6b242aa170ff5a69b77a9345bb23c0142c63c9e9 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:44:22 +0100
Subject: [PATCH 073/455] leave sha as raf

---
 .github/workflows/workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index bb99f2f1..a9c63ceb 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -8,7 +8,7 @@ jobs:
     - uses: actions/checkout@v2
       with:
         fetch-depth: 0
-        ref: ${{ github.ref }}
+        # ref: ${{ github.ref }}
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'

From ac97023f7c36625c0f1d73ff1dfa3b8f06d91104 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:48:18 +0100
Subject: [PATCH 074/455] run git fetch

---
 .github/workflows/workflow.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index a9c63ceb..dbee661f 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -13,6 +13,7 @@ jobs:
       with:
         dotnet-version: '3.1.100'
     - run: dotnet tool restore
+    - run: git fetch
     - run: dotnet dotnet-gitversion /output buildserver
     - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
     - uses: actions/upload-artifact@v1

From 02327b078f55f0fb212164a4e4831de809a629b7 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 17:54:42 +0100
Subject: [PATCH 075/455] fix path on artifacts download

---
 .github/workflows/workflow.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index dbee661f..c49b5530 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -8,13 +8,12 @@ jobs:
     - uses: actions/checkout@v2
       with:
         fetch-depth: 0
-        # ref: ${{ github.ref }}
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
     - run: dotnet tool restore
     - run: git fetch
-    - run: dotnet dotnet-gitversion /output buildserver
+    - run: dotnet dotnet-gitversion
     - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
     - uses: actions/upload-artifact@v1
       with:
@@ -33,6 +32,7 @@ jobs:
     - uses: actions/download-artifact@v1
       with:
         name: gitversion
+        path: ./
     - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet build -c Release
 
@@ -48,6 +48,7 @@ jobs:
     - uses: actions/download-artifact@v1
       with:
         name: gitversion
+        path: ./
     - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
     - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 

From 548757492500bbc0d419b39943ecdc597eb8e3c1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 18:46:53 +0100
Subject: [PATCH 076/455] add test steps in workflow

---
 .github/workflows/workflow.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index c49b5530..b06e7d76 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -13,8 +13,10 @@ jobs:
         dotnet-version: '3.1.100'
     - run: dotnet tool restore
     - run: git fetch
-    - run: dotnet dotnet-gitversion
     - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
+    - run: Get-Content gitversion.json
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+    - run: 'Get-ChildItem env:'    
     - uses: actions/upload-artifact@v1
       with:
         name: gitversion
@@ -34,6 +36,7 @@ jobs:
         name: gitversion
         path: ./
     - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+    - run: 'Get-ChildItem env:'
     - run: dotnet build -c Release
 
   test:

From 1fc09e74d786a01052a8706222e1a8badf8ace10 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 18:50:52 +0100
Subject: [PATCH 077/455] try to use ::set-env

---
 .github/workflows/workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index b06e7d76..67b7fa54 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -15,7 +15,7 @@ jobs:
     - run: git fetch
     - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
     - run: Get-Content gitversion.json
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
     - run: 'Get-ChildItem env:'    
     - uses: actions/upload-artifact@v1
       with:

From c0a1a66b38fbe33981b100eee81b7a8d78318163 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 18:54:44 +0100
Subject: [PATCH 078/455] fix other jobs

---
 .github/workflows/workflow.yml | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 67b7fa54..c3e45b70 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -15,8 +15,6 @@ jobs:
     - run: git fetch
     - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
     - run: Get-Content gitversion.json
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
-    - run: 'Get-ChildItem env:'    
     - uses: actions/upload-artifact@v1
       with:
         name: gitversion
@@ -35,7 +33,7 @@ jobs:
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
     - run: 'Get-ChildItem env:'
     - run: dotnet build -c Release
 
@@ -52,7 +50,7 @@ jobs:
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
     - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
   # publish:
@@ -64,8 +62,12 @@ jobs:
   #   - uses: actions/setup-dotnet@master
   #     with:
   #       dotnet-version: '3.1.100'
+    # - uses: actions/download-artifact@v1
+    #     with:
+    #       name: gitversion
+    #       path: ./
   #   - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
-  #   - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { Set-Item -Path "env:GitVersion_$($item.Name)" -Value $item.Value } }
+  #   - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
   #   - run: dotnet build -c Release
   #   - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
   #   - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json

From 6b1283b0feb243f4bbee110781ad659615f6b0e5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 19:02:37 +0100
Subject: [PATCH 079/455] fix gitversion variable output

---
 .github/workflows/workflow.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index c3e45b70..31528683 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -33,7 +33,7 @@ jobs:
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
     - run: 'Get-ChildItem env:'
     - run: dotnet build -c Release
 
@@ -50,7 +50,7 @@ jobs:
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
     - run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
   # publish:

From 6dc27aaeb05d1c10c6df012e28c88101768a9a4d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 19:14:12 +0100
Subject: [PATCH 080/455] add names to steps

---
 .github/workflows/workflow.yml | 50 ++++++++++++++++++++++------------
 1 file changed, 32 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 31528683..f6c4f593 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -5,17 +5,22 @@ jobs:
     name: GenerateVersionInfo
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v2
+    - name: Checkout
+      uses: actions/checkout@v2
       with:
         fetch-depth: 0
-    - uses: actions/setup-dotnet@master
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - run: dotnet tool restore
-    - run: git fetch
-    - run: dotnet dotnet-gitversion /output json | Out-File gitversion.json
-    - run: Get-Content gitversion.json
-    - uses: actions/upload-artifact@v1
+    - name: Restore dotnet tools
+      run: dotnet tool restore
+    - name: Fetch complete repository 
+      run: git fetch
+    - name: Generate version info from git history
+      run: dotnet dotnet-gitversion /output json | Out-File gitversion.json; Get-Content gitversion.json
+    - name: Upload version info file
+      uses: actions/upload-artifact@v1
       with:
         name: gitversion
         path: gitversion.json
@@ -25,33 +30,42 @@ jobs:
     needs: generateVersionInfo
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-dotnet@master
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - uses: actions/download-artifact@v1
+    - name: Download version info file
+      uses: actions/download-artifact@v1
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
-    - run: 'Get-ChildItem env:'
-    - run: dotnet build -c Release
+    - name: Inject version info into environment
+      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }; $env:GitVersion_SemVer
+    - name: Build solution
+      run: dotnet build -c Release
 
   test:
     name: Test
     needs: [build, generateVersionInfo]
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-dotnet@master
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - uses: actions/download-artifact@v1
+    - name: Download version info file
+      uses: actions/download-artifact@v1
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
-    - run: dotnet test -c Release -p:ParallelizeTestCollections=false
+    - name: Inject version info into environment
+      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
+    - name: Run tests
+      run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
   # publish:
   #   name: Publish

From ff2ac88f0db2eabf5db10b3217cf444c3750c4e5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 19:19:35 +0100
Subject: [PATCH 081/455] run workflow on pullrequests too

---
 .github/workflows/workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index f6c4f593..9fdd205e 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -1,5 +1,5 @@
 name: Main workflow
-on: [push]
+on: [push, pull_request]
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From 12529880a1c4b70e94a2b74a8897574227e7ba1d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 19:29:06 +0100
Subject: [PATCH 082/455] try to fix publish job

---
 .github/workflows/workflow.yml | 41 ++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 9fdd205e..613e1e30 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -67,22 +67,25 @@ jobs:
     - name: Run tests
       run: dotnet test -c Release -p:ParallelizeTestCollections=false
 
-  # publish:
-  #   name: Publish
-  #   needs: [test, generateVersionInfo]
-  #   runs-on: windows-latest
-  #   steps:
-  #   - uses: actions/checkout@v2
-  #   - uses: actions/setup-dotnet@master
-  #     with:
-  #       dotnet-version: '3.1.100'
-    # - uses: actions/download-artifact@v1
-    #     with:
-    #       name: gitversion
-    #       path: ./
-  #   - run: $env:OWNER = Split-Path -Path $env:GITHUB_REPOSITORY
-  #   - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
-  #   - run: dotnet build -c Release
-  #   - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
-  #   - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
-  #   - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg --user $env:GITHUB_ACTOR --password ${{ secrets.GITHUB_TOKEN }} --source https://nuget.pkg.github.com/$env:OWNER/index.json
+  publish:
+    name: Publish
+    needs: [test, generateVersionInfo]
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v2
+    - run: '$owner = Split-Path -Path "graphql-dotnet/graphql-client"; "::set-env name=OWNER::$($owner)"'
+    - uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+        source-url: https://nuget.pkg.github.com/${{env.OWNER}}/index.json
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+    - uses: actions/download-artifact@v1
+        with:
+          name: gitversion
+          path: ./
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
+    - run: dotnet build -c Release
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg

From bf1b093814757dee448429cf36a71f183738354a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 19:30:13 +0100
Subject: [PATCH 083/455] fix indentation

---
 .github/workflows/workflow.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 613e1e30..3cfa660b 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -73,7 +73,7 @@ jobs:
     runs-on: windows-latest
     steps:
     - uses: actions/checkout@v2
-    - run: '$owner = Split-Path -Path "graphql-dotnet/graphql-client"; "::set-env name=OWNER::$($owner)"'
+    - run: $owner = Split-Path -Path "graphql-dotnet/graphql-client"; "::set-env name=OWNER::$($owner)"
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
@@ -81,9 +81,9 @@ jobs:
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - uses: actions/download-artifact@v1
-        with:
-          name: gitversion
-          path: ./
+      with:
+        name: gitversion
+        path: ./
     - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
     - run: dotnet build -c Release
     - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg

From 30a62b1ebd9d978c24cbecde94eb816bcd6b9370 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 19:37:53 +0100
Subject: [PATCH 084/455] fix github repo path

---
 .github/workflows/workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 3cfa660b..14076f5a 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -73,7 +73,7 @@ jobs:
     runs-on: windows-latest
     steps:
     - uses: actions/checkout@v2
-    - run: $owner = Split-Path -Path "graphql-dotnet/graphql-client"; "::set-env name=OWNER::$($owner)"
+    - run: $owner = Split-Path -Path $env:GITHUB_REPOSITORY; "::set-env name=OWNER::$($owner)"
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'

From b382cc32647a8cf98ed7217ef21bd9f7ffe2eb70 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 19:38:40 +0100
Subject: [PATCH 085/455] fix gitversion injection in publish job

---
 .github/workflows/workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 14076f5a..b1b4bea4 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -84,7 +84,7 @@ jobs:
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$item.Value" } }
+    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
     - run: dotnet build -c Release
     - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg
     - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg

From 63df4e03c82affc3a3838a221303642979ee08b1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 20:47:30 +0100
Subject: [PATCH 086/455] move auth token env var

---
 .github/workflows/workflow.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index b1b4bea4..4408ecb3 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -71,15 +71,15 @@ jobs:
     name: Publish
     needs: [test, generateVersionInfo]
     runs-on: windows-latest
+    env:
+      NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     steps:
     - uses: actions/checkout@v2
     - run: $owner = Split-Path -Path $env:GITHUB_REPOSITORY; "::set-env name=OWNER::$($owner)"
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-        source-url: https://nuget.pkg.github.com/${{env.OWNER}}/index.json
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+        source-url: https://nuget.pkg.github.com/${{env.OWNER}}/index.json      
     - uses: actions/download-artifact@v1
       with:
         name: gitversion

From 9bf15020c6e87281100410bd9d979356a20bcf61 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 4 Feb 2020 21:01:24 +0100
Subject: [PATCH 087/455] run setup-dotnet twice

---
 .github/workflows/workflow.yml | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 4408ecb3..a67ed8f2 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -71,21 +71,24 @@ jobs:
     name: Publish
     needs: [test, generateVersionInfo]
     runs-on: windows-latest
-    env:
-      NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     steps:
     - uses: actions/checkout@v2
     - run: $owner = Split-Path -Path $env:GITHUB_REPOSITORY; "::set-env name=OWNER::$($owner)"
     - uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-        source-url: https://nuget.pkg.github.com/${{env.OWNER}}/index.json      
     - uses: actions/download-artifact@v1
       with:
         name: gitversion
         path: ./
     - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
     - run: dotnet build -c Release
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg
+    - uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+        source-url: https://nuget.pkg.github.com/${{env.OWNER}}/index.json      
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file

From fe9862345a8557f07e6969537aec2a9c4c17454b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 21:13:25 +0100
Subject: [PATCH 088/455] fix nupkg path

---
 .github/workflows/workflow.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index a67ed8f2..0a877e8e 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -89,6 +89,6 @@ jobs:
         source-url: https://nuget.pkg.github.com/${{env.OWNER}}/index.json      
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-    - run: dotnet nuget push ./src/GraphQL.Primitives/bin/Release/GraphQL.Primitives.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
-    - run: dotnet nuget push ./src/GraphQL.Client/bin/Release/GraphQL.Client.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
-    - run: dotnet nuget push ./src/GraphQL.Client.Http/bin/Release/GraphQL.Client.Http.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file
+    - run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+    - run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+    - run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file

From b8f5576f8276707448d182fc908e34398d7aa9f3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 21:31:32 +0100
Subject: [PATCH 089/455] use graphql-dotnet as owner

---
 .github/workflows/workflow.yml | 32 +++++++++++++++++++++-----------
 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 0a877e8e..52703f58 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -72,23 +72,33 @@ jobs:
     needs: [test, generateVersionInfo]
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v2
-    - run: $owner = Split-Path -Path $env:GITHUB_REPOSITORY; "::set-env name=OWNER::$($owner)"
-    - uses: actions/setup-dotnet@master
+    - name: Checkout
+      uses: actions/checkout@v2
+    # - name: Evaluate repository owner
+    #   run: $owner = Split-Path -Path $env:GITHUB_REPOSITORY; "::set-env name=OWNER::$($owner)"
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-    - uses: actions/download-artifact@v1
+    - name: Download version info file
+      uses: actions/download-artifact@v1
       with:
         name: gitversion
         path: ./
-    - run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
-    - run: dotnet build -c Release
-    - uses: actions/setup-dotnet@master
+    - name: Inject version info into environment
+      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
+    - name: Build solution
+      run: dotnet build -c Release
+    - name: Setup GitHub Packages as nuget source
+      uses: actions/setup-dotnet@master
       with:
         dotnet-version: '3.1.100'
-        source-url: https://nuget.pkg.github.com/${{env.OWNER}}/index.json      
+        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-    - run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
-    - run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
-    - run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file
+    - name: push GraphQL.Primitives
+      run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+    - name: push GraphQL.Client
+      run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+    - name: push GraphQL.Client.Http
+      run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file

From d7a094feb566d6b0f6a0ee7c1df72f0db51993cc Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 21:59:20 +0100
Subject: [PATCH 090/455] only run main workflow on pushes

---
 .github/workflows/workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 52703f58..68b28903 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -1,5 +1,5 @@
 name: Main workflow
-on: [push, pull_request]
+on: [push]
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From d19c96ee9c006c7a8ad30fbc4c534c9bf5395444 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 22:14:14 +0100
Subject: [PATCH 091/455] replace IHostEnvironment with IWebHostEnvironment

---
 tests/IntegrationTestServer/Startup.cs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 88fa64f5..b45151ed 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -8,16 +8,17 @@
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 
 namespace IntegrationTestServer {
 	public class Startup {
-		public Startup(IConfiguration configuration, IHostingEnvironment environment) {
+		public Startup(IConfiguration configuration, IWebHostEnvironment environment) {
 			Configuration = configuration;
 			Environment = environment;
 		}
 
 		public IConfiguration Configuration { get; }
-		public IHostingEnvironment Environment { get; }
+		public IWebHostEnvironment Environment { get; }
 
 		// This method gets called by the runtime. Use this method to add services to the container.
 		// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
@@ -39,12 +40,10 @@ public void ConfigureServices(IServiceCollection services) {
 				options.ExposeExceptions = Environment.IsDevelopment();
 			})
 				.AddWebSockets();
-
-			//services.AddMvc();
 		}
 
 		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
-		public void Configure(IApplicationBuilder app, IHostingEnvironment env) {
+		public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
 			if (env.IsDevelopment()) {
 				app.UseDeveloperExceptionPage();
 			}
@@ -63,7 +62,6 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env) {
 			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions {
 				Path = "/ui/playground"
 			});
-			//app.UseMvc();
 		}
 	}
 }

From c430750f35e38ac382d100ecf01696f588d8abe1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 22:35:08 +0100
Subject: [PATCH 092/455] try setting and using NUGET_AUTH_TOKEN

---
 .github/workflows/workflow.yml | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 68b28903..18694834 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -97,8 +97,14 @@ jobs:
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: push GraphQL.Primitives
-      run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+      run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -k $env:NUGET_AUTH_TOKEN
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: push GraphQL.Client
-      run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+      run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -k $env:NUGET_AUTH_TOKEN
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: push GraphQL.Client.Http
-      run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -k ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file
+      run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -k $env:NUGET_AUTH_TOKEN
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file

From f512d9e37b0b8c489bca492a18e897a241c0adf4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 22:58:24 +0100
Subject: [PATCH 093/455] set GPR source with nuget cli

---
 .github/workflows/workflow.yml | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 18694834..37749ceb 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -90,21 +90,22 @@ jobs:
     - name: Build solution
       run: dotnet build -c Release
     - name: Setup GitHub Packages as nuget source
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+      # uses: actions/setup-dotnet@master
+      # with:
+      #   dotnet-version: '3.1.100'
+      #   source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
+      # env:
+      #   NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+      run: nuget source Add -Name "GPR" -Source "https://nuget.pkg.github.com/graphql-dotnet/index.json" -UserName graphql-dotnet -Password ${{ secrets.GITHUB_TOKEN }}          
     - name: push GraphQL.Primitives
-      run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -k $env:NUGET_AUTH_TOKEN
+      run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -s "GPR" --skip-duplicate
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: push GraphQL.Client
-      run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -k $env:NUGET_AUTH_TOKEN
+      run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -s "GPR" --skip-duplicate
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: push GraphQL.Client.Http
-      run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -k $env:NUGET_AUTH_TOKEN
+      run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -s "GPR" --skip-duplicate
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file

From 17563c61cb4a3068da1bbbe15d19a9153a3419fa Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 23:05:54 +0100
Subject: [PATCH 094/455] fix repository url

---
 root.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/root.props b/root.props
index 77846382..0307b880 100644
--- a/root.props
+++ b/root.props
@@ -16,7 +16,7 @@
 		<PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
 		<PackageTags>GraphQL</PackageTags>
 		<RepositoryType>git</RepositoryType>
-		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client.git</RepositoryUrl>
+		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client</RepositoryUrl>
 		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
 		<WarningLevel>4</WarningLevel>
 	</PropertyGroup>

From 59fef26c0d674e10d8748b3927ecb069b30af041 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 23:08:40 +0100
Subject: [PATCH 095/455] check if the bad repo entry was the cause

---
 .github/workflows/workflow.yml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index 37749ceb..d82d340d 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -90,13 +90,13 @@ jobs:
     - name: Build solution
       run: dotnet build -c Release
     - name: Setup GitHub Packages as nuget source
-      # uses: actions/setup-dotnet@master
-      # with:
-      #   dotnet-version: '3.1.100'
-      #   source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
-      # env:
-      #   NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-      run: nuget source Add -Name "GPR" -Source "https://nuget.pkg.github.com/graphql-dotnet/index.json" -UserName graphql-dotnet -Password ${{ secrets.GITHUB_TOKEN }}          
+      uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+      # run: nuget source Add -Name "GPR" -Source "https://nuget.pkg.github.com/graphql-dotnet/index.json" -UserName graphql-dotnet -Password ${{ secrets.GITHUB_TOKEN }}          
     - name: push GraphQL.Primitives
       run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -s "GPR" --skip-duplicate
       env:

From f50ceb88f57174482d0caeedbed803f3ae09f1ac Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 23:22:07 +0100
Subject: [PATCH 096/455] store packages in artifacts

---
 .github/workflows/workflow.yml                | 35 +++++++------------
 .../GraphQL.Client.Http.Examples.csproj       |  1 +
 2 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index d82d340d..e9531a21 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -45,6 +45,13 @@ jobs:
       run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }; $env:GitVersion_SemVer
     - name: Build solution
       run: dotnet build -c Release
+    - name: Create NuGet packages
+      run: dotnet pack -c Release --no-build -o nupkg 
+    - name: Upload nuget packages
+      uses: actions/upload-artifact@v1
+      with:
+        name: nupkg
+        path: nupkg
 
   test:
     name: Test
@@ -74,21 +81,10 @@ jobs:
     steps:
     - name: Checkout
       uses: actions/checkout@v2
-    # - name: Evaluate repository owner
-    #   run: $owner = Split-Path -Path $env:GITHUB_REPOSITORY; "::set-env name=OWNER::$($owner)"
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - name: Download version info file
+    - name: Download nuget packages
       uses: actions/download-artifact@v1
       with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
-    - name: Build solution
-      run: dotnet build -c Release
+        name: nupkg
     - name: Setup GitHub Packages as nuget source
       uses: actions/setup-dotnet@master
       with:
@@ -97,15 +93,8 @@ jobs:
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
       # run: nuget source Add -Name "GPR" -Source "https://nuget.pkg.github.com/graphql-dotnet/index.json" -UserName graphql-dotnet -Password ${{ secrets.GITHUB_TOKEN }}          
-    - name: push GraphQL.Primitives
-      run: dotnet nuget push .\src\GraphQL.Primitives\bin\Release\GraphQL.Primitives.*.nupkg -s "GPR" --skip-duplicate
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-    - name: push GraphQL.Client
-      run: dotnet nuget push .\src\GraphQL.Client\bin\Release\GraphQL.Client.*.nupkg -s "GPR" --skip-duplicate
+    - name: push packages
+      run: dotnet nuget push .\nupkg\*.nupkg --skip-duplicate
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-    - name: push GraphQL.Client.Http
-      run: dotnet nuget push .\src\GraphQL.Client.Http\bin\Release\GraphQL.Client.Http.*.nupkg -s "GPR" --skip-duplicate
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
\ No newline at end of file
+    
\ No newline at end of file
diff --git a/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj b/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
index 959525f5..676c3e72 100644
--- a/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
+++ b/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
@@ -3,6 +3,7 @@
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
 		<TargetFramework>netcoreapp3.1</TargetFramework>
+		<IsPackable>false</IsPackable>
 	</PropertyGroup>
 
 	<ItemGroup>

From 0d8215a0e23d87a092492e5f0a1bc10f73e70223 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 23:31:01 +0100
Subject: [PATCH 097/455] cleanup

---
 .github/workflows/workflow.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.github/workflows/workflow.yml b/.github/workflows/workflow.yml
index e9531a21..51b3b1c4 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/workflow.yml
@@ -92,9 +92,6 @@ jobs:
         source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-      # run: nuget source Add -Name "GPR" -Source "https://nuget.pkg.github.com/graphql-dotnet/index.json" -UserName graphql-dotnet -Password ${{ secrets.GITHUB_TOKEN }}          
     - name: push packages
       run: dotnet nuget push .\nupkg\*.nupkg --skip-duplicate
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     
\ No newline at end of file

From 9cda3881ef4b3064a44709953d169c9414830332 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 4 Feb 2020 23:58:42 +0100
Subject: [PATCH 098/455] separate workflow for unprotected branches

---
 .github/workflows/branches.yml               | 81 ++++++++++++++++++++
 .github/workflows/{workflow.yml => main.yml} | 10 ++-
 2 files changed, 89 insertions(+), 2 deletions(-)
 create mode 100644 .github/workflows/branches.yml
 rename .github/workflows/{workflow.yml => main.yml} (96%)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
new file mode 100644
index 00000000..e6669ac3
--- /dev/null
+++ b/.github/workflows/branches.yml
@@ -0,0 +1,81 @@
+name: Branch workflow
+on: 
+  push:
+    branches-ignore:
+      - master
+      - develop
+      - 'release/**'
+      - 'releases/**'
+jobs:
+  generateVersionInfo:  
+    name: GenerateVersionInfo
+    runs-on: windows-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+    - name: Restore dotnet tools
+      run: dotnet tool restore
+    - name: Fetch complete repository 
+      run: git fetch
+    - name: Generate version info from git history
+      run: dotnet dotnet-gitversion /output json | Out-File gitversion.json; Get-Content gitversion.json
+    - name: Upload version info file
+      uses: actions/upload-artifact@v1
+      with:
+        name: gitversion
+        path: gitversion.json
+
+  build:
+    name: Build
+    needs: generateVersionInfo
+    runs-on: windows-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+    - name: Download version info file
+      uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+        path: ./
+    - name: Inject version info into environment
+      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }; $env:GitVersion_SemVer
+    - name: Build solution
+      run: dotnet build -c Release
+    - name: Create NuGet packages
+      run: dotnet pack -c Release --no-build -o nupkg 
+    - name: Upload nuget packages
+      uses: actions/upload-artifact@v1
+      with:
+        name: nupkg
+        path: nupkg
+
+  test:
+    name: Test
+    needs: [build, generateVersionInfo]
+    runs-on: windows-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+    - name: Download version info file
+      uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+        path: ./
+    - name: Inject version info into environment
+      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
+    - name: Run tests
+      run: dotnet test -c Release -p:ParallelizeTestCollections=false
diff --git a/.github/workflows/workflow.yml b/.github/workflows/main.yml
similarity index 96%
rename from .github/workflows/workflow.yml
rename to .github/workflows/main.yml
index 51b3b1c4..a0463612 100644
--- a/.github/workflows/workflow.yml
+++ b/.github/workflows/main.yml
@@ -1,5 +1,11 @@
 name: Main workflow
-on: [push]
+on: 
+  push:
+    branches:
+      - master
+      - develop
+      - 'release/**'
+      - 'releases/**'
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo
@@ -76,7 +82,7 @@ jobs:
 
   publish:
     name: Publish
-    needs: [test, generateVersionInfo]
+    needs: [test]
     runs-on: windows-latest
     steps:
     - name: Checkout

From c898dc583253d7230b37873490d3c8617496fe55 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 08:50:12 +0100
Subject: [PATCH 099/455] add key to dotnet nuget push

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index a0463612..1f04b3dc 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -99,5 +99,5 @@ jobs:
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: push packages
-      run: dotnet nuget push .\nupkg\*.nupkg --skip-duplicate
+      run: dotnet nuget push .\nupkg\*.nupkg --skip-duplicate -k ${{secrets.GITHUB_TOKEN}}
     
\ No newline at end of file

From ed999730300bfbc30b095a4c7dd74a7be19022ef Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 11:15:40 +0100
Subject: [PATCH 100/455] create second startup class for the starwars schema
 from GraphQL.StarWars

---
 .../Helpers/WebHostHelpers.cs                 | 30 +++++++++++++++++
 .../SubscriptionsTest.cs                      | 33 ++++---------------
 .../IntegrationTestServer.csproj              |  1 +
 tests/IntegrationTestServer/Program.cs        |  2 +-
 tests/IntegrationTestServer/Startup.cs        | 27 ++++++++-------
 tests/IntegrationTestServer/StartupChat.cs    | 27 +++++++++++++++
 .../IntegrationTestServer/StartupStarWars.cs  | 31 +++++++++++++++++
 7 files changed, 113 insertions(+), 38 deletions(-)
 create mode 100644 tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
 create mode 100644 tests/IntegrationTestServer/StartupChat.cs
 create mode 100644 tests/IntegrationTestServer/StartupStarWars.cs

diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
new file mode 100644
index 00000000..8e6103bf
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace GraphQL.Integration.Tests.Helpers
+{
+	public static class WebHostHelpers
+	{
+		public static IWebHost CreateServer<TStartup>(int port) where TStartup : class
+		{
+			var configBuilder = new ConfigurationBuilder();
+			configBuilder.AddInMemoryCollection();
+			var config = configBuilder.Build();
+			config["server.urls"] = $"http://localhost:{port}";
+
+			var host = new WebHostBuilder()
+				.ConfigureLogging((ctx, logging) => {
+					logging.AddDebug();
+				})
+				.UseConfiguration(config)
+				.UseKestrel()
+				.UseStartup<TStartup>()
+				.Build();
+
+			host.Start();
+
+			return host;
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index d81d79c1..c1241f0b 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -7,9 +7,8 @@
 using GraphQL.Client.Http;
 using GraphQL.Integration.Tests.Extensions;
 using GraphQL.Integration.Tests.Helpers;
+using IntegrationTestServer;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -17,25 +16,7 @@ namespace GraphQL.Integration.Tests {
 	public class SubscriptionsTest {
 		private readonly ITestOutputHelper output;
 
-		public static IWebHost CreateServer(int port) {
-			var configBuilder = new ConfigurationBuilder();
-			configBuilder.AddInMemoryCollection();
-			var config = configBuilder.Build();
-			config["server.urls"] = $"http://localhost:{port}";
-
-			var host = new WebHostBuilder()
-				.ConfigureLogging((ctx, logging) => {
-					logging.AddDebug();
-				})
-				.UseConfiguration(config)
-				.UseKestrel()
-				.UseStartup<IntegrationTestServer.Startup>()
-				.Build();
-
-			host.Start();
-
-			return host;
-		}
+		private static IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
 
 		public SubscriptionsTest(ITestOutputHelper output) {
 			this.output = output;
@@ -99,7 +80,7 @@ public async void CanCreateObservableSubscription() {
 			using (CreateServer(port)) {
 				var client = GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -140,7 +121,7 @@ public async void CanReconnectWithSameObservable() {
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -209,8 +190,8 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 				var client = GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable1 = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
-				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
+				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable1 = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse<SubscriptionsTest.UserJoinedSubscriptionResult>> observable2 = client.CreateSubscriptionStream<SubscriptionsTest.UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable1.SubscribeTester();
@@ -257,7 +238,7 @@ public async void CanHandleConnectionTimeout() {
 
 			var client = GetGraphQLClient(port);
 			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+			IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
 
 			Debug.WriteLine("subscribing...");
 			var tester = observable.SubscribeTester();
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 86bfb9ec..6ecc6a43 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -15,6 +15,7 @@
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
+    <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
     <PackageReference Include="System.Reactive" Version="4.1.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
   </ItemGroup>
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index ec3530e1..67cbd96b 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -10,7 +10,7 @@ public static void Main(string[] args) {
 
 		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
 			WebHost.CreateDefaultBuilder(args)
-				.UseStartup<Startup>()
+				.UseStartup<StartupStarWars>()
 				.ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 	}
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index b45151ed..dbb4623f 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,3 +1,5 @@
+using System.Xml.Serialization;
+using GraphQL;
 using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
@@ -11,8 +13,8 @@
 using Microsoft.Extensions.Hosting;
 
 namespace IntegrationTestServer {
-	public class Startup {
-		public Startup(IConfiguration configuration, IWebHostEnvironment environment) {
+	public abstract class Startup {
+		protected Startup(IConfiguration configuration, IWebHostEnvironment environment) {
 			Configuration = configuration;
 			Environment = environment;
 		}
@@ -27,14 +29,11 @@ public void ConfigureServices(IServiceCollection services) {
 			{
 				options.AllowSynchronousIO = true;
 			});
-			services.AddSingleton<IChat, Chat>();
-			services.AddSingleton<ChatSchema.ChatSchema>();
-			services.AddSingleton<ChatQuery>();
-			services.AddSingleton<ChatMutation>();
-			services.AddSingleton<ChatSubscriptions>();
-			services.AddSingleton<MessageType>();
-			services.AddSingleton<MessageInputType>();
 
+			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
+
+			ConfigureGraphQLSchemaServices(services);
+			
 			services.AddGraphQL(options => {
 				options.EnableMetrics = true;
 				options.ExposeExceptions = Environment.IsDevelopment();
@@ -42,6 +41,9 @@ public void ConfigureServices(IServiceCollection services) {
 				.AddWebSockets();
 		}
 
+		public abstract void ConfigureGraphQLSchemaServices(IServiceCollection services);
+
+
 		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
 		public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
 			if (env.IsDevelopment()) {
@@ -49,8 +51,9 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
 			}
 
 			app.UseWebSockets();
-			app.UseGraphQLWebSockets<ChatSchema.ChatSchema>("/graphql");
-			app.UseGraphQL<ChatSchema.ChatSchema>("/graphql");
+
+			ConfigureGraphQLSchema(app);
+
 			app.UseGraphiQLServer(new GraphiQLOptions {
 				GraphiQLPath = "/ui/graphiql",
 				GraphQLEndPoint = "/graphql"
@@ -63,5 +66,7 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
 				Path = "/ui/playground"
 			});
 		}
+
+		public abstract void ConfigureGraphQLSchema(IApplicationBuilder app);
 	}
 }
diff --git a/tests/IntegrationTestServer/StartupChat.cs b/tests/IntegrationTestServer/StartupChat.cs
new file mode 100644
index 00000000..37c205e7
--- /dev/null
+++ b/tests/IntegrationTestServer/StartupChat.cs
@@ -0,0 +1,27 @@
+using GraphQL.Server;
+using IntegrationTestServer.ChatSchema;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace IntegrationTestServer {
+	public class StartupChat: Startup {
+		public StartupChat(IConfiguration configuration, IWebHostEnvironment environment): base(configuration, environment) { }
+
+		public override void ConfigureGraphQLSchemaServices(IServiceCollection services) {
+			services.AddSingleton<IChat, Chat>();
+			services.AddSingleton<ChatSchema.ChatSchema>();
+			services.AddSingleton<ChatQuery>();
+			services.AddSingleton<ChatMutation>();
+			services.AddSingleton<ChatSubscriptions>();
+			services.AddSingleton<MessageType>();
+			services.AddSingleton<MessageInputType>();
+		}
+
+		public override void ConfigureGraphQLSchema(IApplicationBuilder app) {
+			app.UseGraphQLWebSockets<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphQL<ChatSchema.ChatSchema>("/graphql");
+		}
+	}
+}
diff --git a/tests/IntegrationTestServer/StartupStarWars.cs b/tests/IntegrationTestServer/StartupStarWars.cs
new file mode 100644
index 00000000..c62dc5f2
--- /dev/null
+++ b/tests/IntegrationTestServer/StartupStarWars.cs
@@ -0,0 +1,31 @@
+using GraphQL.Server;
+using GraphQL.StarWars;
+using GraphQL.StarWars.Types;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace IntegrationTestServer {
+	public class StartupStarWars: Startup {
+		public StartupStarWars(IConfiguration configuration, IWebHostEnvironment environment): base(configuration, environment) { }
+
+		public override void ConfigureGraphQLSchemaServices(IServiceCollection services) {
+			services.AddSingleton<StarWarsData>();
+			services.AddSingleton<StarWarsQuery>();
+			services.AddSingleton<StarWarsMutation>();
+			services.AddSingleton<StarWarsSchema>();
+
+			services.AddTransient<CharacterInterface>();
+			services.AddTransient<DroidType>();
+			services.AddTransient<EpisodeEnum>();
+			services.AddTransient<HumanType>();
+			services.AddTransient<HumanInputType>();
+		}
+
+		public override void ConfigureGraphQLSchema(IApplicationBuilder app) {
+			app.UseGraphQLWebSockets<StarWarsSchema>("/graphql");
+			app.UseGraphQL<StarWarsSchema>("/graphql");
+		}
+	}
+}

From 3aecaab749be73d04cb7fba5ba6e30db7f3e0ad2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 12:28:10 +0100
Subject: [PATCH 101/455] add basic query and mutation tests

---
 .../GraphQL.Client.Http.csproj                |   1 +
 .../GraphQLHttpClientOptions.cs               |  14 +--
 .../GraphQL.Integration.Tests.csproj          |   2 +-
 .../Helpers/WebHostHelpers.cs                 |  31 +++++
 .../QueryAndMutationTests.cs                  | 115 ++++++++++++++++++
 .../SubscriptionsTest.cs                      |  28 ++---
 .../TestData/StarWarsHumans.cs                |  19 +++
 7 files changed, 179 insertions(+), 31 deletions(-)
 create mode 100644 tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
 create mode 100644 tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs

diff --git a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
index 05900a76..5d72a44c 100644
--- a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
+++ b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
@@ -11,6 +11,7 @@
     </ItemGroup>
 
 	<ItemGroup>
+		<PackageReference Include="Dahomey.Json" Version="1.6.0" />
 		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
 		<PackageReference Include="System.Net.Http" Version="4.3.4" />
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index bf0502dc..9cf44333 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -3,6 +3,7 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text.Json;
+using Dahomey.Json;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
@@ -19,23 +20,12 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public Uri EndPoint { get; set; }
 
-		/// <summary>
-		/// The <see cref="Newtonsoft.Json.JsonSerializerSettings"/> that is going to be used
-		/// </summary>
-		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver(),
-			Converters = new List<JsonConverter>
-			{
-				new StringEnumConverter()
-			}
-		};
-
 		/// <summary>
 		/// The <see cref="JsonSerializerOptions"/> that is going to be used
 		/// </summary>
 		public JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions {
 			PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-		};
+		}.SetupExtensions();
 
 		/// <summary>
 		/// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 9848d12b..0d11b879 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 8e6103bf..4edb3f71 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,3 +1,6 @@
+using System;
+using GraphQL.Client;
+using GraphQL.Client.Http;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -26,5 +29,33 @@ public static IWebHost CreateServer<TStartup>(int port) where TStartup : class
 
 			return host;
 		}
+
+
+		public static GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
+			=> new GraphQLHttpClient(new GraphQLHttpClientOptions {
+				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+				UseWebSocketForQueriesAndMutations = requestsViaWebsocket
+			});
+
+
+		public static TestServerSetup SetupTest<TStartup>(bool requestsViaWebsocket = false) where TStartup : class
+		{
+			var port = NetworkHelpers.GetFreeTcpPortNumber();
+			return new TestServerSetup {
+				Server = CreateServer<TStartup>(port),
+				Client = GetGraphQLClient(port)
+			};
+		}
+	}
+
+	public class TestServerSetup : IDisposable
+	{
+		public IWebHost Server { get; set; }
+		public IGraphQLClient Client { get; set; }
+		public void Dispose()
+		{
+			Server?.Dispose();
+			Client?.Dispose();
+		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
new file mode 100644
index 00000000..a44134e5
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
@@ -0,0 +1,115 @@
+using GraphQL.Client;
+using GraphQL.Integration.Tests.Helpers;
+using GraphQL.Integration.Tests.TestData;
+using IntegrationTestServer;
+using Xunit;
+
+namespace GraphQL.Integration.Tests {
+	public class QueryAndMutationTests {
+
+		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) => WebHostHelpers.SetupTest<StartupStarWars>(requestsViaWebsocket);
+		
+		[Theory]
+		[ClassData(typeof(StarWarsHumans))]
+		public async void QueryTheory(int id, string name) {
+			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+
+			using (var setup = SetupTest()) {
+				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty }})
+					.ConfigureAwait(false);
+
+				Assert.Null(response.Errors);
+				Assert.Equal(name, response.Data.Human.Name);
+			}
+		}
+
+		[Theory]
+		[ClassData(typeof(StarWarsHumans))]
+		public async void QueryWitVarsTheory(int id, string name) {
+			var graphQLRequest = new GraphQLRequest(@"
+				query Human($id: String!){
+					human(id: $id) {
+						name
+					}
+				}",
+				new {id = id.ToString()});
+
+			using (var setup = SetupTest()) {
+				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
+					.ConfigureAwait(false);
+
+				Assert.Null(response.Errors);
+				Assert.Equal(name, response.Data.Human.Name);
+			}
+		}
+
+		[Theory]
+		[ClassData(typeof(StarWarsHumans))]
+		public async void QueryWitVarsAndOperationNameTheory(int id, string name) {
+			var graphQLRequest = new GraphQLRequest(@"
+				query Human($id: String!){
+					human(id: $id) {
+						name
+					}
+				}
+
+				query Droid($id: String!) {
+				  droid(id: $id) {
+				    name
+				  }
+				}",
+				new { id = id.ToString() },
+				"Human");
+
+			using (var setup = SetupTest()) {
+				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
+					.ConfigureAwait(false);
+
+				Assert.Null(response.Errors);
+				Assert.Equal(name, response.Data.Human.Name);
+			}
+		}
+
+		[Fact]
+		public async void SendMutationFact() {
+			var mutationRequest = new GraphQLRequest(@"
+				mutation CreateHuman($human: HumanInput!) {
+				  createHuman(human: $human) {
+				    id
+				    name
+				    homePlanet
+				  }
+				}",
+				new { human = new { name = "Han Solo", homePlanet = "Corellia"}});
+
+			var queryRequest = new GraphQLRequest(@"
+				query Human($id: String!){
+					human(id: $id) {
+						name
+					}
+				}");
+
+			using (var setup = SetupTest()) {
+				var mutationResponse = await setup.Client.SendMutationAsync(mutationRequest, () => new {
+						createHuman = new {
+							Id = "",
+							Name = "",
+							HomePlanet = ""
+						}
+					})
+					.ConfigureAwait(false);
+
+				Assert.Null(mutationResponse.Errors);
+				Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
+				Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
+
+				queryRequest.Variables = new {id = mutationResponse.Data.createHuman.Id};
+				var queryResponse = await setup.Client.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } })
+					.ConfigureAwait(false);
+				
+				Assert.Null(queryResponse.Errors);
+				Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
+			}
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index c1241f0b..03187233 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -4,7 +4,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client;
-using GraphQL.Client.Http;
 using GraphQL.Integration.Tests.Extensions;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
@@ -21,19 +20,12 @@ public class SubscriptionsTest {
 		public SubscriptionsTest(ITestOutputHelper output) {
 			this.output = output;
 		}
-
-		private GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
-			=> new GraphQLHttpClient(new GraphQLHttpClientOptions {
-				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-				UseWebSocketForQueriesAndMutations = requestsViaWebsocket
-			});
-
-
+		
 		[Fact]
 		public async void AssertTestingHarness() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port);
 
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
@@ -46,7 +38,7 @@ public async void AssertTestingHarness() {
 		public async void CanSendRequestViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = GetGraphQLClient(port, true);
+				var client = WebHostHelpers.GetGraphQLClient(port, true);
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
@@ -58,7 +50,7 @@ public async void CanSendRequestViaWebsocket() {
 		public async void CanHandleRequestErrorViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = GetGraphQLClient(port, true);
+				var client = WebHostHelpers.GetGraphQLClient(port, true);
 				var response = await client.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
 
 				Assert.Single(response.Errors);
@@ -78,7 +70,7 @@ public async void CanHandleRequestErrorViaWebsocket() {
 		public async void CanCreateObservableSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest);
 
@@ -118,7 +110,7 @@ public class MessageAddedContent {
 		public async void CanReconnectWithSameObservable() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest);
@@ -187,7 +179,7 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var callbackTester = new CallbackTester<Exception>();
 			var callbackTester2 = new CallbackTester<Exception>();
 			using (CreateServer(port)) {
-				var client = GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port);
 
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable1 = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
@@ -236,7 +228,7 @@ public async void CanHandleConnectionTimeout() {
 			var server = CreateServer(port);
 			var callbackTester = new CallbackTester<Exception>();
 
-			var client = GetGraphQLClient(port);
+			var client = WebHostHelpers.GetGraphQLClient(port);
 			Debug.WriteLine("creating subscription stream");
 			IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
 
@@ -276,7 +268,7 @@ public async void CanHandleConnectionTimeout() {
 		public void CanHandleSubscriptionError() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
 					new GraphQLRequest(@"
@@ -305,7 +297,7 @@ public void CanHandleQueryErrorInSubscription() {
 
 				var test = new GraphQLRequest("tset", new { test = "blaa" });
 
-				var client = GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port);
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
 					new GraphQLRequest(@"
diff --git a/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs b/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs
new file mode 100644
index 00000000..ce53de50
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using GraphQL.StarWars;
+
+namespace GraphQL.Integration.Tests.TestData {
+	public class StarWarsHumans: IEnumerable<object[]> {
+		public IEnumerator<object[]> GetEnumerator() {
+			yield return new object[] { 1, "Luke" };
+			yield return new object[] { 2, "Vader" };
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return GetEnumerator();
+		}
+	}
+}

From 9611f2977337459c1105619c36c3d623b455e37e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 12:59:56 +0100
Subject: [PATCH 102/455] set default timeout to 3 seconds

---
 tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs b/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
index 5135e417..a650237b 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
@@ -12,7 +12,7 @@ public class ObservableTester<T> : IDisposable {
 		/// <summary>
 		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
 		/// </summary>
-		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
 
 		/// <summary>
 		/// Indicates that an update has been received since the last <see cref="_reset"/>

From 3f0d55fff438f51ce1dacd7fb6b0746911c9f12b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 13:18:52 +0100
Subject: [PATCH 103/455] ensure open websocket in subscription tests

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  |  7 +++++-
 .../Websocket/GraphQLHttpWebSocket.cs         | 14 ++++-------
 .../GraphQL.Integration.Tests.csproj          |  3 ++-
 .../Helpers/WebHostHelpers.cs                 |  3 +--
 .../SubscriptionsTest.cs                      | 24 +++++++++++++------
 5 files changed, 31 insertions(+), 20 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 71ca2568..0f04e478 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -24,7 +24,6 @@ public class GraphQLHttpClient : IGraphQLClient {
 		/// <inheritdoc />
 		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
 
-
 		public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint)) { }
 
 		public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
@@ -91,6 +90,12 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			return observable;
 		}
 
+		/// <summary>
+		/// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
+		/// </summary>
+		/// <returns></returns>
+		public Task InitializeWebsocketConnection() => graphQlHttpWebSocket.InitializeWebSocket();
+
 		#region Private Methods
 
 		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
index 7678cc59..0c516c14 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
@@ -6,10 +6,8 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Newtonsoft.Json;
 
 namespace GraphQL.Client.Http.Websocket {
 	internal class GraphQLHttpWebSocket : IDisposable {
@@ -19,8 +17,8 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		private Subject<WebsocketResponseWrapper> _responseSubject;
-		private Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
-		private Subject<Exception> _exceptionSubject = new Subject<Exception>();
+		private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
 		private IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
@@ -40,8 +38,7 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
 
 		public IObservable<WebsocketResponseWrapper> ResponseStream => _responseStream;
-		public IObservable<WebsocketResponseWrapper> _responseStream;
-		//private IDisposable _responseStreamConnection;
+		public readonly IObservable<WebsocketResponseWrapper> _responseStream;
 
 		public Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
 			_requestSubject.OnNext(request);
@@ -71,7 +68,7 @@ await this.clientWebSocket.SendAsync(
 
 		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
 
-		private object _initializeLock = new object();
+		private readonly object _initializeLock = new object();
 
 		#region Private Methods
 
@@ -167,7 +164,6 @@ private async Task _connectAsync(CancellationToken token) {
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
 				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
-				//_responseStreamConnection = _responseStream.Connect();
 				_connectionAttempt = 1;
 			}
 			catch (Exception e) {
@@ -178,7 +174,7 @@ private async Task _connectAsync(CancellationToken token) {
 
 
 		private Task<WebsocketResponseWrapper> _receiveAsyncTask = null;
-		private object _receiveTaskLocker = new object();
+		private readonly object _receiveTaskLocker = new object();
 		/// <summary>
 		/// wrapper method to pick up the existing request task if already running
 		/// </summary>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 0d11b879..de5a92ca 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
@@ -9,6 +9,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="NETStandard.Library" Version="2.0.3" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
     <PackageReference Include="xunit" Version="2.4.1" />
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 4edb3f71..bd737a67 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -36,8 +36,7 @@ public static GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebso
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
 				UseWebSocketForQueriesAndMutations = requestsViaWebsocket
 			});
-
-
+		
 		public static TestServerSetup SetupTest<TStartup>(bool requestsViaWebsocket = false) where TStartup : class
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 03187233..df09455e 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -17,6 +17,8 @@ public class SubscriptionsTest {
 
 		private static IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
 
+		private static TimeSpan WaitForConnectionDelay = TimeSpan.FromMilliseconds(200);
+
 		public SubscriptionsTest(ITestOutputHelper output) {
 			this.output = output;
 		}
@@ -71,8 +73,10 @@ public async void CanCreateObservableSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port);
+				await client.InitializeWebsocketConnection();
+
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest);
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -111,9 +115,10 @@ public async void CanReconnectWithSameObservable() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port);
+				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest);
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.SubscribeTester();
@@ -134,6 +139,7 @@ public async void CanReconnectWithSameObservable() {
 
 				Debug.WriteLine("disposing subscription...");
 				tester.Dispose();
+				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.SubscribeTester();
@@ -180,10 +186,11 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var callbackTester2 = new CallbackTester<Exception>();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port);
+				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable1 = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
-				IObservable<GraphQLResponse<SubscriptionsTest.UserJoinedSubscriptionResult>> observable2 = client.CreateSubscriptionStream<SubscriptionsTest.UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable1 = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable1.SubscribeTester();
@@ -229,8 +236,9 @@ public async void CanHandleConnectionTimeout() {
 			var callbackTester = new CallbackTester<Exception>();
 
 			var client = WebHostHelpers.GetGraphQLClient(port);
+			await client.InitializeWebsocketConnection();
 			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse<SubscriptionsTest.MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<SubscriptionsTest.MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
 
 			Debug.WriteLine("subscribing...");
 			var tester = observable.SubscribeTester();
@@ -265,10 +273,11 @@ public async void CanHandleConnectionTimeout() {
 		}
 
 		[Fact]
-		public void CanHandleSubscriptionError() {
+		public async void CanHandleSubscriptionError() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port);
+				await client.InitializeWebsocketConnection();
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
 					new GraphQLRequest(@"
@@ -291,13 +300,14 @@ public void CanHandleSubscriptionError() {
 		}
 
 		[Fact]
-		public void CanHandleQueryErrorInSubscription() {
+		public async void CanHandleQueryErrorInSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 
 				var test = new GraphQLRequest("tset", new { test = "blaa" });
 
 				var client = WebHostHelpers.GetGraphQLClient(port);
+				await client.InitializeWebsocketConnection();
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
 					new GraphQLRequest(@"

From 56c7ed482cfec5f71f5de4238f03f4c757e41c44 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 13:20:42 +0100
Subject: [PATCH 104/455] cleanup unused using statements

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs                  | 1 -
 src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs           | 4 ----
 .../Websocket/GraphQLHttpWebsocketHelpers.cs                  | 1 -
 src/GraphQL.Client/GraphQLClientExtensions.cs                 | 1 -
 tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs     | 1 -
 tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs    | 4 ----
 tests/IntegrationTestServer/Startup.cs                        | 2 --
 7 files changed, 14 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 0f04e478..8d2c5db5 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Concurrent;
 using System.Net.Http;
-using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index 9cf44333..ac5a8314 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -1,12 +1,8 @@
 using System;
-using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text.Json;
 using Dahomey.Json;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Converters;
-using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.Http {
 
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index 4f357a3e..2227b777 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -7,7 +7,6 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
-using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http.Websocket {
 	public static class GraphQLHttpWebsocketHelpers {
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client/GraphQLClientExtensions.cs
index a1731e87..d8824a05 100644
--- a/src/GraphQL.Client/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLClientExtensions.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 
diff --git a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
index 21a659fe..1f12cff5 100644
--- a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
@@ -1,4 +1,3 @@
-using System.Globalization;
 using Xunit;
 using System.Text.Json;
 
diff --git a/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs b/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs
index ce53de50..99312c8c 100644
--- a/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs
+++ b/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs
@@ -1,9 +1,5 @@
-using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using GraphQL.StarWars;
 
 namespace GraphQL.Integration.Tests.TestData {
 	public class StarWarsHumans: IEnumerable<object[]> {
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index dbb4623f..0ae7280e 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,10 +1,8 @@
-using System.Xml.Serialization;
 using GraphQL;
 using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Voyager;
 using GraphQL.Server.Ui.Playground;
-using IntegrationTestServer.ChatSchema;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Server.Kestrel.Core;

From dbd4c2d4a6c2d25f04dab6c1e806ce05bc4f982b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 13:29:27 +0100
Subject: [PATCH 105/455] insert delay in CanReconnectWithSameObservable

---
 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index df09455e..a70a000c 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -139,6 +139,7 @@ public async void CanReconnectWithSameObservable() {
 
 				Debug.WriteLine("disposing subscription...");
 				tester.Dispose();
+				await Task.Delay(500);
 				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating new subscription...");

From 51f8c0296a222b6ac90c7d49758e01ec6431c04b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 13:47:36 +0100
Subject: [PATCH 106/455] send connection init (chelliwell)

---
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  | 58 ++++++++++++-------
 1 file changed, 36 insertions(+), 22 deletions(-)

diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index 2227b777..d43d0026 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -27,34 +27,38 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 						Id = startRequest.Id,
 						Type = GraphQLWebSocketMessageType.GQL_STOP
 					};
+					var initRequest = new GraphQLWebSocketRequest {
+						Id = startRequest.Id,
+						Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+					};
 
 					var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
 						graphQlHttpWebSocket.ResponseStream
 							// ignore null values and messages for other requests
 							.Where(response => response != null && response.Id == startRequest.Id)
 							.Subscribe(response => {
-								// terminate the sequence when a 'complete' message is received
-								if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE) {
-									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-									o.OnCompleted();
-									return;
-								}
-
-								// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-								Debug.WriteLine($"received payload on subscription {startRequest.Id}");
-								var typedResponse =
-									JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
-										options.JsonSerializerOptions);
-								o.OnNext(typedResponse.Payload);
-
-								// in case of a GraphQL error, terminate the sequence after the response has been posted
-								if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR) {
-									Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
-									o.OnCompleted();
-								}
-							},
-							o.OnError,
-							o.OnCompleted)
+									// terminate the sequence when a 'complete' message is received
+									if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE) {
+										Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+										o.OnCompleted();
+										return;
+									}
+
+									// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+									var typedResponse =
+										JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
+											options.JsonSerializerOptions);
+									o.OnNext(typedResponse.Payload);
+
+									// in case of a GraphQL error, terminate the sequence after the response has been posted
+									if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR) {
+										Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+										o.OnCompleted();
+									}
+								},
+								o.OnError,
+								o.OnCompleted)
 					);
 
 					try {
@@ -81,6 +85,16 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 						})
 					);
 
+					// send connection init
+					Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
+					try {
+						await graphQlHttpWebSocket.SendWebSocketRequest(initRequest).ConfigureAwait(false);
+					}
+					catch (Exception e) {
+						Console.WriteLine(e);
+						throw;
+					}
+
 					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
 					// send subscription request
 					try {

From c2e0e2b0e538a7625fc598d4dcca1a3441cb091b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 13:51:56 +0100
Subject: [PATCH 107/455] use tls credentials on websocket connection
 (chelliwell)

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs              | 4 ++--
 src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 8d2c5db5..f6cb447d 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -30,13 +30,13 @@ public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
 		public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
 			Options = new GraphQLHttpClientOptions();
 			configure(Options);
-			this.httpClient = new HttpClient();
+			this.httpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			Options = options;
-			this.httpClient = new HttpClient();
+			this.httpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
index 0c516c14..7098a8e5 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.IO;
+using System.Net.Http;
 using System.Net.WebSockets;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
@@ -108,9 +109,13 @@ public Task InitializeWebSocket() {
 				switch (clientWebSocket) {
 					case ClientWebSocket nativeWebSocket:
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)_options.HttpMessageHandler).ClientCertificates;
+						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)_options.HttpMessageHandler).UseDefaultCredentials;
 						break;
 					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
 						managedWebSocket.Options.AddSubProtocol("graphql-ws");
+						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)_options.HttpMessageHandler).ClientCertificates;
+						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)_options.HttpMessageHandler).UseDefaultCredentials;
 						break;
 					default:
 						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");

From 11811529cd78fdc280f8695a189c1a6f196e7903 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 14:01:52 +0100
Subject: [PATCH 108/455] expose the HttpClient instance from GraphQLHttpClient

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index f6cb447d..f8db3ecc 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -12,9 +12,13 @@ public class GraphQLHttpClient : IGraphQLClient {
 
 		private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-		private readonly HttpClient httpClient;
 		private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
 
+		/// <summary>
+		/// the instance of <see cref="HttpClient"/> which is used internally
+		/// </summary>
+		public HttpClient HttpClient { get; }
+
 		/// <summary>
 		/// The Options	to be used
 		/// </summary>
@@ -30,19 +34,19 @@ public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
 		public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
 			Options = new GraphQLHttpClientOptions();
 			configure(Options);
-			this.httpClient = new HttpClient(Options.HttpMessageHandler);
+			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			Options = options;
-			this.httpClient = new HttpClient(Options.HttpMessageHandler);
+			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
 			Options = options;
-			this.httpClient = httpClient;
+			this.HttpClient = httpClient;
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
@@ -99,7 +103,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
 		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			using var httpRequestMessage = this.GenerateHttpRequestMessage(request.SerializeToJson(Options));
-			using var httpResponseMessage = await this.httpClient.SendAsync(httpRequestMessage, cancellationToken);
+			using var httpResponseMessage = await this.HttpClient.SendAsync(httpRequestMessage, cancellationToken);
 			if (!httpResponseMessage.IsSuccessStatusCode) {
 				throw new GraphQLHttpException(httpResponseMessage);
 			}
@@ -140,7 +144,7 @@ public void Dispose() {
 
 		private void _dispose() {
 			disposed = true;
-			this.httpClient.Dispose();
+			this.HttpClient.Dispose();
 			this.graphQlHttpWebSocket.Dispose();
 			cancellationTokenSource.Cancel();
 			cancellationTokenSource.Dispose();

From f69d3ccaff79b2375f5373c421d962c1bfb70e15 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 14:19:38 +0100
Subject: [PATCH 109/455] request preprocessing #104

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  | 19 ++--
 .../GraphQLHttpClientOptions.cs               |  7 +-
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  | 90 ++++++++++---------
 3 files changed, 62 insertions(+), 54 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index f8db3ecc..32ad6ea7 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -50,17 +50,17 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
+		/// <inheritdoc />
 		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
+				? this.graphQlHttpWebSocket.Request<TResponse>(request, this, cancellationToken)
 				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
-		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request<TResponse>(request, Options, cancellationToken)
-				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
-		}
+		/// <inheritdoc />
+		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request,
+			CancellationToken cancellationToken = default)
+			=> SendQueryAsync<TResponse>(request, cancellationToken);
 
 		/// <inheritdoc />
 		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) {
@@ -72,7 +72,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			if (subscriptionStreams.ContainsKey(key))
 				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, Options, cancellationToken: cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, this, cancellationToken: cancellationTokenSource.Token);
 
 			subscriptionStreams.TryAdd(key, observable);
 			return observable;
@@ -88,7 +88,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			if (subscriptionStreams.ContainsKey(key))
 				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, Options, exceptionHandler, cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, this, exceptionHandler, cancellationTokenSource.Token);
 			subscriptionStreams.TryAdd(key, observable);
 			return observable;
 		}
@@ -102,7 +102,8 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 		#region Private Methods
 
 		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			using var httpRequestMessage = this.GenerateHttpRequestMessage(request.SerializeToJson(Options));
+			var preprocessedRequest = await Options.PreprocessRequest(request, this);
+			using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest.SerializeToJson(Options));
 			using var httpResponseMessage = await this.HttpClient.SendAsync(httpRequestMessage, cancellationToken);
 			if (!httpResponseMessage.IsSuccessStatusCode) {
 				throw new GraphQLHttpException(httpResponseMessage);
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index ac5a8314..146ff3f4 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -2,6 +2,7 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Text.Json;
+using System.Threading.Tasks;
 using Dahomey.Json;
 
 namespace GraphQL.Client.Http {
@@ -46,6 +47,10 @@ public class GraphQLHttpClientOptions {
 		/// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
 		/// </summary>
 		public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
-	}
 
+		/// <summary>
+		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
+		/// </summary>
+		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
+	}
 }
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index d43d0026..5a2a348d 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -13,11 +13,12 @@ public static class GraphQLHttpWebsocketHelpers {
 		internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpClientOptions options,
+			GraphQLHttpClient client,
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default) {
 			return Observable.Defer(() =>
 				Observable.Create<GraphQLResponse<TResponse>>(async observer => {
+					await client.Options.PreprocessRequest(request, client);
 					var startRequest = new GraphQLWebSocketRequest {
 						Id = Guid.NewGuid().ToString("N"),
 						Type = GraphQLWebSocketMessageType.GQL_START,
@@ -48,7 +49,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
 									var typedResponse =
 										JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
-											options.JsonSerializerOptions);
+											client.Options.JsonSerializerOptions);
 									o.OnNext(typedResponse.Payload);
 
 									// in case of a GraphQL error, terminate the sequence after the response has been posted
@@ -154,50 +155,51 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 		internal static Task<GraphQLResponse<TResponse>> Request<TResponse>(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpClientOptions options,
+			GraphQLHttpClient client,
 			CancellationToken cancellationToken = default) {
 			return Observable.Create<GraphQLResponse<TResponse>>(async observer => {
-				var websocketRequest = new GraphQLWebSocketRequest {
-					Id = Guid.NewGuid().ToString("N"),
-					Type = GraphQLWebSocketMessageType.GQL_START,
-					Payload = request
-				};
-				var observable = graphQlHttpWebSocket.ResponseStream
-					.Where(response => response != null && response.Id == websocketRequest.Id)
-					.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-					.Select(response => {
-						Debug.WriteLine($"received response for request {websocketRequest.Id}");
-						var typedResponse =
-							JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
-								options.JsonSerializerOptions);
-						return typedResponse.Payload;
-					});
-
-				try {
-					// intialize websocket (completes immediately if socket is already open)
-					await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
-				}
-				catch (Exception e) {
-					// subscribe observer to failed observable
-					return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-				}
-
-				var disposable = new CompositeDisposable(
-					observable.Subscribe(observer)
-				);
-
-				Debug.WriteLine($"submitting request {websocketRequest.Id}");
-				// send request
-				try {
-					await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
-				}
-				catch (Exception e) {
-					Console.WriteLine(e);
-					throw;
-				}
-
-				return disposable;
-			})
+					await client.Options.PreprocessRequest(request, client);
+					var websocketRequest = new GraphQLWebSocketRequest {
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GraphQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var observable = graphQlHttpWebSocket.ResponseStream
+						.Where(response => response != null && response.Id == websocketRequest.Id)
+						.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+						.Select(response => {
+							Debug.WriteLine($"received response for request {websocketRequest.Id}");
+							var typedResponse =
+								JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
+									client.Options.JsonSerializerOptions);
+							return typedResponse.Payload;
+						});
+
+					try {
+						// intialize websocket (completes immediately if socket is already open)
+						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+					}
+					catch (Exception e) {
+						// subscribe observer to failed observable
+						return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+					}
+
+					var disposable = new CompositeDisposable(
+						observable.Subscribe(observer)
+					);
+
+					Debug.WriteLine($"submitting request {websocketRequest.Id}");
+					// send request
+					try {
+						await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
+					}
+					catch (Exception e) {
+						Console.WriteLine(e);
+						throw;
+					}
+
+					return disposable;
+				})
 			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 			.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
 				Observable.Empty<GraphQLResponse<TResponse>>())

From fe6d8992905c2e1a8784d2cf4dd7631083029462 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 14:48:11 +0100
Subject: [PATCH 110/455] minor refactoring

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs                | 2 +-
 .../Websocket/GraphQLHttpWebsocketHelpers.cs                | 2 +-
 .../{SubscriptionsTest.cs => WebsocketTest.cs}              | 6 ++----
 3 files changed, 4 insertions(+), 6 deletions(-)
 rename tests/GraphQL.Integration.Tests/{SubscriptionsTest.cs => WebsocketTest.cs} (98%)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 32ad6ea7..43705941 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -53,7 +53,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 		/// <inheritdoc />
 		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request<TResponse>(request, this, cancellationToken)
+				? this.graphQlHttpWebSocket.SendRequest<TResponse>(request, this, cancellationToken)
 				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
index 5a2a348d..4d929a83 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -152,7 +152,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 				.Publish().RefCount();
 		}
 
-		internal static Task<GraphQLResponse<TResponse>> Request<TResponse>(
+		internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
 			GraphQLHttpClient client,
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
similarity index 98%
rename from tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
rename to tests/GraphQL.Integration.Tests/WebsocketTest.cs
index a70a000c..3e5eafb1 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
@@ -12,14 +12,12 @@
 using Xunit.Abstractions;
 
 namespace GraphQL.Integration.Tests {
-	public class SubscriptionsTest {
+	public class WebsocketTest {
 		private readonly ITestOutputHelper output;
 
 		private static IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
 
-		private static TimeSpan WaitForConnectionDelay = TimeSpan.FromMilliseconds(200);
-
-		public SubscriptionsTest(ITestOutputHelper output) {
+		public WebsocketTest(ITestOutputHelper output) {
 			this.output = output;
 		}
 		

From 9e608af38dd19f3f669173f66ae589b45599ce9c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 16:01:59 +0100
Subject: [PATCH 111/455] add action to GraphQLHttpRequest which allows
 modificatio of the request prior to sending it

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs  | 13 ++++++++----
 src/GraphQL.Client.Http/GraphQLHttpRequest.cs | 17 +++++++++++++++
 .../Helpers/WebHostHelpers.cs                 |  2 +-
 .../QueryAndMutationTests.cs                  | 21 +++++++++++++++++++
 4 files changed, 48 insertions(+), 5 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index 43705941..b9064fd6 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -103,7 +103,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
 		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			var preprocessedRequest = await Options.PreprocessRequest(request, this);
-			using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest.SerializeToJson(Options));
+			using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest);
 			using var httpResponseMessage = await this.HttpClient.SendAsync(httpRequestMessage, cancellationToken);
 			if (!httpResponseMessage.IsSuccessStatusCode) {
 				throw new GraphQLHttpException(httpResponseMessage);
@@ -113,10 +113,15 @@ private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TRespons
 			return await bodyStream.DeserializeFromJsonAsync<GraphQLHttpResponse<TResponse>>(Options, cancellationToken);
 		}
 
-		private HttpRequestMessage GenerateHttpRequestMessage(string requestString) {
-			return new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
-				Content = new StringContent(requestString, Encoding.UTF8, "application/json")
+		private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request) {
+			var message = new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
+				Content = new StringContent(request.SerializeToJson(Options), Encoding.UTF8, "application/json")
 			};
+
+			if (request is GraphQLHttpRequest httpRequest)
+				httpRequest.PreprocessHttpRequestMessage(message);
+
+			return message;
 		}
 
 		private Uri GetWebSocketUri() {
diff --git a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
index 635d8da7..59cac335 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpRequest.cs
@@ -1,5 +1,22 @@
+using System;
+using System.Net.Http;
+using System.Text.Json.Serialization;
+
 namespace GraphQL.Client.Http {
 
 	public class GraphQLHttpRequest : GraphQLRequest {
+		public GraphQLHttpRequest()
+		{
+		}
+
+		public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null) : base(query, variables, operationName)
+		{
+		}
+
+		/// <summary>
+		/// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
+		/// </summary>
+		[JsonIgnore]
+		public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index bd737a67..8c32f558 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -50,7 +50,7 @@ public static TestServerSetup SetupTest<TStartup>(bool requestsViaWebsocket = fa
 	public class TestServerSetup : IDisposable
 	{
 		public IWebHost Server { get; set; }
-		public IGraphQLClient Client { get; set; }
+		public GraphQLHttpClient Client { get; set; }
 		public void Dispose()
 		{
 			Server?.Dispose();
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
index a44134e5..64ec475a 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
@@ -1,4 +1,6 @@
+using System.Net.Http;
 using GraphQL.Client;
+using GraphQL.Client.Http;
 using GraphQL.Integration.Tests.Helpers;
 using GraphQL.Integration.Tests.TestData;
 using IntegrationTestServer;
@@ -111,5 +113,24 @@ query Human($id: String!){
 				Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
 			}
 		}
+
+		[Fact]
+		public async void PreprocessHttpRequestMessageIsCalled() {
+			var callbackTester = new CallbackTester<HttpRequestMessage>();
+			var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}") {
+				PreprocessHttpRequestMessage = callbackTester.Callback
+			};
+
+			using (var setup = SetupTest()) {
+				var defaultHeaders = setup.Client.HttpClient.DefaultRequestHeaders;
+				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
+					.ConfigureAwait(false);
+				callbackTester.CallbackShouldHaveBeenInvoked(message => {
+					Assert.Equal(defaultHeaders, message.Headers);
+				});
+				Assert.Null(response.Errors);
+				Assert.Equal("Luke", response.Data.Human.Name);
+			}
+		}
 	}
 }

From c96e8e7cd965f59fa5862c18dfa86c93af1ca778 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 5 Feb 2020 17:57:50 +0100
Subject: [PATCH 112/455] target netcoreapp3.1 and net461 for
 GraphQL.Client.Http and remove unnecessary dependencies there

---
 root.props                                    |  2 +-
 .../GraphQL.Client.Http.csproj                | 21 +++++++++++++++----
 .../GraphQLHttpClientOptions.cs               |  1 +
 .../Websocket/GraphQLHttpWebSocket.cs         | 20 +++++++++++++-----
 src/GraphQL.Client/GraphQL.Client.csproj      |  2 --
 5 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/root.props b/root.props
index 0307b880..2c0a5b7d 100644
--- a/root.props
+++ b/root.props
@@ -8,7 +8,7 @@
 		<GenerateDocumentationFile>True</GenerateDocumentationFile>
 		<LangVersion>8.0</LangVersion>
 		<NeutralLanguage>en-US</NeutralLanguage>
-		<NoWarn>CS0618;CS1591;CS1701;CS8618;NU5048;NU5105;NU5125</NoWarn>
+		<NoWarn>CS0618;CS1591;CS1701;CS8618;CS8632;NU5048;NU5105;NU5125</NoWarn>
 		<Nullable>annotations</Nullable>
 		<PackageIcon>icon.png</PackageIcon>
 		<PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
diff --git a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
index 5d72a44c..fcac32b3 100644
--- a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
+++ b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
@@ -3,19 +3,32 @@
 	<Import Project="../src.props" />
 
     <PropertyGroup>
-		<TargetFramework>netstandard2.0</TargetFramework>
+		<TargetFrameworks>netstandard2.0;netcoreapp3.1;net461</TargetFrameworks>
     </PropertyGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\GraphQL.Client\GraphQL.Client.csproj" />
     </ItemGroup>
 
+	<PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+		<DefineConstants>NETSTANDARD</DefineConstants>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(TargetFramework)' == 'net461'">
+		<DefineConstants>NETFRAMEWORK</DefineConstants>
+	</PropertyGroup>
+
+
 	<ItemGroup>
 		<PackageReference Include="Dahomey.Json" Version="1.6.0" />
-		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-		<PackageReference Include="System.Net.Http" Version="4.3.4" />
-		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+	</ItemGroup>
+
+	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net461'">
 		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 	</ItemGroup>
 
+	<ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
+		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
+	</ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index 146ff3f4..d1c139f4 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -52,5 +52,6 @@ public class GraphQLHttpClientOptions {
 		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
 		/// </summary>
 		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
+
 	}
 }
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
index 7098a8e5..1546092b 100644
--- a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
@@ -24,7 +24,11 @@ internal class GraphQLHttpWebSocket : IDisposable {
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
+#if NETFRAMEWORK
 		private WebSocket clientWebSocket = null;
+#else
+		private ClientWebSocket clientWebSocket = null;
+#endif
 		private int _connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options) {
@@ -71,7 +75,7 @@ await this.clientWebSocket.SendAsync(
 
 		private readonly object _initializeLock = new object();
 
-		#region Private Methods
+#region Private Methods
 
 		private Task _backOff() {
 			_connectionAttempt++;
@@ -103,6 +107,7 @@ public Task InitializeWebSocket() {
 				//_responseStreamConnection?.Dispose();
 				clientWebSocket?.Dispose();
 
+#if NETFRAMEWORK
 				// fix websocket not supported on win 7 using
 				// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
 				clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
@@ -120,7 +125,12 @@ public Task InitializeWebSocket() {
 					default:
 						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
 				}
-
+#else
+				clientWebSocket = new ClientWebSocket();
+				clientWebSocket.Options.AddSubProtocol("graphql-ws");
+				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)_options.HttpMessageHandler).ClientCertificates;
+				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)_options.HttpMessageHandler).UseDefaultCredentials;
+#endif
 				return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 			}
 		}
@@ -247,9 +257,9 @@ private async Task _closeAsync(CancellationToken cancellationToken = default) {
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
 		}
 
-		#endregion
+#endregion
 
-		#region IDisposable
+#region IDisposable
 
 		private Task _disposed;
 		private object _disposedLocker = new object();
@@ -269,6 +279,6 @@ private async Task DisposeAsync() {
 			_cancellationTokenSource.Dispose();
 			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
 		}
-		#endregion
+#endregion
 	}
 }
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index bc004365..78633fd1 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -12,8 +12,6 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
-		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
         <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
 	</ItemGroup>

From e1c8f3b1ac5ffbfcec9dbf6d36f1aad6bcacf65b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 11:03:08 +0100
Subject: [PATCH 113/455] use JsonElement as return type for Extensions

---
 .../GraphQLExtensionsConverter.cs             |  8 ++++
 .../GraphQLHttpClientOptions.cs               | 24 +++++++++--
 .../GraphQLSerializationExtensions.cs         | 11 +++++
 src/GraphQL.Client/GraphQL.Client.csproj      |  1 +
 src/GraphQL.Client/GraphQLResponse.cs         | 11 ++---
 .../GraphQL.Primitives.csproj                 |  4 +-
 src/GraphQL.Primitives/GraphQLError.cs        |  9 ++--
 .../GraphQLExtensionsType.cs                  |  5 +++
 .../GraphQL.Client.Http.Tests.csproj          |  1 +
 .../JsonSerializationTests.cs                 |  8 +++-
 .../ExtensionsTest.cs                         | 43 +++++++++++++++++++
 .../GraphQL.Integration.Tests.csproj          |  1 +
 .../ChatSchema/ChatQuery.cs                   | 17 ++++++++
 13 files changed, 128 insertions(+), 15 deletions(-)
 create mode 100644 src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs
 create mode 100644 src/GraphQL.Primitives/GraphQLExtensionsType.cs
 create mode 100644 tests/GraphQL.Integration.Tests/ExtensionsTest.cs

diff --git a/src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs
new file mode 100644
index 00000000..a2d25cfb
--- /dev/null
+++ b/src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs
@@ -0,0 +1,8 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Client.Http {
+	class GraphQLExtensionsConverter {
+	}
+}
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index d1c139f4..604c2017 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -4,6 +4,7 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using Dahomey.Json;
+using Dahomey.Json.Serialization.Converters.Factories;
 
 namespace GraphQL.Client.Http {
 
@@ -20,9 +21,7 @@ public class GraphQLHttpClientOptions {
 		/// <summary>
 		/// The <see cref="JsonSerializerOptions"/> that is going to be used
 		/// </summary>
-		public JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions {
-			PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-		}.SetupExtensions();
+		public JsonSerializerOptions JsonSerializerOptions { get; set; } = GetDefaultJsonSerializerOptions();
 
 		/// <summary>
 		/// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
@@ -53,5 +52,24 @@ public class GraphQLHttpClientOptions {
 		/// </summary>
 		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
 
+		/// <summary>
+		/// Generates the default <see cref="JsonSerializerOptions"/>
+		/// </summary>
+		/// <returns></returns>
+		public static JsonSerializerOptions GetDefaultJsonSerializerOptions() {
+			var options = new JsonSerializerOptions {
+				PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+			};
+
+			//options.Converters.Add(new JsonSerializerOptionsState(options));
+			//options.Converters.Add(new DictionaryConverterFactory());
+			//options.Converters.Add(new CollectionConverterFactory());
+			//options.Converters.Add(new JsonNodeConverterFactory());
+			//options.Converters.Add(new ObjectConverterFactory());
+
+			options.SetupExtensions();
+
+			return options;
+		}
 	}
 }
diff --git a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
index a0a6d271..758a8245 100644
--- a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
+++ b/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
@@ -2,6 +2,8 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using Dahomey.Json;
+using Dahomey.Json.Serialization.Converters.Factories;
 
 namespace GraphQL.Client.Http {
 	public static class GraphQLSerializationExtensions {
@@ -21,5 +23,14 @@ public static ValueTask<TGraphQLResponse> DeserializeFromJsonAsync<TGraphQLRespo
 			return JsonSerializer.DeserializeAsync<TGraphQLResponse>(stream, options.JsonSerializerOptions, cancellationToken);
 		}
 
+		public static JsonSerializerOptions SetupDahomeyJson(this JsonSerializerOptions options) {
+			options.Converters.Add(new JsonSerializerOptionsState(options));
+			options.Converters.Add(new DictionaryConverterFactory());
+			options.Converters.Add(new CollectionConverterFactory());
+			//options.Converters.Add(new JsonNodeConverterFactory());
+			options.Converters.Add(new ObjectConverterFactory());
+
+			return options;
+		}
 	}
 }
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 78633fd1..1c883480 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -12,6 +12,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
+		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
         <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
 	</ItemGroup>
diff --git a/src/GraphQL.Client/GraphQLResponse.cs b/src/GraphQL.Client/GraphQLResponse.cs
index 81c163d5..a27d459d 100644
--- a/src/GraphQL.Client/GraphQLResponse.cs
+++ b/src/GraphQL.Client/GraphQLResponse.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.Json;
 
 namespace GraphQL.Client {
 
@@ -10,14 +11,14 @@ public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
 
 		public GraphQLError[]? Errors { get; set; }
 
-		public IDictionary<string, dynamic>? Extensions { get; set; }
+		public JsonElement? Extensions { get; set; }
 
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
 
 		public bool Equals(GraphQLResponse<T>? other) {
 			if (other == null) { return false; }
 			if (ReferenceEquals(this, other)) { return true; }
-			if (!EqualityComparer<dynamic?>.Default.Equals(this.Data, other.Data)) { return false; }
+			if (!EqualityComparer<T>.Default.Equals(this.Data, other.Data)) { return false; }
 			{
 				if (this.Errors != null && other.Errors != null) {
 					if (!Enumerable.SequenceEqual(this.Errors, other.Errors)) { return false; }
@@ -25,13 +26,13 @@ public bool Equals(GraphQLResponse<T>? other) {
 				else if (this.Errors != null && other.Errors == null) { return false; }
 				else if (this.Errors == null && other.Errors != null) { return false; }
 			}
-			if (!EqualityComparer<IDictionary<string, dynamic>?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
+			if (!EqualityComparer<JsonElement?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
 			return true;
 		}
 
 		public override int GetHashCode() {
 			unchecked {
-				var hashCode = EqualityComparer<dynamic?>.Default.GetHashCode(this.Data);
+				var hashCode = EqualityComparer<T>.Default.GetHashCode(this.Data);
 				{
 					if (this.Errors != null) {
 						foreach (var element in this.Errors) {
@@ -42,7 +43,7 @@ public override int GetHashCode() {
 						hashCode = (hashCode * 397) ^ 0;
 					}
 				}
-				hashCode = (hashCode * 397) ^ EqualityComparer<IDictionary<string, dynamic>?>.Default.GetHashCode(this.Extensions);
+				hashCode = (hashCode * 397) ^ EqualityComparer<JsonElement?>.Default.GetHashCode(this.Extensions);
 				return hashCode;
 			}
 		}
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index ca03991d..aecb7aea 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -5,11 +5,11 @@
 	<PropertyGroup>
 		<Description>GraphQL basic types</Description>
 		<RootNamespace>GraphQL</RootNamespace>
-		<TargetFrameworks>netstandard1.0;netstandard2.0</TargetFrameworks>
+		<TargetFramework>netstandard2.0</TargetFramework>
 	</PropertyGroup>
 
 	<ItemGroup>
 		<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 	</ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 6ccdd39c..3ad80ed0 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.Json;
 
 namespace GraphQL {
 
@@ -12,7 +13,7 @@ public class GraphQLError : IEquatable<GraphQLError?> {
 		/// <summary>
 		/// The extensions of the error
 		/// </summary>
-		public IDictionary<string, dynamic?>? Extensions { get; set; }
+		public JsonElement? Extensions { get; set; }
 
 		/// <summary>
 		/// The locations of the error
@@ -27,7 +28,7 @@ public class GraphQLError : IEquatable<GraphQLError?> {
 		/// <summary>
 		/// The Path of the error
 		/// </summary>
-		public dynamic[]? Path { get; set; }
+		public object[]? Path { get; set; }
 
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
@@ -45,7 +46,7 @@ public override bool Equals(object? obj) =>
 		public bool Equals(GraphQLError? other) {
 			if (other == null) { return false; }
 			if (ReferenceEquals(this, other)) { return true; }
-			if (!EqualityComparer<IDictionary<string, dynamic?>?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
+			if (!EqualityComparer<JsonElement?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
 			{
 				if (this.Locations != null && other.Locations != null) {
 					if (!this.Locations.SequenceEqual(other.Locations)) { return false; }
@@ -70,7 +71,7 @@ public bool Equals(GraphQLError? other) {
 		public override int GetHashCode() {
 			var hashCode = 0;
 			if (this.Extensions != null) {
-				hashCode = hashCode ^ EqualityComparer<IDictionary<string, dynamic?>>.Default.GetHashCode(this.Extensions);
+				hashCode = hashCode ^ EqualityComparer<JsonElement?>.Default.GetHashCode(this.Extensions);
 			}
 			if (this.Locations != null) {
 				hashCode = hashCode ^ EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(this.Locations);
diff --git a/src/GraphQL.Primitives/GraphQLExtensionsType.cs b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
new file mode 100644
index 00000000..d750eeb8
--- /dev/null
+++ b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
@@ -0,0 +1,5 @@
+using System.Collections.Generic;
+
+namespace GraphQL {
+	public class GraphQLExtensionsType: Dictionary<string, object> { }
+}
diff --git a/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj b/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
index 64ce8f5e..c0b659da 100644
--- a/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
+++ b/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
@@ -7,6 +7,7 @@
 	</PropertyGroup>
 
     <ItemGroup>
+		<PackageReference Include="FluentAssertions" Version="5.10.0" />
 		<PackageReference Include="Microsoft.AspNetCore.TestHost" Version="3.1.0" />
     </ItemGroup>
 
diff --git a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
index 1f12cff5..74191b15 100644
--- a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
@@ -1,5 +1,7 @@
+using System.Collections.Generic;
 using Xunit;
 using System.Text.Json;
+using FluentAssertions;
 
 namespace GraphQL.Client.Http.Tests {
 	public class JsonSerializationTests {
@@ -9,7 +11,9 @@ public void WebSocketResponseDeserialization() {
 			var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff" };
 			var json = JsonSerializer.Serialize(testObject);
 			var deserialized = JsonSerializer.Deserialize<TestObject>(json);
-
+			var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
+			var childObject = (JsonElement) dict["ChildObject"];
+			childObject.GetProperty("Id").GetString().Should().Be(testObject.ChildObject.Id);
 		}
 
 		public class TestObject {
@@ -19,6 +23,8 @@ public class TestObject {
 
 		public class ExtendedTestObject : TestObject {
 			public string OtherData { get; set; }
+
+			public TestObject ChildObject{ get; set; } = new TestObject {Id = "1337"};
 		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
new file mode 100644
index 00000000..a778d552
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using FluentAssertions;
+using GraphQL.Client;
+using GraphQL.Integration.Tests.Helpers;
+using IntegrationTestServer;
+using IntegrationTestServer.ChatSchema;
+using Xunit;
+
+namespace GraphQL.Integration.Tests {
+	public class ExtensionsTest {
+		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) => WebHostHelpers.SetupTest<StartupChat>(requestsViaWebsocket);
+
+		[Fact]
+		public async void CanDeserializeExtensions() {
+
+			using var setup = SetupTest();
+			var response = await setup.Client.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"), () => new { extensionsTest = "" })
+				.ConfigureAwait(false);
+
+			response.Errors.Should().NotBeNull();
+			response.Errors.Should().ContainSingle();
+			response.Errors[0].Extensions.Should().NotBeNull();
+
+			JsonElement data = new JsonElement();
+			response.Errors[0].Extensions.Value.Invoking(element => data = element.GetProperty("data")).Should().NotThrow();
+
+			foreach (var item in ChatQuery.TestExtensions) {
+				JsonElement value = new JsonElement(); 
+				data.Invoking(element => value = element.GetProperty(item.Key)).Should().NotThrow();
+
+				switch (item.Value) {
+					case int i:
+						value.GetInt32().Should().Be(i);
+						break;
+					default:
+						value.GetString().Should().BeEquivalentTo(item.Value.ToString());
+						break;
+				}
+			}
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index de5a92ca..aaf21a67 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.0" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
     <PackageReference Include="NETStandard.Library" Version="2.0.3" />
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
index 6620c19c..8b423f95 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
+++ b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
@@ -1,10 +1,27 @@
+using System.Collections.Generic;
 using System.Linq;
+using GraphQL;
 using GraphQL.Types;
 
 namespace IntegrationTestServer.ChatSchema {
 	public class ChatQuery : ObjectGraphType {
+
+		public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
+			{"extension1", "hello world"},
+			{"another extension", 4711}
+		};
+
 		public ChatQuery(IChat chat) {
+			Name = "ChatQuery";
+
 			Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+
+			Field<StringGraphType>()
+				.Name("extensionsTest")
+				.Resolve(context => {
+					context.Errors.Add(new ExecutionError("this error contains extension fields", TestExtensions));
+					return null;
+				});
 		}
 	}
 }

From 56005f2af99713f45468158664707d30b61140a5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 11:08:13 +0100
Subject: [PATCH 114/455] test JsonElement as return type

---
 .../QueryAndMutationTests.cs                      | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
index 64ec475a..ca81340f 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
@@ -1,4 +1,5 @@
 using System.Net.Http;
+using System.Text.Json;
 using GraphQL.Client;
 using GraphQL.Client.Http;
 using GraphQL.Integration.Tests.Helpers;
@@ -25,6 +26,20 @@ public async void QueryTheory(int id, string name) {
 			}
 		}
 
+		[Theory]
+		[ClassData(typeof(StarWarsHumans))]
+		public async void QueryWithJsonElementAsReturnTypeTheory(int id, string name) {
+			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+
+			using (var setup = SetupTest()) {
+				var response = await setup.Client.SendQueryAsync<JsonElement>(graphQLRequest)
+					.ConfigureAwait(false);
+
+				Assert.Null(response.Errors);
+				Assert.Equal(name, response.Data.GetProperty("human").GetProperty("name").GetString());
+			}
+		}
+
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
 		public async void QueryWitVarsTheory(int id, string name) {

From 24ac0bf41b2b9156dd4cf4e7e6574268c4c7b6f4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 11:29:25 +0100
Subject: [PATCH 115/455] specify all property names from the GraphQL spec

---
 .../GraphQLExtensionsConverter.cs             |  8 ----
 src/GraphQL.Client/GraphQLResponse.cs         |  4 ++
 src/GraphQL.Primitives/GraphQLError.cs        |  7 +++-
 .../GraphQLExtensionsType.cs                  |  5 ---
 src/GraphQL.Primitives/GraphQLRequest.cs      |  5 +++
 .../ExtensionsTest.cs                         | 39 +++++++++++++++++--
 .../ChatSchema/CapitalizedFieldsGraphType.cs  | 18 +++++++++
 7 files changed, 68 insertions(+), 18 deletions(-)
 delete mode 100644 src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs
 delete mode 100644 src/GraphQL.Primitives/GraphQLExtensionsType.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/CapitalizedFieldsGraphType.cs

diff --git a/src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs
deleted file mode 100644
index a2d25cfb..00000000
--- a/src/GraphQL.Client.Http/GraphQLExtensionsConverter.cs
+++ /dev/null
@@ -1,8 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace GraphQL.Client.Http {
-	class GraphQLExtensionsConverter {
-	}
-}
diff --git a/src/GraphQL.Client/GraphQLResponse.cs b/src/GraphQL.Client/GraphQLResponse.cs
index a27d459d..64c28ac5 100644
--- a/src/GraphQL.Client/GraphQLResponse.cs
+++ b/src/GraphQL.Client/GraphQLResponse.cs
@@ -2,15 +2,19 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace GraphQL.Client {
 
 	public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
 
+		[JsonPropertyName("data")]
 		public T Data { get; set; }
 
+		[JsonPropertyName("errors")]
 		public GraphQLError[]? Errors { get; set; }
 
+		[JsonPropertyName("extensions")]
 		public JsonElement? Extensions { get; set; }
 
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 3ad80ed0..82a80ddc 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace GraphQL {
 
@@ -12,22 +13,26 @@ public class GraphQLError : IEquatable<GraphQLError?> {
 
 		/// <summary>
 		/// The extensions of the error
-		/// </summary>
+		/// </summary> 
+		[JsonPropertyName("extensions")]
 		public JsonElement? Extensions { get; set; }
 
 		/// <summary>
 		/// The locations of the error
 		/// </summary>
+		[JsonPropertyName("locations")]
 		public GraphQLLocation[]? Locations { get; set; }
 
 		/// <summary>
 		/// The message of the error
 		/// </summary>
+		[JsonPropertyName("message")]
 		public string Message { get; set; }
 
 		/// <summary>
 		/// The Path of the error
 		/// </summary>
+		[JsonPropertyName("path")]
 		public object[]? Path { get; set; }
 
 		/// <summary>
diff --git a/src/GraphQL.Primitives/GraphQLExtensionsType.cs b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
deleted file mode 100644
index d750eeb8..00000000
--- a/src/GraphQL.Primitives/GraphQLExtensionsType.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-using System.Collections.Generic;
-
-namespace GraphQL {
-	public class GraphQLExtensionsType: Dictionary<string, object> { }
-}
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index dd8a180a..95bf8eae 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Text.Json.Serialization;
 
 namespace GraphQL {
 
@@ -11,16 +12,20 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		/// <summary>
 		/// The Query
 		/// </summary>
+		/// 
+		[JsonPropertyName("query")]
 		public string Query { get; set; }
 
 		/// <summary>
 		/// The name of the Operation
 		/// </summary>
+		[JsonPropertyName("operationName")]
 		public string? OperationName { get; set; }
 
 		/// <summary>
 		/// Represents the request variables
 		/// </summary>
+		[JsonPropertyName("variables")]
 		public virtual object? Variables { get; set; }
 
 
diff --git a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
index a778d552..f3dfa126 100644
--- a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
@@ -1,7 +1,10 @@
+using System;
 using System.Collections.Generic;
 using System.Text.Json;
+using Dahomey.Json;
 using FluentAssertions;
 using GraphQL.Client;
+using GraphQL.Integration.Tests.Extensions;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
 using IntegrationTestServer.ChatSchema;
@@ -9,13 +12,15 @@
 
 namespace GraphQL.Integration.Tests {
 	public class ExtensionsTest {
-		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) => WebHostHelpers.SetupTest<StartupChat>(requestsViaWebsocket);
+		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) =>
+			WebHostHelpers.SetupTest<StartupChat>(requestsViaWebsocket);
 
 		[Fact]
 		public async void CanDeserializeExtensions() {
 
 			using var setup = SetupTest();
-			var response = await setup.Client.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"), () => new { extensionsTest = "" })
+			var response = await setup.Client.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
+					() => new {extensionsTest = ""})
 				.ConfigureAwait(false);
 
 			response.Errors.Should().NotBeNull();
@@ -23,10 +28,11 @@ public async void CanDeserializeExtensions() {
 			response.Errors[0].Extensions.Should().NotBeNull();
 
 			JsonElement data = new JsonElement();
-			response.Errors[0].Extensions.Value.Invoking(element => data = element.GetProperty("data")).Should().NotThrow();
+			response.Errors[0].Extensions.Value.Invoking(element => data = element.GetProperty("data")).Should()
+				.NotThrow();
 
 			foreach (var item in ChatQuery.TestExtensions) {
-				JsonElement value = new JsonElement(); 
+				JsonElement value = new JsonElement();
 				data.Invoking(element => value = element.GetProperty(item.Key)).Should().NotThrow();
 
 				switch (item.Value) {
@@ -39,5 +45,30 @@ public async void CanDeserializeExtensions() {
 				}
 			}
 		}
+
+		[Fact]
+		public async void DontNeedToUseCamelCaseNamingStrategy() {
+
+			using var setup = SetupTest();
+			setup.Client.Options.JsonSerializerOptions = new JsonSerializerOptions().SetupExtensions();
+
+			const string message = "some random testing message";
+			var graphQLRequest = new GraphQLRequest(
+				@"mutation($input: MessageInputType){
+				  addMessage(message: $input){
+				    content
+				  }
+				}",
+				new {
+					input = new {
+						fromId = "2",
+						content = message,
+						sentAt = DateTime.Now
+					}
+				});
+			var response = await setup.Client.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
+
+			Assert.Equal(message, response.Data.addMessage.content);
+		}
 	}
 }
diff --git a/tests/IntegrationTestServer/ChatSchema/CapitalizedFieldsGraphType.cs b/tests/IntegrationTestServer/ChatSchema/CapitalizedFieldsGraphType.cs
new file mode 100644
index 00000000..32b235e5
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/CapitalizedFieldsGraphType.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Metadata.Ecma335;
+using System.Threading.Tasks;
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema {
+	public class CapitalizedFieldsGraphType: ObjectGraphType {
+		public CapitalizedFieldsGraphType() {
+			Name = "CapitalizedFields";
+
+			Field<StringGraphType>()
+				.Name("StringField")
+				.Resolve(context => "hello world");
+		}
+	}
+}

From 9265c239170822028f55496d1e58e4b803e31f34 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 11:31:24 +0100
Subject: [PATCH 116/455] convert field BackOffStrategy to property

---
 src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index 604c2017..b0fa28b4 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -37,7 +37,7 @@ public class GraphQLHttpClientOptions {
 		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
 		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
 		/// </summary>
-		public Func<int, TimeSpan> BackOffStrategy = n => {
+		public Func<int, TimeSpan> BackOffStrategy { get; set; } = n => {
 			var rnd = new Random();
 			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
 		};

From 32660ea0fbd372a0e9386d50e0a6094f1e9f4764 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 11:34:26 +0100
Subject: [PATCH 117/455] use media type from options

---
 src/GraphQL.Client.Http/GraphQLHttpClient.cs        | 2 +-
 src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
index b9064fd6..9a55c77e 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClient.cs
@@ -115,7 +115,7 @@ private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TRespons
 
 		private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request) {
 			var message = new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
-				Content = new StringContent(request.SerializeToJson(Options), Encoding.UTF8, "application/json")
+				Content = new StringContent(request.SerializeToJson(Options), Encoding.UTF8, Options.MediaType)
 			};
 
 			if (request is GraphQLHttpRequest httpRequest)
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
index b0fa28b4..2eda001e 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
@@ -31,7 +31,7 @@ public class GraphQLHttpClientOptions {
 		/// <summary>
 		/// The <see cref="MediaTypeHeaderValue"/> that will be send on POST
 		/// </summary>
-		public MediaTypeHeaderValue MediaType { get; set; } = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
+		public string MediaType { get; set; } = "application/json"; // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
 		/// <summary>
 		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>

From d37188f1b385aac59f0ca4a0928d1c4d3982016f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 12:14:16 +0100
Subject: [PATCH 118/455] fix dependencies

---
 src/GraphQL.Client/GraphQL.Client.csproj         | 8 +++++---
 src/GraphQL.Primitives/GraphQL.Primitives.csproj | 5 ++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 1c883480..215ef4b2 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -4,7 +4,7 @@
 
 	<PropertyGroup>
 		<Description>A GraphQL Client</Description>
-		<TargetFrameworks>netstandard2.0</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -12,9 +12,11 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
-        <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+	</ItemGroup>
+
+	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 	</ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index aecb7aea..add49e13 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -5,11 +5,10 @@
 	<PropertyGroup>
 		<Description>GraphQL basic types</Description>
 		<RootNamespace>GraphQL</RootNamespace>
-		<TargetFramework>netstandard2.0</TargetFramework>
+		<TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
 	</PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
 		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 	</ItemGroup>
 </Project>

From 87422593b1e6633b6bfa7b39509b3975b9fefbd7 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 13:14:41 +0100
Subject: [PATCH 119/455] try to push packages with nuget cli

---
 .github/workflows/main.yml | 22 ++++++++++++++--------
 GraphQL.Client.sln         |  3 ++-
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 1f04b3dc..de49bee4 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -91,13 +91,19 @@ jobs:
       uses: actions/download-artifact@v1
       with:
         name: nupkg
-    - name: Setup GitHub Packages as nuget source
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+    - name: Setup Nuget.exe
+      uses: warrenbuckley/Setup-Nuget@v1
+    - name: Configure package source
+      run: nuget sources Add -Name "GPR" -Source https://nuget.pkg.github.com/graphql-dotnet/index.json -UserName graphql-dotnet -Password ${{secrets.GITHUB_TOKEN}}
     - name: push packages
-      run: dotnet nuget push .\nupkg\*.nupkg --skip-duplicate -k ${{secrets.GITHUB_TOKEN}}
+      run: nuget push .\nupkg\*.nupkg -SkipDuplicate
+    # - name: Setup GitHub Packages as nuget source
+    #   uses: actions/setup-dotnet@master
+    #   with:
+    #     dotnet-version: '3.1.100'
+    #     source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
+    #   env:
+    #     NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+    # - name: push packages
+    #   run: dotnet nuget push .\nupkg\*.nupkg --skip-duplicate -k ${{secrets.GITHUB_TOKEN}}
     
\ No newline at end of file
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 5bf6b3e9..f5c685df 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -42,7 +42,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{C421
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{05CAF9B2-981E-40C0-AE31-5FA56E351F12}"
 	ProjectSection(SolutionItems) = preProject
-		.github\workflows\workflow.yml = .github\workflows\workflow.yml
+		.github\workflows\branches.yml = .github\workflows\branches.yml
+		.github\workflows\main.yml = .github\workflows\main.yml
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Http", "src\GraphQL.Client.Http\GraphQL.Client.Http.csproj", "{FA10201B-AE2A-4BFC-8E8F-6F944680974D}"

From e9dc4e776bb1aeb6050e25b2248f1fae24043328 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 13:15:17 +0100
Subject: [PATCH 120/455] add source to nuget push

---
 .github/workflows/main.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index de49bee4..4c578799 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -96,7 +96,7 @@ jobs:
     - name: Configure package source
       run: nuget sources Add -Name "GPR" -Source https://nuget.pkg.github.com/graphql-dotnet/index.json -UserName graphql-dotnet -Password ${{secrets.GITHUB_TOKEN}}
     - name: push packages
-      run: nuget push .\nupkg\*.nupkg -SkipDuplicate
+      run: nuget push .\nupkg\*.nupkg -SkipDuplicate -Source "GPR"
     # - name: Setup GitHub Packages as nuget source
     #   uses: actions/setup-dotnet@master
     #   with:

From ae4de10d8ca23e5517316c9c758a3c08d42d8fc6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 13:22:43 +0100
Subject: [PATCH 121/455] fix gitversion error

---
 .github/workflows/main.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 4c578799..dd2dc3e3 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -25,6 +25,8 @@ jobs:
       run: git fetch
     - name: Generate version info from git history
       run: dotnet dotnet-gitversion /output json | Out-File gitversion.json; Get-Content gitversion.json
+      env:
+        IGNORE_NORMALISATION_GIT_HEAD_MOVE: 1
     - name: Upload version info file
       uses: actions/upload-artifact@v1
       with:

From 45b4e69f6e1aa0857b275285d1f9144fc718b26f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 13:40:22 +0100
Subject: [PATCH 122/455] add GitVersion.yml

---
 GitVersion.yml | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 GitVersion.yml

diff --git a/GitVersion.yml b/GitVersion.yml
new file mode 100644
index 00000000..2210324b
--- /dev/null
+++ b/GitVersion.yml
@@ -0,0 +1 @@
+mode: ContinuousDeployment

From 3501cb9c8ce45651cd167e1c3d84c4e73989fa60 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 6 Feb 2020 13:42:45 +0100
Subject: [PATCH 123/455] only use ContinuousDeployment mode for develop and
 release

---
 GitVersion.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/GitVersion.yml b/GitVersion.yml
index 2210324b..4b1b821f 100644
--- a/GitVersion.yml
+++ b/GitVersion.yml
@@ -1 +1,3 @@
-mode: ContinuousDeployment
+branches:   
+  release:
+    mode: ContinuousDeployment

From 0a2b08a2cf1b655c4f6a4d418a82c541b4cfb187 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 21:10:35 +0100
Subject: [PATCH 124/455] cleanup and rename packages

---
 GraphQL.Client.sln                            |  45 ++--
 .../GraphQL.Client.Http.Examples.csproj       |   2 +-
 .../GraphQL.Client.Abstractions.csproj        |  23 ++
 .../GraphQLClientExtensions.cs                |   2 +-
 .../IGraphQLClient.cs                         |   2 +-
 .../GraphQL.Client.Http.csproj                |  34 ---
 src/GraphQL.Client/GraphQL.Client.csproj      |  29 ++-
 src/GraphQL.Client/GraphQLException.cs        |  15 --
 .../GraphQLHttpClient.cs                      |   1 +
 .../GraphQLHttpClientExtensions.cs            |   1 +
 .../GraphQLHttpClientOptions.cs               |   0
 .../GraphQLHttpException.cs                   |   0
 .../GraphQLHttpRequest.cs                     |   0
 .../GraphQLHttpResponse.cs                    |   0
 .../GraphQLSerializationExtensions.cs         |   0
 .../GraphQLSubscriptionException.cs           |   0
 .../HttpClientExtensions.cs                   |   0
 .../Websocket/GraphQLHttpWebSocket.cs         |   0
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  |   0
 .../Websocket/GraphQLWebSocketMessageType.cs  |   0
 .../Websocket/GraphQLWebSocketRequest.cs      |   0
 .../Websocket/GraphQLWebSocketResponse.cs     |   0
 .../Websocket/WebsocketResponseWrapper.cs     |   0
 .../GraphQLResponse.cs                        |   2 +-
 tests/GraphQL.Client.Http.Tests/BaseTest.cs   |  16 --
 .../GraphQL.Client.Http.Tests.csproj          |  18 --
 .../GraphQL.Client.Tests.csproj               |  13 --
 tests/GraphQL.Client.Tests/Model/Person.cs    |  17 --
 .../ExtensionsTest.cs                         |   4 +-
 .../GraphQL.Integration.Tests.csproj          |   1 -
 .../QueryAndMutationTests.cs                  |   2 +-
 .../WebsocketTest.cs                          |   2 +-
 .../GraphQL.Primitives.Tests.csproj           |   8 +
 .../GraphQLLocationTest.cs                    |   0
 .../GraphQLLocationTests.cs                   | 204 ------------------
 .../GraphQLRequestTest.cs                     |   0
 .../GraphQLResponseTest.cs                    |   0
 .../JsonSerializationTests.cs                 |   0
 38 files changed, 75 insertions(+), 366 deletions(-)
 create mode 100644 src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
 rename src/{GraphQL.Client => GraphQL.Client.Abstractions}/GraphQLClientExtensions.cs (98%)
 rename src/{GraphQL.Client => GraphQL.Client.Abstractions}/IGraphQLClient.cs (98%)
 delete mode 100644 src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
 delete mode 100644 src/GraphQL.Client/GraphQLException.cs
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLHttpClient.cs (99%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLHttpClientExtensions.cs (98%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLHttpClientOptions.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLHttpException.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLHttpRequest.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLHttpResponse.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLSerializationExtensions.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/GraphQLSubscriptionException.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/HttpClientExtensions.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/Websocket/GraphQLHttpWebSocket.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/Websocket/GraphQLHttpWebsocketHelpers.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/Websocket/GraphQLWebSocketMessageType.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/Websocket/GraphQLWebSocketRequest.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/Websocket/GraphQLWebSocketResponse.cs (100%)
 rename src/{GraphQL.Client.Http => GraphQL.Client}/Websocket/WebsocketResponseWrapper.cs (100%)
 rename src/{GraphQL.Client => GraphQL.Primitives}/GraphQLResponse.cs (98%)
 delete mode 100644 tests/GraphQL.Client.Http.Tests/BaseTest.cs
 delete mode 100644 tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
 delete mode 100644 tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
 delete mode 100644 tests/GraphQL.Client.Tests/Model/Person.cs
 rename tests/{GraphQL.Client.Tests => GraphQL.Primitives.Tests}/GraphQLLocationTest.cs (100%)
 delete mode 100644 tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
 rename tests/{GraphQL.Client.Tests => GraphQL.Primitives.Tests}/GraphQLRequestTest.cs (100%)
 rename tests/{GraphQL.Client.Tests => GraphQL.Primitives.Tests}/GraphQLResponseTest.cs (100%)
 rename tests/{GraphQL.Client.Http.Tests => GraphQL.Primitives.Tests}/JsonSerializationTests.cs (100%)

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index f5c685df..1b6cc421 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -8,8 +8,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{47C98B55-08F
 		src\src.props = src\src.props
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client", "src\GraphQL.Client\GraphQL.Client.csproj", "{42BEFACE-39F9-4FE4-B725-15CD2B16292E}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{63F75859-4698-4EDE-8B70-4ACBB8BC425A}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
@@ -25,8 +23,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0B0EDB0F
 		tests\tests.props = tests\tests.props
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Tests", "tests\GraphQL.Client.Tests\GraphQL.Client.Tests.csproj", "{FEDAE425-B505-4DD6-98ED-3F8593358FC8}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "assets", "assets", "{6326E0E2-3F48-4BAF-80D3-47AED5EB647C}"
 	ProjectSection(SolutionItems) = preProject
 		assets\logo.64x64.png = assets\logo.64x64.png
@@ -46,10 +42,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{
 		.github\workflows\main.yml = .github\workflows\main.yml
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Http", "src\GraphQL.Client.Http\GraphQL.Client.Http.csproj", "{FA10201B-AE2A-4BFC-8E8F-6F944680974D}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Http.Tests", "tests\GraphQL.Client.Http.Tests\GraphQL.Client.Http.Tests.csproj", "{8F5BBBDA-B3DD-458B-B97F-F67531D323E0}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{D61415CA-D822-43DD-9AE7-993B8B60E855}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Http.Examples", "examples\GraphQL.Client.Http.Examples\GraphQL.Client.Http.Examples.csproj", "{95D78D57-3232-491D-BAD6-F373D76EA34D}"
@@ -62,32 +54,20 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "te
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests", "tests\GraphQL.Integration.Tests\GraphQL.Integration.Tests.csproj", "{C68C26EB-7659-402A-93D1-E6E248DA5427}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Abstractions", "src\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj", "{76E622F6-7CDD-4B1F-AD06-FFABF37C55E5}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client", "src\GraphQL.Client\GraphQL.Client.csproj", "{ED3541C9-D2B2-4D06-A464-38E404A3919A}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{42BEFACE-39F9-4FE4-B725-15CD2B16292E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{42BEFACE-39F9-4FE4-B725-15CD2B16292E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{42BEFACE-39F9-4FE4-B725-15CD2B16292E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{42BEFACE-39F9-4FE4-B725-15CD2B16292E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FEDAE425-B505-4DD6-98ED-3F8593358FC8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FEDAE425-B505-4DD6-98ED-3F8593358FC8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FEDAE425-B505-4DD6-98ED-3F8593358FC8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FEDAE425-B505-4DD6-98ED-3F8593358FC8}.Release|Any CPU.Build.0 = Release|Any CPU
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FA10201B-AE2A-4BFC-8E8F-6F944680974D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FA10201B-AE2A-4BFC-8E8F-6F944680974D}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FA10201B-AE2A-4BFC-8E8F-6F944680974D}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FA10201B-AE2A-4BFC-8E8F-6F944680974D}.Release|Any CPU.Build.0 = Release|Any CPU
-		{8F5BBBDA-B3DD-458B-B97F-F67531D323E0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{8F5BBBDA-B3DD-458B-B97F-F67531D323E0}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{8F5BBBDA-B3DD-458B-B97F-F67531D323E0}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{8F5BBBDA-B3DD-458B-B97F-F67531D323E0}.Release|Any CPU.Build.0 = Release|Any CPU
 		{95D78D57-3232-491D-BAD6-F373D76EA34D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{95D78D57-3232-491D-BAD6-F373D76EA34D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{95D78D57-3232-491D-BAD6-F373D76EA34D}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -108,24 +88,27 @@ Global
 		{C68C26EB-7659-402A-93D1-E6E248DA5427}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C68C26EB-7659-402A-93D1-E6E248DA5427}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C68C26EB-7659-402A-93D1-E6E248DA5427}.Release|Any CPU.Build.0 = Release|Any CPU
+		{76E622F6-7CDD-4B1F-AD06-FFABF37C55E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{76E622F6-7CDD-4B1F-AD06-FFABF37C55E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{76E622F6-7CDD-4B1F-AD06-FFABF37C55E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{76E622F6-7CDD-4B1F-AD06-FFABF37C55E5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{ED3541C9-D2B2-4D06-A464-38E404A3919A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ED3541C9-D2B2-4D06-A464-38E404A3919A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ED3541C9-D2B2-4D06-A464-38E404A3919A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ED3541C9-D2B2-4D06-A464-38E404A3919A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{42BEFACE-39F9-4FE4-B725-15CD2B16292E} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
-		{FEDAE425-B505-4DD6-98ED-3F8593358FC8} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
-		{6326E0E2-3F48-4BAF-80D3-47AED5EB647C} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
-		{C42106CF-F685-4F29-BC18-A70616BD68A0} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
-		{05CAF9B2-981E-40C0-AE31-5FA56E351F12} = {C42106CF-F685-4F29-BC18-A70616BD68A0}
-		{FA10201B-AE2A-4BFC-8E8F-6F944680974D} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
-		{8F5BBBDA-B3DD-458B-B97F-F67531D323E0} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{95D78D57-3232-491D-BAD6-F373D76EA34D} = {D61415CA-D822-43DD-9AE7-993B8B60E855}
 		{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{C212983F-67DB-44EB-BFB0-5DA75A86DF55} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{92107DF5-73DF-4371-8EB1-6734FED704AD} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{C68C26EB-7659-402A-93D1-E6E248DA5427} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{76E622F6-7CDD-4B1F-AD06-FFABF37C55E5} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
+		{ED3541C9-D2B2-4D06-A464-38E404A3919A} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj b/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
index 676c3e72..2f2dea3c 100644
--- a/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
+++ b/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
@@ -11,7 +11,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<ProjectReference Include="..\..\src\GraphQL.Client.Http\GraphQL.Client.Http.csproj" />
+		<ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
 		<ProjectReference Include="..\..\tests\GraphQL.Server.Test\GraphQL.Server.Test.csproj" />
 	</ItemGroup>
 
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
new file mode 100644
index 00000000..4a2c3ac8
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<Import Project="../src.props" />
+
+	<PropertyGroup>
+		<Description>A GraphQL Client</Description>
+		<RootNamespace>GraphQL.Client.Abstractions</RootNamespace>
+		<TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
+	</PropertyGroup>
+
+	<ItemGroup>
+      <ProjectReference Include="..\GraphQL.Primitives\GraphQL.Primitives.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="System.Reactive" Version="4.1.2" />
+	</ItemGroup>
+
+	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+		<PackageReference Include="System.Text.Json" Version="4.7.0" />
+	</ItemGroup>
+
+</Project>
diff --git a/src/GraphQL.Client/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
similarity index 98%
rename from src/GraphQL.Client/GraphQLClientExtensions.cs
rename to src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index d8824a05..5bd30c9d 100644
--- a/src/GraphQL.Client/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -2,7 +2,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client {
+namespace GraphQL.Client.Abstractions {
 	public static class GraphQLClientExtensions {
 		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
 			string query, object? variables = null,
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
similarity index 98%
rename from src/GraphQL.Client/IGraphQLClient.cs
rename to src/GraphQL.Client.Abstractions/IGraphQLClient.cs
index c4565e78..3b47a932 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
@@ -3,7 +3,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client {
+namespace GraphQL.Client.Abstractions {
 
 	public interface IGraphQLClient : IDisposable {
 
diff --git a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj b/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
deleted file mode 100644
index fcac32b3..00000000
--- a/src/GraphQL.Client.Http/GraphQL.Client.Http.csproj
+++ /dev/null
@@ -1,34 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-	<Import Project="../src.props" />
-
-    <PropertyGroup>
-		<TargetFrameworks>netstandard2.0;netcoreapp3.1;net461</TargetFrameworks>
-    </PropertyGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\GraphQL.Client\GraphQL.Client.csproj" />
-    </ItemGroup>
-
-	<PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-		<DefineConstants>NETSTANDARD</DefineConstants>
-	</PropertyGroup>
-
-	<PropertyGroup Condition=" '$(TargetFramework)' == 'net461'">
-		<DefineConstants>NETFRAMEWORK</DefineConstants>
-	</PropertyGroup>
-
-
-	<ItemGroup>
-		<PackageReference Include="Dahomey.Json" Version="1.6.0" />
-	</ItemGroup>
-
-	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net461'">
-		<PackageReference Include="System.Text.Json" Version="4.7.0" />
-	</ItemGroup>
-
-	<ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
-		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
-	</ItemGroup>
-
-</Project>
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 215ef4b2..bcd8d91a 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -2,21 +2,34 @@
 
 	<Import Project="../src.props" />
 
-	<PropertyGroup>
-		<Description>A GraphQL Client</Description>
-		<TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
+    <PropertyGroup>
+		<TargetFrameworks>netstandard2.0;netcoreapp3.1;net461</TargetFrameworks>
+	    <RootNamespace>GraphQL.Client.Http</RootNamespace>
+    </PropertyGroup>
+
+	<PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+		<DefineConstants>NETSTANDARD</DefineConstants>
+	</PropertyGroup>
+
+	<PropertyGroup Condition=" '$(TargetFramework)' == 'net461'">
+		<DefineConstants>NETFRAMEWORK</DefineConstants>
 	</PropertyGroup>
 
-	<ItemGroup>
-      <ProjectReference Include="..\GraphQL.Primitives\GraphQL.Primitives.csproj" />
-	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="System.Reactive" Version="4.1.2" />
+		<PackageReference Include="Dahomey.Json" Version="1.6.0" />
 	</ItemGroup>
 
-	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net461'">
 		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 	</ItemGroup>
 
+	<ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
+		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+	</ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client/GraphQLException.cs b/src/GraphQL.Client/GraphQLException.cs
deleted file mode 100644
index 613ab2ac..00000000
--- a/src/GraphQL.Client/GraphQLException.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System;
-
-namespace GraphQL.Client {
-
-	public class GraphQLException : Exception {
-
-		public GraphQLError[] Errors { get; }
-
-		public GraphQLException(GraphQLError[] errors) : base(errors[0].Message) {
-			this.Errors = errors;
-		}
-
-	}
-
-}
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
similarity index 99%
rename from src/GraphQL.Client.Http/GraphQLHttpClient.cs
rename to src/GraphQL.Client/GraphQLHttpClient.cs
index 9a55c77e..15ff6e8f 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http.Websocket;
 
 namespace GraphQL.Client.Http {
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
similarity index 98%
rename from src/GraphQL.Client.Http/GraphQLHttpClientExtensions.cs
rename to src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index 4535c1e0..405d041c 100644
--- a/src/GraphQL.Client.Http/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Net.WebSockets;
+using GraphQL.Client.Abstractions;
 
 namespace GraphQL.Client.Http {
 	public static class GraphQLHttpClientExtensions {
diff --git a/src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
similarity index 100%
rename from src/GraphQL.Client.Http/GraphQLHttpClientOptions.cs
rename to src/GraphQL.Client/GraphQLHttpClientOptions.cs
diff --git a/src/GraphQL.Client.Http/GraphQLHttpException.cs b/src/GraphQL.Client/GraphQLHttpException.cs
similarity index 100%
rename from src/GraphQL.Client.Http/GraphQLHttpException.cs
rename to src/GraphQL.Client/GraphQLHttpException.cs
diff --git a/src/GraphQL.Client.Http/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
similarity index 100%
rename from src/GraphQL.Client.Http/GraphQLHttpRequest.cs
rename to src/GraphQL.Client/GraphQLHttpRequest.cs
diff --git a/src/GraphQL.Client.Http/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
similarity index 100%
rename from src/GraphQL.Client.Http/GraphQLHttpResponse.cs
rename to src/GraphQL.Client/GraphQLHttpResponse.cs
diff --git a/src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs b/src/GraphQL.Client/GraphQLSerializationExtensions.cs
similarity index 100%
rename from src/GraphQL.Client.Http/GraphQLSerializationExtensions.cs
rename to src/GraphQL.Client/GraphQLSerializationExtensions.cs
diff --git a/src/GraphQL.Client.Http/GraphQLSubscriptionException.cs b/src/GraphQL.Client/GraphQLSubscriptionException.cs
similarity index 100%
rename from src/GraphQL.Client.Http/GraphQLSubscriptionException.cs
rename to src/GraphQL.Client/GraphQLSubscriptionException.cs
diff --git a/src/GraphQL.Client.Http/HttpClientExtensions.cs b/src/GraphQL.Client/HttpClientExtensions.cs
similarity index 100%
rename from src/GraphQL.Client.Http/HttpClientExtensions.cs
rename to src/GraphQL.Client/HttpClientExtensions.cs
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
similarity index 100%
rename from src/GraphQL.Client.Http/Websocket/GraphQLHttpWebSocket.cs
rename to src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
similarity index 100%
rename from src/GraphQL.Client.Http/Websocket/GraphQLHttpWebsocketHelpers.cs
rename to src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client/Websocket/GraphQLWebSocketMessageType.cs
similarity index 100%
rename from src/GraphQL.Client.Http/Websocket/GraphQLWebSocketMessageType.cs
rename to src/GraphQL.Client/Websocket/GraphQLWebSocketMessageType.cs
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs
similarity index 100%
rename from src/GraphQL.Client.Http/Websocket/GraphQLWebSocketRequest.cs
rename to src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs
diff --git a/src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs
similarity index 100%
rename from src/GraphQL.Client.Http/Websocket/GraphQLWebSocketResponse.cs
rename to src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs
diff --git a/src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs
similarity index 100%
rename from src/GraphQL.Client.Http/Websocket/WebsocketResponseWrapper.cs
rename to src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs
diff --git a/src/GraphQL.Client/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
similarity index 98%
rename from src/GraphQL.Client/GraphQLResponse.cs
rename to src/GraphQL.Primitives/GraphQLResponse.cs
index 64c28ac5..762f554e 100644
--- a/src/GraphQL.Client/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -4,7 +4,7 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GraphQL.Client {
+namespace GraphQL {
 
 	public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
 
diff --git a/tests/GraphQL.Client.Http.Tests/BaseTest.cs b/tests/GraphQL.Client.Http.Tests/BaseTest.cs
deleted file mode 100644
index ba47cdea..00000000
--- a/tests/GraphQL.Client.Http.Tests/BaseTest.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using System;
-using Microsoft.AspNetCore.TestHost;
-
-namespace GraphQL.Client.Http.Tests {
-
-	public abstract class BaseTest : IDisposable {
-
-		private readonly TestServer testServer = new TestServer(Server.Test.Program.CreateHostBuilder());
-
-		public void Dispose() {
-			this.testServer.Dispose();
-		}
-
-	}
-
-}
diff --git a/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj b/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
deleted file mode 100644
index c0b659da..00000000
--- a/tests/GraphQL.Client.Http.Tests/GraphQL.Client.Http.Tests.csproj
+++ /dev/null
@@ -1,18 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-	<Import Project="../tests.props" />
-
-	<PropertyGroup>
-        <TargetFramework>netcoreapp3.1</TargetFramework>
-	</PropertyGroup>
-
-    <ItemGroup>
-		<PackageReference Include="FluentAssertions" Version="5.10.0" />
-		<PackageReference Include="Microsoft.AspNetCore.TestHost" Version="3.1.0" />
-    </ItemGroup>
-
-    <ItemGroup>
-      <ProjectReference Include="..\GraphQL.Server.Test\GraphQL.Server.Test.csproj" />
-    </ItemGroup>
-
-</Project>
diff --git a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
deleted file mode 100644
index 6de16408..00000000
--- a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
+++ /dev/null
@@ -1,13 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-	<Import Project="../tests.props" />
-
-	<PropertyGroup>
-		<TargetFramework>netcoreapp3.1</TargetFramework>
-	</PropertyGroup>
-
-	<ItemGroup>
-		<ProjectReference Include="../../src/GraphQL.Client/GraphQL.Client.csproj" />
-	</ItemGroup>
-
-</Project>
diff --git a/tests/GraphQL.Client.Tests/Model/Person.cs b/tests/GraphQL.Client.Tests/Model/Person.cs
deleted file mode 100644
index 23b86a43..00000000
--- a/tests/GraphQL.Client.Tests/Model/Person.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-namespace GraphQL.Client.Tests.Model {
-
-	public class Person {
-
-		public string[] AppearsIn { get; set; }
-
-		public Person[] Friends { get; set; }
-
-		public double Height { get; set; }
-
-		public string Name { get; set; }
-
-		public string PrimaryFunction { get; set; }
-
-	}
-
-}
diff --git a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
index f3dfa126..3ef08638 100644
--- a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
@@ -1,10 +1,8 @@
 using System;
-using System.Collections.Generic;
 using System.Text.Json;
 using Dahomey.Json;
 using FluentAssertions;
-using GraphQL.Client;
-using GraphQL.Integration.Tests.Extensions;
+using GraphQL.Client.Abstractions;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
 using IntegrationTestServer.ChatSchema;
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index aaf21a67..b1731cc1 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -21,7 +21,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\src\GraphQL.Client.Http\GraphQL.Client.Http.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
   </ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
index ca81340f..91ff53f0 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
@@ -1,6 +1,6 @@
 using System.Net.Http;
 using System.Text.Json;
-using GraphQL.Client;
+using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http;
 using GraphQL.Integration.Tests.Helpers;
 using GraphQL.Integration.Tests.TestData;
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
index 3e5eafb1..4bd1fade 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
@@ -3,7 +3,7 @@
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
-using GraphQL.Client;
+using GraphQL.Client.Abstractions;
 using GraphQL.Integration.Tests.Extensions;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index 99070b4c..c7be7594 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -6,8 +6,16 @@
 		<TargetFramework>netcoreapp3.1</TargetFramework>
 	</PropertyGroup>
 
+	<ItemGroup>
+	  <PackageReference Include="FluentAssertions" Version="5.10.0" />
+	</ItemGroup>
+
 	<ItemGroup>
 		<ProjectReference Include="..\..\src\GraphQL.Primitives\GraphQL.Primitives.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+	</ItemGroup>
+
 </Project>
diff --git a/tests/GraphQL.Client.Tests/GraphQLLocationTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
similarity index 100%
rename from tests/GraphQL.Client.Tests/GraphQLLocationTest.cs
rename to tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
deleted file mode 100644
index 3b13b068..00000000
--- a/tests/GraphQL.Primitives.Tests/GraphQLLocationTests.cs
+++ /dev/null
@@ -1,204 +0,0 @@
-using Xunit;
-
-namespace GraphQL.Primitives.Tests {
-
-	public class GraphQLLocationTests {
-
-		[Fact]
-		public void Constructor1() {
-			var graphQLLocation = new GraphQLLocation();
-			Assert.NotNull(graphQLLocation);
-		}
-
-		[Fact]
-		public void Constructor2() {
-			var graphQLLocation = new GraphQLLocation {
-				Column = 10
-			};
-			Assert.Equal(10U, graphQLLocation.Column);
-		}
-
-		[Fact]
-		public void Constructor3() {
-			var graphQLLocation = new GraphQLLocation {
-				Line = 10
-			};
-			Assert.Equal(10U, graphQLLocation.Line);
-		}
-
-		[Fact]
-		public void Constructor4() {
-			var graphQLLocation = new GraphQLLocation {
-				Column = 10,
-				Line = 10
-			};
-			Assert.Equal(10U, graphQLLocation.Column);
-			Assert.Equal(10U, graphQLLocation.Line);
-		}
-
-		[Fact]
-		public void Equality1() {
-			var graphQLLocation1 = new GraphQLLocation();
-			var graphQLLocation2 = new GraphQLLocation();
-			Assert.True(graphQLLocation1.Equals(graphQLLocation2));
-			Assert.True(graphQLLocation2.Equals(graphQLLocation1));
-		}
-
-		[Fact]
-		public void Equality2() {
-			var graphQLLocation1 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			var graphQLLocation2 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			Assert.True(graphQLLocation1.Equals(graphQLLocation2));
-			Assert.True(graphQLLocation2.Equals(graphQLLocation1));
-		}
-
-		[Fact]
-		public void Equality3() {
-			var graphQLLocation1 = new GraphQLLocation();
-			var graphQLLocation2 = new GraphQLLocation();
-			Assert.True(graphQLLocation1 == graphQLLocation2);
-			Assert.True(graphQLLocation2 == graphQLLocation1);
-		}
-
-		[Fact]
-		public void Equality4() {
-			var graphQLLocation1 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			var graphQLLocation2 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			Assert.True(graphQLLocation1 == graphQLLocation2);
-			Assert.True(graphQLLocation2 == graphQLLocation1);
-		}
-
-		[Fact]
-		public void Equality5() {
-			var graphQLLocation1 = new GraphQLLocation();
-			var graphQLLocation2 = new GraphQLLocation();
-			Assert.True(graphQLLocation1.Equals((object)graphQLLocation2));
-			Assert.True(graphQLLocation2.Equals((object)graphQLLocation1));
-		}
-
-		[Fact]
-		public void Equality6() {
-			var graphQLLocation1 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			var graphQLLocation2 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			Assert.True(graphQLLocation1.Equals((object)graphQLLocation2));
-			Assert.True(graphQLLocation2.Equals((object)graphQLLocation1));
-		}
-
-		[Fact]
-		public void GetHashCode1() {
-			var graphQLLocation = new GraphQLLocation();
-			Assert.Equal(0, graphQLLocation.GetHashCode());
-		}
-
-		[Fact]
-		public void GetHashCode2() {
-			var graphQLLocation = new GraphQLLocation {
-				Column = 1
-			};
-			Assert.Equal(1.GetHashCode(), graphQLLocation.GetHashCode());
-		}
-
-		[Fact]
-		public void GetHashCode3() {
-			var graphQLLocation = new GraphQLLocation {
-				Line = 1
-			};
-			Assert.Equal(0.GetHashCode() ^ 1.GetHashCode(), graphQLLocation.GetHashCode());
-		}
-
-		[Fact]
-		public void GetHashCode4() {
-			var graphQLLocation = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			Assert.Equal(1.GetHashCode() ^ 2.GetHashCode(), graphQLLocation.GetHashCode());
-		}
-
-		[Fact]
-		public void Inequality1() {
-			var graphQLLocation1 = new GraphQLLocation();
-			var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.False(graphQLLocation1.Equals(graphQLLocation2));
-			Assert.False(graphQLLocation2.Equals(graphQLLocation1));
-		}
-
-		[Fact]
-		public void Inequality2() {
-			var graphQLLocation1 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			var graphQLLocation2 = new GraphQLLocation {
-				Column = 2,
-				Line = 1
-			};
-			Assert.False(graphQLLocation1.Equals(graphQLLocation2));
-			Assert.False(graphQLLocation2.Equals(graphQLLocation1));
-		}
-
-		[Fact]
-		public void Inequality3() {
-			var graphQLLocation1 = new GraphQLLocation();
-			var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.True(graphQLLocation1 != graphQLLocation2);
-			Assert.True(graphQLLocation2 != graphQLLocation1);
-		}
-
-		[Fact]
-		public void Inequality4() {
-			var graphQLLocation1 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			var graphQLLocation2 = new GraphQLLocation {
-				Column = 2,
-				Line = 1
-			};
-			Assert.True(graphQLLocation1 != graphQLLocation2);
-			Assert.True(graphQLLocation2 != graphQLLocation1);
-		}
-
-		[Fact]
-		public void Inequality5() {
-			var graphQLLocation1 = new GraphQLLocation();
-			var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.False(graphQLLocation1.Equals((object)graphQLLocation2));
-			Assert.False(graphQLLocation2.Equals((object)graphQLLocation1));
-		}
-
-		[Fact]
-		public void Inequality6() {
-			var graphQLLocation1 = new GraphQLLocation {
-				Column = 1,
-				Line = 2
-			};
-			var graphQLLocation2 = new GraphQLLocation {
-				Column = 2,
-				Line = 1
-			};
-			Assert.False(graphQLLocation1.Equals((object)graphQLLocation2));
-			Assert.False(graphQLLocation2.Equals((object)graphQLLocation1));
-		}
-
-	}
-
-}
diff --git a/tests/GraphQL.Client.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
similarity index 100%
rename from tests/GraphQL.Client.Tests/GraphQLRequestTest.cs
rename to tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
diff --git a/tests/GraphQL.Client.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
similarity index 100%
rename from tests/GraphQL.Client.Tests/GraphQLResponseTest.cs
rename to tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
diff --git a/tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
similarity index 100%
rename from tests/GraphQL.Client.Http.Tests/JsonSerializationTests.cs
rename to tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs

From 5c465271cdced70a7dd68b1476f87310e344f210 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 21:12:04 +0100
Subject: [PATCH 125/455] adjust namespaces

---
 tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs    | 2 +-
 tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs     | 2 +-
 tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs    | 2 +-
 tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
index 468d521e..5b144a74 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace GraphQL.Client.Tests {
+namespace GraphQL.Primitives.Tests {
 
 	public class GraphQLLocationTest {
 
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
index c3a22357..f4a22742 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace GraphQL.Client.Tests {
+namespace GraphQL.Primitives.Tests {
 
 	public class GraphQLRequestTest {
 
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
index fc792a1d..07c4063c 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
@@ -1,6 +1,6 @@
 using Xunit;
 
-namespace GraphQL.Client.Tests {
+namespace GraphQL.Primitives.Tests {
 
 	public class GraphQLResponseTest {
 
diff --git a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
index 74191b15..3dbdb828 100644
--- a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
@@ -1,9 +1,9 @@
 using System.Collections.Generic;
-using Xunit;
 using System.Text.Json;
 using FluentAssertions;
+using Xunit;
 
-namespace GraphQL.Client.Http.Tests {
+namespace GraphQL.Primitives.Tests {
 	public class JsonSerializationTests {
 
 		[Fact]

From 44d59894c84edfb85b733756d5c4a59d7c3d8e57 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 21:52:13 +0100
Subject: [PATCH 126/455] revert to Json.Net

---
 .../GraphQL.Client.Abstractions.csproj        |  6 +--
 src/GraphQL.Client/GraphQL.Client.csproj      |  8 +---
 .../GraphQLHttpClientOptions.cs               | 31 +++-----------
 src/GraphQL.Client/GraphQLHttpRequest.cs      |  4 +-
 .../GraphQLSerializationExtensions.cs         | 42 ++++++++++++-------
 .../Websocket/GraphQLHttpWebSocket.cs         | 18 ++++----
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  | 10 ++---
 .../Websocket/WebsocketResponseWrapper.cs     |  4 +-
 .../GraphQL.Primitives.csproj                 |  6 +--
 src/GraphQL.Primitives/GraphQLError.cs        | 17 ++++----
 src/GraphQL.Primitives/GraphQLRequest.cs      |  8 ++--
 src/GraphQL.Primitives/GraphQLResponse.cs     | 15 ++++---
 .../ExtensionsTest.cs                         | 20 ++-------
 .../QueryAndMutationTests.cs                  |  7 ++--
 14 files changed, 82 insertions(+), 114 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 4a2c3ac8..6430f4b7 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -5,7 +5,7 @@
 	<PropertyGroup>
 		<Description>A GraphQL Client</Description>
 		<RootNamespace>GraphQL.Client.Abstractions</RootNamespace>
-		<TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -16,8 +16,4 @@
 		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
-	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-		<PackageReference Include="System.Text.Json" Version="4.7.0" />
-	</ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index bcd8d91a..2dfd5ad8 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -3,7 +3,7 @@
 	<Import Project="../src.props" />
 
     <PropertyGroup>
-		<TargetFrameworks>netstandard2.0;netcoreapp3.1;net461</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
 	    <RootNamespace>GraphQL.Client.Http</RootNamespace>
     </PropertyGroup>
 
@@ -17,11 +17,7 @@
 
 
 	<ItemGroup>
-		<PackageReference Include="Dahomey.Json" Version="1.6.0" />
-	</ItemGroup>
-
-	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'net461'">
-		<PackageReference Include="System.Text.Json" Version="4.7.0" />
+		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 2eda001e..dcb0a37e 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -1,10 +1,9 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Text.Json;
 using System.Threading.Tasks;
-using Dahomey.Json;
-using Dahomey.Json.Serialization.Converters.Factories;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.Http {
 
@@ -19,9 +18,11 @@ public class GraphQLHttpClientOptions {
 		public Uri EndPoint { get; set; }
 
 		/// <summary>
-		/// The <see cref="JsonSerializerOptions"/> that is going to be used
+		/// The <see cref="JsonSerializerSettings"/> that is going to be used
 		/// </summary>
-		public JsonSerializerOptions JsonSerializerOptions { get; set; } = GetDefaultJsonSerializerOptions();
+		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
+			ContractResolver = new CamelCasePropertyNamesContractResolver()
+		};
 
 		/// <summary>
 		/// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
@@ -51,25 +52,5 @@ public class GraphQLHttpClientOptions {
 		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
 		/// </summary>
 		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
-
-		/// <summary>
-		/// Generates the default <see cref="JsonSerializerOptions"/>
-		/// </summary>
-		/// <returns></returns>
-		public static JsonSerializerOptions GetDefaultJsonSerializerOptions() {
-			var options = new JsonSerializerOptions {
-				PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-			};
-
-			//options.Converters.Add(new JsonSerializerOptionsState(options));
-			//options.Converters.Add(new DictionaryConverterFactory());
-			//options.Converters.Add(new CollectionConverterFactory());
-			//options.Converters.Add(new JsonNodeConverterFactory());
-			//options.Converters.Add(new ObjectConverterFactory());
-
-			options.SetupExtensions();
-
-			return options;
-		}
 	}
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 59cac335..67e06259 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Net.Http;
-using System.Text.Json.Serialization;
+using System.Runtime.Serialization;
 
 namespace GraphQL.Client.Http {
 
@@ -16,7 +16,7 @@ public GraphQLHttpRequest(string query, object? variables = null, string? operat
 		/// <summary>
 		/// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
 		/// </summary>
-		[JsonIgnore]
+		[IgnoreDataMember]
 		public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
 	}
 }
diff --git a/src/GraphQL.Client/GraphQLSerializationExtensions.cs b/src/GraphQL.Client/GraphQLSerializationExtensions.cs
index 758a8245..649d2c73 100644
--- a/src/GraphQL.Client/GraphQLSerializationExtensions.cs
+++ b/src/GraphQL.Client/GraphQLSerializationExtensions.cs
@@ -1,36 +1,48 @@
 using System.IO;
-using System.Text.Json;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using Dahomey.Json;
-using Dahomey.Json.Serialization.Converters.Factories;
+using GraphQL.Client.Http.Websocket;
+using Newtonsoft.Json;
 
 namespace GraphQL.Client.Http {
 	public static class GraphQLSerializationExtensions {
 
 		public static string SerializeToJson(this GraphQLRequest request,
 			GraphQLHttpClientOptions options) {
-			return JsonSerializer.Serialize(request, options.JsonSerializerOptions);
+			return JsonConvert.SerializeObject(request, options.JsonSerializerSettings);
+		}
+		
+		public static byte[] SerializeToBytes(this GraphQLRequest request,
+			GraphQLHttpClientOptions options) {
+			var json = JsonConvert.SerializeObject(request, options.JsonSerializerSettings);
+			return Encoding.UTF8.GetBytes(json);
+		}
+		public static byte[] SerializeToBytes(this GraphQLWebSocketRequest request,
+			GraphQLHttpClientOptions options) {
+			var json = JsonConvert.SerializeObject(request, options.JsonSerializerSettings);
+			return Encoding.UTF8.GetBytes(json);
 		}
 
 		public static TGraphQLResponse DeserializeFromJson<TGraphQLResponse>(this string jsonString,
 			GraphQLHttpClientOptions options) {
-			return JsonSerializer.Deserialize<TGraphQLResponse>(jsonString, options.JsonSerializerOptions);
+			return JsonConvert.DeserializeObject<TGraphQLResponse>(jsonString, options.JsonSerializerSettings);
 		}
 
-		public static ValueTask<TGraphQLResponse> DeserializeFromJsonAsync<TGraphQLResponse>(this Stream stream,
-			GraphQLHttpClientOptions options, CancellationToken cancellationToken = default) {
-			return JsonSerializer.DeserializeAsync<TGraphQLResponse>(stream, options.JsonSerializerOptions, cancellationToken);
+		public static TObject DeserializeFromBytes<TObject>(this byte[] utf8bytes,
+			GraphQLHttpClientOptions options) {
+			return JsonConvert.DeserializeObject<TObject>(Encoding.UTF8.GetString(utf8bytes), options.JsonSerializerSettings);
 		}
 
-		public static JsonSerializerOptions SetupDahomeyJson(this JsonSerializerOptions options) {
-			options.Converters.Add(new JsonSerializerOptionsState(options));
-			options.Converters.Add(new DictionaryConverterFactory());
-			options.Converters.Add(new CollectionConverterFactory());
-			//options.Converters.Add(new JsonNodeConverterFactory());
-			options.Converters.Add(new ObjectConverterFactory());
 
-			return options;
+		public static Task<TGraphQLResponse> DeserializeFromJsonAsync<TGraphQLResponse>(this Stream stream,
+			GraphQLHttpClientOptions options, CancellationToken cancellationToken = default) {
+			using (StreamReader sr = new StreamReader(stream))
+			using (JsonReader reader = new JsonTextReader(sr)) {
+				JsonSerializer serializer = JsonSerializer.Create(options.JsonSerializerSettings);
+				
+				return Task.FromResult(serializer.Deserialize<TGraphQLResponse>(reader));
+			}
 		}
 	}
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 1546092b..5a4e76c2 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -9,6 +9,7 @@
 using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 
 namespace GraphQL.Client.Http.Websocket {
 	internal class GraphQLHttpWebSocket : IDisposable {
@@ -58,7 +59,7 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request) {
 				}
 
 				await InitializeWebSocket().ConfigureAwait(false);
-				var requestBytes = System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(request, _options.JsonSerializerOptions);
+				var requestBytes = request.SerializeToBytes(_options);
 				await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
@@ -222,13 +223,14 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 					ms.Seek(0, SeekOrigin.Begin);
 
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
-						var bytes = ms.ToArray();
-						var response =
-							System.Text.Json.JsonSerializer.Deserialize<WebsocketResponseWrapper>(bytes,
-								_options.JsonSerializerOptions);
-						response.MessageBytes = bytes;
-
-						return response;
+						using (StreamReader sr = new StreamReader(ms))
+						using (JsonReader reader = new JsonTextReader(sr)) {
+							JsonSerializer serializer = JsonSerializer.Create(_options.JsonSerializerSettings);
+
+							var response = serializer.Deserialize<WebsocketResponseWrapper>(reader);
+							response.MessageBytes = ms.ToArray();
+							return response;
+						}
 					}
 					else {
 						throw new NotSupportedException("binary websocket messages are not supported");
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
index 4d929a83..f3cb5854 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -4,9 +4,9 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
-using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 
 namespace GraphQL.Client.Http.Websocket {
 	public static class GraphQLHttpWebsocketHelpers {
@@ -48,8 +48,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 									// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
 									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
 									var typedResponse =
-										JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
-											client.Options.JsonSerializerOptions);
+										response.MessageBytes.DeserializeFromBytes<GraphQLWebSocketResponse<TResponse>>(client.Options);
 									o.OnNext(typedResponse.Payload);
 
 									// in case of a GraphQL error, terminate the sequence after the response has been posted
@@ -168,10 +167,9 @@ internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 						.Where(response => response != null && response.Id == websocketRequest.Id)
 						.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
 						.Select(response => {
-							Debug.WriteLine($"received response for request {websocketRequest.Id}");
+							Debug.WriteLine($"received response for request {websocketRequest.Id}"); ;
 							var typedResponse =
-								JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(response.MessageBytes,
-									client.Options.JsonSerializerOptions);
+								response.MessageBytes.DeserializeFromBytes<GraphQLWebSocketResponse<TResponse>>(client.Options);
 							return typedResponse.Payload;
 						});
 
diff --git a/src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs
index fe237889..fd91ef78 100644
--- a/src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs
+++ b/src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs
@@ -1,9 +1,9 @@
-using System.Text.Json.Serialization;
+using System.Runtime.Serialization;
 
 namespace GraphQL.Client.Http.Websocket {
 	public class WebsocketResponseWrapper : GraphQLWebSocketResponse {
 
-		[JsonIgnore]
+		[IgnoreDataMember]
 		public byte[] MessageBytes { get; set; }
 	}
 }
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index add49e13..53f58f4b 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -5,10 +5,6 @@
 	<PropertyGroup>
 		<Description>GraphQL basic types</Description>
 		<RootNamespace>GraphQL</RootNamespace>
-		<TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
-
-	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-		<PackageReference Include="System.Text.Json" Version="4.7.0" />
-	</ItemGroup>
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 82a80ddc..c1b159a4 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -1,8 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.Json;
-using System.Text.Json.Serialization;
+using System.Runtime.Serialization;
 
 namespace GraphQL {
 
@@ -14,25 +13,25 @@ public class GraphQLError : IEquatable<GraphQLError?> {
 		/// <summary>
 		/// The extensions of the error
 		/// </summary> 
-		[JsonPropertyName("extensions")]
-		public JsonElement? Extensions { get; set; }
+		[DataMember(Name = "extensions")]
+		public IDictionary<string, object?>? Extensions { get; set; }
 
 		/// <summary>
 		/// The locations of the error
 		/// </summary>
-		[JsonPropertyName("locations")]
+		[DataMember(Name = "locations")]
 		public GraphQLLocation[]? Locations { get; set; }
 
 		/// <summary>
 		/// The message of the error
 		/// </summary>
-		[JsonPropertyName("message")]
+		[DataMember(Name = "message")]
 		public string Message { get; set; }
 
 		/// <summary>
 		/// The Path of the error
 		/// </summary>
-		[JsonPropertyName("path")]
+		[DataMember(Name = "path")]
 		public object[]? Path { get; set; }
 
 		/// <summary>
@@ -51,7 +50,7 @@ public override bool Equals(object? obj) =>
 		public bool Equals(GraphQLError? other) {
 			if (other == null) { return false; }
 			if (ReferenceEquals(this, other)) { return true; }
-			if (!EqualityComparer<JsonElement?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
+			if (!EqualityComparer<IDictionary<string, object?>?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
 			{
 				if (this.Locations != null && other.Locations != null) {
 					if (!this.Locations.SequenceEqual(other.Locations)) { return false; }
@@ -76,7 +75,7 @@ public bool Equals(GraphQLError? other) {
 		public override int GetHashCode() {
 			var hashCode = 0;
 			if (this.Extensions != null) {
-				hashCode = hashCode ^ EqualityComparer<JsonElement?>.Default.GetHashCode(this.Extensions);
+				hashCode = hashCode ^ EqualityComparer<IDictionary<string, object?>?>.Default.GetHashCode(this.Extensions);
 			}
 			if (this.Locations != null) {
 				hashCode = hashCode ^ EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(this.Locations);
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 95bf8eae..874b0352 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Text.Json.Serialization;
+using System.Runtime.Serialization;
 
 namespace GraphQL {
 
@@ -13,19 +13,19 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		/// The Query
 		/// </summary>
 		/// 
-		[JsonPropertyName("query")]
+		[DataMember(Name = "query")]
 		public string Query { get; set; }
 
 		/// <summary>
 		/// The name of the Operation
 		/// </summary>
-		[JsonPropertyName("operationName")]
+		[DataMember(Name = "operationName")]
 		public string? OperationName { get; set; }
 
 		/// <summary>
 		/// Represents the request variables
 		/// </summary>
-		[JsonPropertyName("variables")]
+		[DataMember(Name = "variables")]
 		public virtual object? Variables { get; set; }
 
 
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 762f554e..4ae09061 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -1,21 +1,20 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text.Json;
-using System.Text.Json.Serialization;
+using System.Runtime.Serialization;
 
 namespace GraphQL {
 
 	public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
 
-		[JsonPropertyName("data")]
+		[DataMember(Name = "data")]
 		public T Data { get; set; }
 
-		[JsonPropertyName("errors")]
+		[DataMember(Name = "errors")]
 		public GraphQLError[]? Errors { get; set; }
 
-		[JsonPropertyName("extensions")]
-		public JsonElement? Extensions { get; set; }
+		[DataMember(Name = "extensions")]
+		public IDictionary<string, object?>? Extensions { get; set; }
 
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
 
@@ -30,7 +29,7 @@ public bool Equals(GraphQLResponse<T>? other) {
 				else if (this.Errors != null && other.Errors == null) { return false; }
 				else if (this.Errors == null && other.Errors != null) { return false; }
 			}
-			if (!EqualityComparer<JsonElement?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
+			if (!EqualityComparer<IDictionary<string, object?>?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
 			return true;
 		}
 
@@ -47,7 +46,7 @@ public override int GetHashCode() {
 						hashCode = (hashCode * 397) ^ 0;
 					}
 				}
-				hashCode = (hashCode * 397) ^ EqualityComparer<JsonElement?>.Default.GetHashCode(this.Extensions);
+				hashCode = (hashCode * 397) ^ EqualityComparer<IDictionary<string, object?>?>.Default.GetHashCode(this.Extensions);
 				return hashCode;
 			}
 		}
diff --git a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
index 3ef08638..fff1b6e4 100644
--- a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
@@ -1,11 +1,11 @@
 using System;
 using System.Text.Json;
-using Dahomey.Json;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
 using IntegrationTestServer.ChatSchema;
+using Newtonsoft.Json;
 using Xunit;
 
 namespace GraphQL.Integration.Tests {
@@ -24,23 +24,11 @@ public async void CanDeserializeExtensions() {
 			response.Errors.Should().NotBeNull();
 			response.Errors.Should().ContainSingle();
 			response.Errors[0].Extensions.Should().NotBeNull();
-
-			JsonElement data = new JsonElement();
-			response.Errors[0].Extensions.Value.Invoking(element => data = element.GetProperty("data")).Should()
-				.NotThrow();
+			response.Errors[0].Extensions.Should().ContainKey("data");
 
 			foreach (var item in ChatQuery.TestExtensions) {
-				JsonElement value = new JsonElement();
-				data.Invoking(element => value = element.GetProperty(item.Key)).Should().NotThrow();
+				
 
-				switch (item.Value) {
-					case int i:
-						value.GetInt32().Should().Be(i);
-						break;
-					default:
-						value.GetString().Should().BeEquivalentTo(item.Value.ToString());
-						break;
-				}
 			}
 		}
 
@@ -48,7 +36,7 @@ public async void CanDeserializeExtensions() {
 		public async void DontNeedToUseCamelCaseNamingStrategy() {
 
 			using var setup = SetupTest();
-			setup.Client.Options.JsonSerializerOptions = new JsonSerializerOptions().SetupExtensions();
+			setup.Client.Options.JsonSerializerSettings = new JsonSerializerSettings();
 
 			const string message = "some random testing message";
 			var graphQLRequest = new GraphQLRequest(
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
index 91ff53f0..d897884f 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
@@ -5,6 +5,7 @@
 using GraphQL.Integration.Tests.Helpers;
 using GraphQL.Integration.Tests.TestData;
 using IntegrationTestServer;
+using Newtonsoft.Json.Linq;
 using Xunit;
 
 namespace GraphQL.Integration.Tests {
@@ -28,15 +29,15 @@ public async void QueryTheory(int id, string name) {
 
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
-		public async void QueryWithJsonElementAsReturnTypeTheory(int id, string name) {
+		public async void QueryWithDynamicReturnTypeTheory(int id, string name) {
 			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
 
 			using (var setup = SetupTest()) {
-				var response = await setup.Client.SendQueryAsync<JsonElement>(graphQLRequest)
+				var response = await setup.Client.SendQueryAsync<dynamic>(graphQLRequest)
 					.ConfigureAwait(false);
 
 				Assert.Null(response.Errors);
-				Assert.Equal(name, response.Data.GetProperty("human").GetProperty("name").GetString());
+				Assert.Equal(name, response.Data.human.name.ToString());
 			}
 		}
 

From 5d69248afc3870929bf883873df1ae014880beef Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 21:55:07 +0100
Subject: [PATCH 127/455] remove comment from workflow

---
 .github/workflows/main.yml | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index dd2dc3e3..9fa01ff2 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -99,13 +99,3 @@ jobs:
       run: nuget sources Add -Name "GPR" -Source https://nuget.pkg.github.com/graphql-dotnet/index.json -UserName graphql-dotnet -Password ${{secrets.GITHUB_TOKEN}}
     - name: push packages
       run: nuget push .\nupkg\*.nupkg -SkipDuplicate -Source "GPR"
-    # - name: Setup GitHub Packages as nuget source
-    #   uses: actions/setup-dotnet@master
-    #   with:
-    #     dotnet-version: '3.1.100'
-    #     source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json      
-    #   env:
-    #     NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-    # - name: push packages
-    #   run: dotnet nuget push .\nupkg\*.nupkg --skip-duplicate -k ${{secrets.GITHUB_TOKEN}}
-    
\ No newline at end of file

From 7c1bf1357f66a004fd6ce47d52f6547958639f54 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 21:58:20 +0100
Subject: [PATCH 128/455] remove experimental warnings

---
 src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs  | 1 -
 src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs
index 8bcdb7b6..01dcf173 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs
@@ -7,7 +7,6 @@ namespace GraphQL.Client.Http.Websocket {
 	/// <summary>
 	/// A Subscription Request
 	/// </summary>
-	[Obsolete("EXPERIMENTAL")]
 	public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 
 		/// <summary>
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs
index 9d791cfc..08171a6a 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs
@@ -6,7 +6,6 @@ namespace GraphQL.Client.Http.Websocket {
 	/// <summary>
 	/// A Subscription Response
 	/// </summary>
-	[Obsolete("EXPERIMENTAL")]
 	public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse> {
 
 		/// <summary>

From 9c20fd903dc381eeb1abbf792f06654f2f285d68 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 22:15:57 +0100
Subject: [PATCH 129/455] prevent master branch from publishing untagged
 packages

---
 .github/workflows/branches.yml | 1 -
 .github/workflows/main.yml     | 4 +++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index e6669ac3..a896d523 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -2,7 +2,6 @@ name: Branch workflow
 on: 
   push:
     branches-ignore:
-      - master
       - develop
       - 'release/**'
       - 'releases/**'
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 9fa01ff2..2ed05127 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -2,10 +2,12 @@ name: Main workflow
 on: 
   push:
     branches:
-      - master
       - develop
       - 'release/**'
       - 'releases/**'
+    tags:        
+      - v*
+      - V*
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From b57364bd8c415e1993a548d01e5791c7e6172179 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 22:41:58 +0100
Subject: [PATCH 130/455] overhaul readme

---
 README.md | 64 +++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 53 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index 21f7fefe..c658a859 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,5 @@
 # GraphQL.Client
 [![NuGet](https://img.shields.io/nuget/v/GraphQL.Client.svg)](https://www.nuget.org/packages/GraphQL.Client)
-[![MyGet](https://img.shields.io/myget/graphql-dotnet/v/GraphQL.Client.svg)](https://www.myget.org/feed/graphql-dotnet/package/nuget/GraphQL.Client)
 
 A GraphQL Client for .NET Standard over HTTP.
 
@@ -43,25 +42,68 @@ var heroAndFriendsRequest = new GraphQLRequest {
 };
 ```
 
-### Send Request:
+### Execute Query/Mutation:
 ```csharp
 var graphQLClient = new GraphQLClient("https://swapi.apis.guru/");
-var graphQLResponse = await graphQLClient.PostAsync(heroRequest);
+
+public class HeroAndFriendsResponse {
+    public Hero Hero {get; set;}
+
+    public class Hero {
+        public string Name {get; set;}
+
+        public List<Hero> Friends {get; set;}
+    }
+}
+
+var graphQLResponse = await graphQLClient.SendQueryAsync(
+    heroAndFriendsRequest, 
+    () => new {
+        hero = new { 
+            name = string.Empty , 
+            friends = new List<new { name = string.Empty}>
+        }
+    }
+);
+
+var heroName = graphQLResponse.Data.Hero.Name;
+```
+
+### Use Subscriptions
+
+```csharp
+public class UserJoinedSubscriptionResult {
+	public ChatUser UserJoined { get; set; }
+
+	public class ChatUser {
+		public string DisplayName { get; set; }
+		public string Id { get; set; }
+	}
+}
 ```
 
-### Read GraphQLResponse:
+#### Create subscription
 
-#### Dynamic:
 ```csharp
-var graphQLResponse = await graphQLClient.PostAsync(heroRequest);
-var dynamicHeroName = graphQLResponse.Data.hero.name.Value; //Value of data->hero->name
+var userJoinedRequest = new GraphQLRequest {
+    Query = @"
+	subscription {
+		userJoined{
+			displayName
+			id
+		}
+	}"
+};
+
+IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> subscriptionStream = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(userJoinedRequest);
+
+var subscription = subscriptionStream.Subscribe(response => Console.WriteLine($"user '{response.Data.UserJoined.DisplayName}' joined"));
 ```
 
-#### Typed:
+#### End Subscription
+
 ```csharp
-var graphQLResponse = await graphQLClient.PostAsync(heroRequest);
-var personType = graphQLResponse.GetDataFieldAs<Person>("hero"); //data->hero is casted as Person
-var name = personType.Name;
+subscription.Dispose();
 ```
 
 ## Useful Links:

From 3ac61b1561783a360f2b8532117d9f1e47c75047 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 22:47:57 +0100
Subject: [PATCH 131/455] fix examples and formatting

---
 README.md | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index c658a859..f55b48dd 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,6 @@
 # GraphQL.Client
 [![NuGet](https://img.shields.io/nuget/v/GraphQL.Client.svg)](https://www.nuget.org/packages/GraphQL.Client)
+[![NuGet](https://img.shields.io/nuget/vpre/GraphQL.Client.svg)](https://www.nuget.org/packages/GraphQL.Client)
 
 A GraphQL Client for .NET Standard over HTTP.
 
@@ -56,15 +57,7 @@ public class HeroAndFriendsResponse {
     }
 }
 
-var graphQLResponse = await graphQLClient.SendQueryAsync(
-    heroAndFriendsRequest, 
-    () => new {
-        hero = new { 
-            name = string.Empty , 
-            friends = new List<new { name = string.Empty}>
-        }
-    }
-);
+var graphQLResponse = await graphQLClient.SendQueryAsync<HeroAndFriendsResponse>(heroAndFriendsRequest);
 
 var heroName = graphQLResponse.Data.Hero.Name;
 ```
@@ -95,9 +88,13 @@ var userJoinedRequest = new GraphQLRequest {
 	}"
 };
 
-IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> subscriptionStream = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(userJoinedRequest);
+IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> subscriptionStream 
+	= client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(userJoinedRequest);
 
-var subscription = subscriptionStream.Subscribe(response => Console.WriteLine($"user '{response.Data.UserJoined.DisplayName}' joined"));
+var subscription = subscriptionStream.Subscribe(response => 
+	{
+		Console.WriteLine($"user '{response.Data.UserJoined.DisplayName}' joined")
+	});
 ```
 
 #### End Subscription

From c53385a1cc47be92384646b4eb42bddd0f1523fd Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 23:09:36 +0100
Subject: [PATCH 132/455] fix funding.yml

---
 .github/FUNDING.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index 18cff76a..a220af9a 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1 +1 @@
-github: deinok
+custom: ["https://paypal.me/AlexRose89"]

From e1c3b8654123430a2d15ef5d7fb65ab456ce6189 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 23:20:26 +0100
Subject: [PATCH 133/455] remove FUNDING.yml

---
 .github/FUNDING.yml | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
deleted file mode 100644
index a220af9a..00000000
--- a/.github/FUNDING.yml
+++ /dev/null
@@ -1 +0,0 @@
-custom: ["https://paypal.me/AlexRose89"]

From d0928cc816ff4edd280644aa3d208219f9879cbb Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 19:38:32 +0100
Subject: [PATCH 134/455] remove extension fields and use DataMemberName

---
 src/GraphQL.Primitives/GraphQLError.cs    | 10 ----------
 src/GraphQL.Primitives/GraphQLRequest.cs  |  1 -
 src/GraphQL.Primitives/GraphQLResponse.cs |  7 +------
 3 files changed, 1 insertion(+), 17 deletions(-)

diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index c1b159a4..b08105c4 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -10,12 +10,6 @@ namespace GraphQL {
 	/// </summary>
 	public class GraphQLError : IEquatable<GraphQLError?> {
 
-		/// <summary>
-		/// The extensions of the error
-		/// </summary> 
-		[DataMember(Name = "extensions")]
-		public IDictionary<string, object?>? Extensions { get; set; }
-
 		/// <summary>
 		/// The locations of the error
 		/// </summary>
@@ -50,7 +44,6 @@ public override bool Equals(object? obj) =>
 		public bool Equals(GraphQLError? other) {
 			if (other == null) { return false; }
 			if (ReferenceEquals(this, other)) { return true; }
-			if (!EqualityComparer<IDictionary<string, object?>?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
 			{
 				if (this.Locations != null && other.Locations != null) {
 					if (!this.Locations.SequenceEqual(other.Locations)) { return false; }
@@ -74,9 +67,6 @@ public bool Equals(GraphQLError? other) {
 		/// </summary>
 		public override int GetHashCode() {
 			var hashCode = 0;
-			if (this.Extensions != null) {
-				hashCode = hashCode ^ EqualityComparer<IDictionary<string, object?>?>.Default.GetHashCode(this.Extensions);
-			}
 			if (this.Locations != null) {
 				hashCode = hashCode ^ EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(this.Locations);
 			}
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 874b0352..13b2a1f8 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -12,7 +12,6 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		/// <summary>
 		/// The Query
 		/// </summary>
-		/// 
 		[DataMember(Name = "query")]
 		public string Query { get; set; }
 
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 4ae09061..0145229d 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -12,10 +12,7 @@ public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
 
 		[DataMember(Name = "errors")]
 		public GraphQLError[]? Errors { get; set; }
-
-		[DataMember(Name = "extensions")]
-		public IDictionary<string, object?>? Extensions { get; set; }
-
+		
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
 
 		public bool Equals(GraphQLResponse<T>? other) {
@@ -29,7 +26,6 @@ public bool Equals(GraphQLResponse<T>? other) {
 				else if (this.Errors != null && other.Errors == null) { return false; }
 				else if (this.Errors == null && other.Errors != null) { return false; }
 			}
-			if (!EqualityComparer<IDictionary<string, object?>?>.Default.Equals(this.Extensions, other.Extensions)) { return false; }
 			return true;
 		}
 
@@ -46,7 +42,6 @@ public override int GetHashCode() {
 						hashCode = (hashCode * 397) ^ 0;
 					}
 				}
-				hashCode = (hashCode * 397) ^ EqualityComparer<IDictionary<string, object?>?>.Default.GetHashCode(this.Extensions);
 				return hashCode;
 			}
 		}

From f019bd6eaaebe249e49b91d99c95ed8eb1b56a4e Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 7 Feb 2020 20:16:24 +0100
Subject: [PATCH 135/455] create interfaces

---
 .../Websocket/IGraphQLWebSocketJsonSerializer.cs     |  5 +++++
 src/GraphQL.Client/GraphQLHttpClient.cs              |  5 +++--
 src/GraphQL.Client/GraphQLHttpClientOptions.cs       |  9 +++------
 src/GraphQL.Client/GraphQLHttpResponse.cs            |  4 ----
 src/GraphQL.Client/IGraphQLJsonSerializer.cs         | 12 ++++++++++++
 .../Websocket/GraphQLHttpWebsocketHelpers.cs         |  9 +++++----
 src/GraphQL.Primitives/GraphQLRequest.cs             |  6 ++----
 7 files changed, 30 insertions(+), 20 deletions(-)
 create mode 100644 src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs
 create mode 100644 src/GraphQL.Client/IGraphQLJsonSerializer.cs

diff --git a/src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs b/src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs
new file mode 100644
index 00000000..5f89191d
--- /dev/null
+++ b/src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs
@@ -0,0 +1,5 @@
+namespace GraphQL.Client.Http.Websocket {
+	public interface IGraphQLWebSocketJsonSerializer: IGraphQLJsonSerializer {
+		GraphQLWebSocketResponse<TResponse> DeserializeWebSocketResponse<TResponse>(byte[] utf8bytes);
+	}
+}
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 15ff6e8f..16e4b3cf 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -14,6 +14,7 @@ public class GraphQLHttpClient : IGraphQLClient {
 		private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 		private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
+		private IGraphQLJsonSerializer JsonSerializer => Options.JsonSerializer;
 
 		/// <summary>
 		/// the instance of <see cref="HttpClient"/> which is used internally
@@ -111,12 +112,12 @@ private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TRespons
 			}
 
 			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
-			return await bodyStream.DeserializeFromJsonAsync<GraphQLHttpResponse<TResponse>>(Options, cancellationToken);
+			return await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
 		}
 
 		private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request) {
 			var message = new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
-				Content = new StringContent(request.SerializeToJson(Options), Encoding.UTF8, Options.MediaType)
+				Content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, Options.MediaType)
 			};
 
 			if (request is GraphQLHttpRequest httpRequest)
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index dcb0a37e..f3f10df9 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -2,8 +2,7 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Threading.Tasks;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Serialization;
+using GraphQL.Client.Http.Websocket;
 
 namespace GraphQL.Client.Http {
 
@@ -18,11 +17,9 @@ public class GraphQLHttpClientOptions {
 		public Uri EndPoint { get; set; }
 
 		/// <summary>
-		/// The <see cref="JsonSerializerSettings"/> that is going to be used
+		/// the json serializer
 		/// </summary>
-		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver()
-		};
+		public IGraphQLWebSocketJsonSerializer JsonSerializer { get; set; }
 
 		/// <summary>
 		/// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index 1e7c8424..1dbfea30 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -2,8 +2,4 @@ namespace GraphQL.Client.Http {
 
 	public class GraphQLHttpResponse<T> : GraphQLResponse<T> {
 	}
-
-	public class GraphQLHttpResponse : GraphQLHttpResponse<dynamic?> {
-	}
-
 }
diff --git a/src/GraphQL.Client/IGraphQLJsonSerializer.cs b/src/GraphQL.Client/IGraphQLJsonSerializer.cs
new file mode 100644
index 00000000..b9dadd3a
--- /dev/null
+++ b/src/GraphQL.Client/IGraphQLJsonSerializer.cs
@@ -0,0 +1,12 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GraphQL.Client {
+	public interface IGraphQLJsonSerializer {
+		string Serialize(GraphQLRequest request);
+
+		Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream,
+			CancellationToken cancellationToken);
+	}
+}
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
index f3cb5854..ff0aa5e1 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -48,7 +48,8 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 									// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
 									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
 									var typedResponse =
-										response.MessageBytes.DeserializeFromBytes<GraphQLWebSocketResponse<TResponse>>(client.Options);
+										client.Options.JsonSerializer.DeserializeWebSocketResponse<TResponse>(
+											response.MessageBytes);
 									o.OnNext(typedResponse.Payload);
 
 									// in case of a GraphQL error, terminate the sequence after the response has been posted
@@ -167,9 +168,9 @@ internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 						.Where(response => response != null && response.Id == websocketRequest.Id)
 						.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
 						.Select(response => {
-							Debug.WriteLine($"received response for request {websocketRequest.Id}"); ;
-							var typedResponse =
-								response.MessageBytes.DeserializeFromBytes<GraphQLWebSocketResponse<TResponse>>(client.Options);
+							Debug.WriteLine($"received response for request {websocketRequest.Id}");
+							var typedResponse = client.Options.JsonSerializer
+								.DeserializeWebSocketResponse<TResponse>(response.MessageBytes);
 							return typedResponse.Payload;
 						});
 
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 13b2a1f8..d39d2cea 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -25,11 +25,9 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		/// Represents the request variables
 		/// </summary>
 		[DataMember(Name = "variables")]
-		public virtual object? Variables { get; set; }
+		public object? Variables { get; set; }
 
-
-		public GraphQLRequest() {
-		}
+		public GraphQLRequest() { }
 
 		public GraphQLRequest(string query, object? variables = null, string? operationName = null) {
 			Query = query;

From 50827f27cc0e5ef501b410257532660d3f841b9a Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 9 Feb 2020 22:26:37 +0100
Subject: [PATCH 136/455] move newtonsoft serialization to
 GraphQL.Client.Serializer.Newtonsoft

---
 GraphQL.Client.sln                            | 14 ++++
 ...aphQL.Client.Abstractions.Websocket.csproj | 12 +++
 .../GraphQLWebSocketMessageType.cs            |  2 +-
 .../GraphQLWebSocketRequest.cs                |  2 +-
 .../GraphQLWebSocketResponse.cs               | 10 +--
 .../IGraphQLWebsocketJsonSerializer.cs        | 13 ++++
 .../WebsocketResponseWrapper.cs               |  2 +-
 .../IGraphQLJsonSerializer.cs                 |  4 +-
 ...raphQL.Client.Serializer.Newtonsoft.csproj | 16 ++++
 .../NewtonsoftJsonSerializer.cs               | 48 ++++++++++++
 .../NewtonsoftJsonSerializerOptions.cs        | 10 +++
 src/GraphQL.Client/GraphQL.Client.csproj      |  9 +++
 src/GraphQL.Client/GraphQLHttpClient.cs       |  2 +-
 .../GraphQLHttpClientOptions.cs               |  4 +-
 .../GraphQLSerializationExtensions.cs         | 10 +--
 .../Websocket/GraphQLHttpWebSocket.cs         | 15 ++--
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  |  9 ++-
 src/src.props                                 |  1 +
 .../ExtensionsTest.cs                         | 76 +++++++++----------
 19 files changed, 187 insertions(+), 72 deletions(-)
 create mode 100644 src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
 rename src/{GraphQL.Client/Websocket => GraphQL.Client.Abstractions.Websocket}/GraphQLWebSocketMessageType.cs (98%)
 rename src/{GraphQL.Client/Websocket => GraphQL.Client.Abstractions.Websocket}/GraphQLWebSocketRequest.cs (98%)
 rename src/{GraphQL.Client/Websocket => GraphQL.Client.Abstractions.Websocket}/GraphQLWebSocketResponse.cs (84%)
 create mode 100644 src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
 rename src/{GraphQL.Client/Websocket => GraphQL.Client.Abstractions.Websocket}/WebsocketResponseWrapper.cs (77%)
 rename src/{GraphQL.Client => GraphQL.Client.Abstractions}/IGraphQLJsonSerializer.cs (73%)
 create mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
 create mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
 create mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 1b6cc421..6d958137 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -58,6 +58,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Abstractions
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client", "src\GraphQL.Client\GraphQL.Client.csproj", "{ED3541C9-D2B2-4D06-A464-38E404A3919A}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Abstractions.Websocket", "src\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj", "{4D581CE1-523D-46BF-BAA5-F7D79A1B7654}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.Newtonsoft", "src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj", "{11F28E78-ADE4-4153-B97C-56136EB7BD5B}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -96,6 +100,14 @@ Global
 		{ED3541C9-D2B2-4D06-A464-38E404A3919A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{ED3541C9-D2B2-4D06-A464-38E404A3919A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{ED3541C9-D2B2-4D06-A464-38E404A3919A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4D581CE1-523D-46BF-BAA5-F7D79A1B7654}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4D581CE1-523D-46BF-BAA5-F7D79A1B7654}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4D581CE1-523D-46BF-BAA5-F7D79A1B7654}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4D581CE1-523D-46BF-BAA5-F7D79A1B7654}.Release|Any CPU.Build.0 = Release|Any CPU
+		{11F28E78-ADE4-4153-B97C-56136EB7BD5B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{11F28E78-ADE4-4153-B97C-56136EB7BD5B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{11F28E78-ADE4-4153-B97C-56136EB7BD5B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{11F28E78-ADE4-4153-B97C-56136EB7BD5B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -109,6 +121,8 @@ Global
 		{C68C26EB-7659-402A-93D1-E6E248DA5427} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{76E622F6-7CDD-4B1F-AD06-FFABF37C55E5} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{ED3541C9-D2B2-4D06-A464-38E404A3919A} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
+		{4D581CE1-523D-46BF-BAA5-F7D79A1B7654} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
+		{11F28E78-ADE4-4153-B97C-56136EB7BD5B} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
new file mode 100644
index 00000000..5dc9217a
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+	  <LangVersion>8.0</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
similarity index 98%
rename from src/GraphQL.Client/Websocket/GraphQLWebSocketMessageType.cs
rename to src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
index 755a075b..6bf17748 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Http.Websocket {
+namespace GraphQL.Client.Abstractions.Websocket {
 	public static class GraphQLWebSocketMessageType {
 
 		/// <summary>
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
similarity index 98%
rename from src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs
rename to src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index 01dcf173..f43995e2 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client.Http.Websocket {
+namespace GraphQL.Client.Abstractions.Websocket {
 
 	/// <summary>
 	/// A Subscription Request
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
similarity index 84%
rename from src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs
rename to src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
index 08171a6a..c0fd7bd8 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Http.Websocket {
+namespace GraphQL.Client.Abstractions.Websocket {
 
 	/// <summary>
 	/// A Subscription Response
@@ -60,10 +60,10 @@ public override int GetHashCode() {
 
 	}
 
-	public class GraphQLWebSocketResponse<TResponse> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TResponse>> {
-		public GraphQLHttpResponse<TResponse> Payload { get; set; }
+	public class GraphQLWebSocketResponse<TPayload> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TPayload>> {
+		public TPayload Payload { get; set; }
 
-		public bool Equals(GraphQLWebSocketResponse<TResponse>? other) {
+		public bool Equals(GraphQLWebSocketResponse<TPayload>? other) {
 			if (ReferenceEquals(null, other)) return false;
 			if (ReferenceEquals(this, other)) return true;
 			return base.Equals(other) && Payload.Equals(other.Payload);
@@ -73,7 +73,7 @@ public override bool Equals(object? obj) {
 			if (ReferenceEquals(null, obj)) return false;
 			if (ReferenceEquals(this, obj)) return true;
 			if (obj.GetType() != this.GetType()) return false;
-			return Equals((GraphQLWebSocketResponse<TResponse>)obj);
+			return Equals((GraphQLWebSocketResponse<TPayload>)obj);
 		}
 
 		public override int GetHashCode() {
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
new file mode 100644
index 00000000..285d69b6
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -0,0 +1,13 @@
+using System;
+using System.IO;
+
+namespace GraphQL.Client.Abstractions.Websocket
+{
+    public interface IGraphQLWebsocketJsonSerializer: IGraphQLJsonSerializer {
+	    byte[] SerializeToBytes(GraphQLWebSocketRequest request);
+
+	    WebsocketResponseWrapper DeserializeToWebsocketResponseWrapper(Stream stream);
+	    GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
+
+	}
+}
diff --git a/src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client.Abstractions.Websocket/WebsocketResponseWrapper.cs
similarity index 77%
rename from src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs
rename to src/GraphQL.Client.Abstractions.Websocket/WebsocketResponseWrapper.cs
index fd91ef78..5e90a38f 100644
--- a/src/GraphQL.Client/Websocket/WebsocketResponseWrapper.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/WebsocketResponseWrapper.cs
@@ -1,6 +1,6 @@
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Http.Websocket {
+namespace GraphQL.Client.Abstractions.Websocket {
 	public class WebsocketResponseWrapper : GraphQLWebSocketResponse {
 
 		[IgnoreDataMember]
diff --git a/src/GraphQL.Client/IGraphQLJsonSerializer.cs b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
similarity index 73%
rename from src/GraphQL.Client/IGraphQLJsonSerializer.cs
rename to src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
index b9dadd3a..f1f6cfb3 100644
--- a/src/GraphQL.Client/IGraphQLJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
@@ -2,9 +2,9 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client {
+namespace GraphQL.Client.Abstractions {
 	public interface IGraphQLJsonSerializer {
-		string Serialize(GraphQLRequest request);
+		string SerializeToString(GraphQLRequest request);
 
 		Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream,
 			CancellationToken cancellationToken);
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
new file mode 100644
index 00000000..9ae19080
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+	  <LangVersion>8.0</LangVersion>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
new file mode 100644
index 00000000..00b59fb7
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -0,0 +1,48 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Client.Abstractions.Websocket;
+using Newtonsoft.Json;
+
+namespace GraphQL.Client.Serializer.Newtonsoft
+{
+    public class NewtonsoftJsonSerializer: IGraphQLWebsocketJsonSerializer
+    {
+	    public NewtonsoftJsonSerializerOptions Options { get; }
+
+	    public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
+		    Options = options;
+	    }
+
+	    public string SerializeToString(GraphQLRequest request) {
+		    return JsonConvert.SerializeObject(request, Options.JsonSerializerSettings);
+		}
+
+		public byte[] SerializeToBytes(GraphQLWebSocketRequest request) {
+			var json = JsonConvert.SerializeObject(request, Options.JsonSerializerSettings);
+			return Encoding.UTF8.GetBytes(json);
+		}
+
+		public WebsocketResponseWrapper DeserializeToWebsocketResponseWrapper(Stream stream) {
+			using (StreamReader sr = new StreamReader(stream))
+			using (JsonReader reader = new JsonTextReader(sr)) {
+				JsonSerializer serializer = JsonSerializer.Create(Options.JsonSerializerSettings);
+
+				var wrapper = serializer.Deserialize<WebsocketResponseWrapper>(reader);
+				return wrapper;
+			}
+		}
+
+		public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
+			return JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
+				Options.JsonSerializerSettings);
+		}
+
+		public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
+		    throw new NotImplementedException();
+	    }
+
+    }
+}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
new file mode 100644
index 00000000..9148ed2e
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace GraphQL.Client.Serializer.Newtonsoft {
+	public class NewtonsoftJsonSerializerOptions {
+		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
+			ContractResolver = new CamelCasePropertyNamesContractResolver()
+		};
+	}
+}
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 2dfd5ad8..640f9b23 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -15,6 +15,14 @@
 		<DefineConstants>NETFRAMEWORK</DefineConstants>
 	</PropertyGroup>
 
+	<ItemGroup>
+	  <Compile Remove="GraphQLSerializationExtensions.cs" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <None Include="GraphQLSerializationExtensions.cs" />
+	</ItemGroup>
+
 
 	<ItemGroup>
 		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
@@ -25,6 +33,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
+	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 16e4b3cf..361b6195 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -117,7 +117,7 @@ private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TRespons
 
 		private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request) {
 			var message = new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
-				Content = new StringContent(JsonSerializer.Serialize(request), Encoding.UTF8, Options.MediaType)
+				Content = new StringContent(JsonSerializer.SerializeToString(request), Encoding.UTF8, Options.MediaType)
 			};
 
 			if (request is GraphQLHttpRequest httpRequest)
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index f3f10df9..8a9afae8 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -2,7 +2,7 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Threading.Tasks;
-using GraphQL.Client.Http.Websocket;
+using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Http {
 
@@ -19,7 +19,7 @@ public class GraphQLHttpClientOptions {
 		/// <summary>
 		/// the json serializer
 		/// </summary>
-		public IGraphQLWebSocketJsonSerializer JsonSerializer { get; set; }
+		public IGraphQLWebsocketJsonSerializer JsonSerializer { get; set; }
 
 		/// <summary>
 		/// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
diff --git a/src/GraphQL.Client/GraphQLSerializationExtensions.cs b/src/GraphQL.Client/GraphQLSerializationExtensions.cs
index 649d2c73..8d702204 100644
--- a/src/GraphQL.Client/GraphQLSerializationExtensions.cs
+++ b/src/GraphQL.Client/GraphQLSerializationExtensions.cs
@@ -2,6 +2,7 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
 using Newtonsoft.Json;
 
@@ -18,20 +19,15 @@ public static byte[] SerializeToBytes(this GraphQLRequest request,
 			var json = JsonConvert.SerializeObject(request, options.JsonSerializerSettings);
 			return Encoding.UTF8.GetBytes(json);
 		}
-		public static byte[] SerializeToBytes(this GraphQLWebSocketRequest request,
-			GraphQLHttpClientOptions options) {
-			var json = JsonConvert.SerializeObject(request, options.JsonSerializerSettings);
-			return Encoding.UTF8.GetBytes(json);
-		}
 
 		public static TGraphQLResponse DeserializeFromJson<TGraphQLResponse>(this string jsonString,
 			GraphQLHttpClientOptions options) {
 			return JsonConvert.DeserializeObject<TGraphQLResponse>(jsonString, options.JsonSerializerSettings);
 		}
 
-		public static TObject DeserializeFromBytes<TObject>(this byte[] utf8bytes,
+		public static TObject DeserializeFromBytes<TObject>(this byte[] utf8Bytes,
 			GraphQLHttpClientOptions options) {
-			return JsonConvert.DeserializeObject<TObject>(Encoding.UTF8.GetString(utf8bytes), options.JsonSerializerSettings);
+			return JsonConvert.DeserializeObject<TObject>(Encoding.UTF8.GetString(utf8Bytes), options.JsonSerializerSettings);
 		}
 
 
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 5a4e76c2..d5bdcc04 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -9,7 +9,7 @@
 using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
-using Newtonsoft.Json;
+using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Http.Websocket {
 	internal class GraphQLHttpWebSocket : IDisposable {
@@ -59,7 +59,7 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request) {
 				}
 
 				await InitializeWebSocket().ConfigureAwait(false);
-				var requestBytes = request.SerializeToBytes(_options);
+				var requestBytes = _options.JsonSerializer.SerializeToBytes(request);
 				await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
@@ -223,14 +223,9 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 					ms.Seek(0, SeekOrigin.Begin);
 
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
-						using (StreamReader sr = new StreamReader(ms))
-						using (JsonReader reader = new JsonTextReader(sr)) {
-							JsonSerializer serializer = JsonSerializer.Create(_options.JsonSerializerSettings);
-
-							var response = serializer.Deserialize<WebsocketResponseWrapper>(reader);
-							response.MessageBytes = ms.ToArray();
-							return response;
-						}
+						var response = _options.JsonSerializer.DeserializeToWebsocketResponseWrapper(ms);
+						response.MessageBytes = ms.ToArray();
+						return response;
 					}
 					else {
 						throw new NotSupportedException("binary websocket messages are not supported");
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
index ff0aa5e1..9148a727 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -6,7 +6,7 @@
 using System.Reactive.Threading.Tasks;
 using System.Threading;
 using System.Threading.Tasks;
-using Newtonsoft.Json;
+using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Http.Websocket {
 	public static class GraphQLHttpWebsocketHelpers {
@@ -48,7 +48,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 									// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
 									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
 									var typedResponse =
-										client.Options.JsonSerializer.DeserializeWebSocketResponse<TResponse>(
+										client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
 											response.MessageBytes);
 									o.OnNext(typedResponse.Payload);
 
@@ -169,8 +169,9 @@ internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 						.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
 						.Select(response => {
 							Debug.WriteLine($"received response for request {websocketRequest.Id}");
-							var typedResponse = client.Options.JsonSerializer
-								.DeserializeWebSocketResponse<TResponse>(response.MessageBytes);
+							var typedResponse =
+								client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+									response.MessageBytes);
 							return typedResponse.Payload;
 						});
 
diff --git a/src/src.props b/src/src.props
index 19e1fafb..e2e2512b 100644
--- a/src/src.props
+++ b/src/src.props
@@ -5,6 +5,7 @@
 
 	<PropertyGroup>
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+		<LangVersion>8.0</LangVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
index fff1b6e4..1ffaabd2 100644
--- a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
@@ -13,48 +13,48 @@ public class ExtensionsTest {
 		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) =>
 			WebHostHelpers.SetupTest<StartupChat>(requestsViaWebsocket);
 
-		[Fact]
-		public async void CanDeserializeExtensions() {
+		//[Fact]
+		//public async void CanDeserializeExtensions() {
 
-			using var setup = SetupTest();
-			var response = await setup.Client.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
-					() => new {extensionsTest = ""})
-				.ConfigureAwait(false);
+		//	using var setup = SetupTest();
+		//	var response = await setup.Client.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
+		//			() => new {extensionsTest = ""})
+		//		.ConfigureAwait(false);
 
-			response.Errors.Should().NotBeNull();
-			response.Errors.Should().ContainSingle();
-			response.Errors[0].Extensions.Should().NotBeNull();
-			response.Errors[0].Extensions.Should().ContainKey("data");
+		//	response.Errors.Should().NotBeNull();
+		//	response.Errors.Should().ContainSingle();
+		//	response.Errors[0].Extensions.Should().NotBeNull();
+		//	response.Errors[0].Extensions.Should().ContainKey("data");
 
-			foreach (var item in ChatQuery.TestExtensions) {
+		//	foreach (var item in ChatQuery.TestExtensions) {
 				
 
-			}
-		}
-
-		[Fact]
-		public async void DontNeedToUseCamelCaseNamingStrategy() {
-
-			using var setup = SetupTest();
-			setup.Client.Options.JsonSerializerSettings = new JsonSerializerSettings();
-
-			const string message = "some random testing message";
-			var graphQLRequest = new GraphQLRequest(
-				@"mutation($input: MessageInputType){
-				  addMessage(message: $input){
-				    content
-				  }
-				}",
-				new {
-					input = new {
-						fromId = "2",
-						content = message,
-						sentAt = DateTime.Now
-					}
-				});
-			var response = await setup.Client.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
-
-			Assert.Equal(message, response.Data.addMessage.content);
-		}
+		//	}
+		//}
+
+		//[Fact]
+		//public async void DontNeedToUseCamelCaseNamingStrategy() {
+
+		//	using var setup = SetupTest();
+		//	setup.Client.Options.JsonSerializerSettings = new JsonSerializerSettings();
+
+		//	const string message = "some random testing message";
+		//	var graphQLRequest = new GraphQLRequest(
+		//		@"mutation($input: MessageInputType){
+		//		  addMessage(message: $input){
+		//		    content
+		//		  }
+		//		}",
+		//		new {
+		//			input = new {
+		//				fromId = "2",
+		//				content = message,
+		//				sentAt = DateTime.Now
+		//			}
+		//		});
+		//	var response = await setup.Client.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
+
+		//	Assert.Equal(message, response.Data.addMessage.content);
+		//}
 	}
 }

From 5ece68c821d0b2ff5537a71f92027d432db0304d Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 9 Feb 2020 22:29:27 +0100
Subject: [PATCH 137/455] add constructor for di

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 361b6195..2d7794d2 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -5,6 +5,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
+using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
 
 namespace GraphQL.Client.Http {
@@ -52,6 +53,13 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
+		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer) {
+			Options = options;
+			Options.JsonSerializer = serializer;
+			this.HttpClient = httpClient;
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
+		}
+
 		/// <inheritdoc />
 		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations

From c4b5e0fee6af4e9eb83da18a49024200e0654273 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 14:44:45 +0100
Subject: [PATCH 138/455] create Extension classes to allow for custom json
 converters

---
 src/GraphQL.Primitives/GraphQLError.cs    | 10 ++++++++++
 src/GraphQL.Primitives/GraphQLResponse.cs |  9 ++++++++-
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index b08105c4..7c0b0c62 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -28,6 +28,12 @@ public class GraphQLError : IEquatable<GraphQLError?> {
 		[DataMember(Name = "path")]
 		public object[]? Path { get; set; }
 
+		/// <summary>
+		/// The extensions of the error
+		/// </summary> 
+		[DataMember(Name = "extensions")]
+		public ExtensionsType? Extensions { get; set; }
+
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
 		/// </summary>
@@ -95,6 +101,10 @@ public override int GetHashCode() {
 		public static bool operator !=(GraphQLError? left, GraphQLError? right) =>
 			!EqualityComparer<GraphQLError?>.Default.Equals(left, right);
 
+		/// <summary>
+		/// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
+		/// </summary>
+		public class ExtensionsType : Dictionary<string, object?> { }
 	}
 
 }
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 0145229d..aa58ff77 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -12,7 +12,10 @@ public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
 
 		[DataMember(Name = "errors")]
 		public GraphQLError[]? Errors { get; set; }
-		
+
+		[DataMember(Name = "extensions")]
+		public ExtensionsType? Extensions { get; set; }
+
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
 
 		public bool Equals(GraphQLResponse<T>? other) {
@@ -51,6 +54,10 @@ public override int GetHashCode() {
 
 		public static bool operator !=(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => !(response1 == response2);
 
+		/// <summary>
+		/// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
+		/// </summary>
+		public class ExtensionsType : Dictionary<string, object?> { }
 	}
 
 

From 0609ea3ba534553ad31f5c4da1a4af93170b41d8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 15:07:44 +0100
Subject: [PATCH 139/455] automatically create the first discovered serializer
 if none has been provided

---
 .../IGraphQLWebsocketJsonSerializer.cs        |  4 +++
 .../NewtonsoftJsonSerializer.cs               | 27 ++++++++++++-------
 src/GraphQL.Client/GraphQL.Client.csproj      |  1 +
 src/GraphQL.Client/GraphQLHttpClient.cs       | 24 +++++++++++++++--
 4 files changed, 44 insertions(+), 12 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index 285d69b6..10448b80 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -3,6 +3,10 @@
 
 namespace GraphQL.Client.Abstractions.Websocket
 {
+	/// <summary>
+	/// The json serializer interface for the graphql-dotnet http client.
+	/// Implementations should provide a parameterless constructor for convenient usage
+	/// </summary>
     public interface IGraphQLWebsocketJsonSerializer: IGraphQLJsonSerializer {
 	    byte[] SerializeToBytes(GraphQLWebSocketRequest request);
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 00b59fb7..08afd595 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -12,6 +12,11 @@ public class NewtonsoftJsonSerializer: IGraphQLWebsocketJsonSerializer
     {
 	    public NewtonsoftJsonSerializerOptions Options { get; }
 
+	    public NewtonsoftJsonSerializer()
+	    {
+			Options = new NewtonsoftJsonSerializerOptions();
+	    }
+
 	    public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
 		    Options = options;
 	    }
@@ -26,13 +31,7 @@ public byte[] SerializeToBytes(GraphQLWebSocketRequest request) {
 		}
 
 		public WebsocketResponseWrapper DeserializeToWebsocketResponseWrapper(Stream stream) {
-			using (StreamReader sr = new StreamReader(stream))
-			using (JsonReader reader = new JsonTextReader(sr)) {
-				JsonSerializer serializer = JsonSerializer.Create(Options.JsonSerializerSettings);
-
-				var wrapper = serializer.Deserialize<WebsocketResponseWrapper>(reader);
-				return wrapper;
-			}
+			return DeserializeFromUtf8Stream<WebsocketResponseWrapper>(stream);
 		}
 
 		public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
@@ -41,8 +40,16 @@ public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsock
 		}
 
 		public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
-		    throw new NotImplementedException();
-	    }
+			return Task.FromResult(DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream));
+		}
+
+
+		private T DeserializeFromUtf8Stream<T>(Stream stream) {
+			using StreamReader sr = new StreamReader(stream);
+			using JsonReader reader = new JsonTextReader(sr);
+			JsonSerializer serializer = JsonSerializer.Create(Options.JsonSerializerSettings);
+			return serializer.Deserialize<T>(reader);
+		}
 
-    }
+	}
 }
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 640f9b23..31fa21ab 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -35,6 +35,7 @@
 	<ItemGroup>
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+	  <ProjectReference Include="..\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
 	</ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 2d7794d2..3f5bd89d 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Linq;
 using System.Net.Http;
 using System.Text;
 using System.Threading;
@@ -39,24 +40,27 @@ public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
 			configure(Options);
 			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
+			EnsureSerializerAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			Options = options;
 			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
+			EnsureSerializerAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
 			Options = options;
 			this.HttpClient = httpClient;
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
+			EnsureSerializerAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer) {
 			Options = options;
-			Options.JsonSerializer = serializer;
-			this.HttpClient = httpClient;
+			Options.JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
+			this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
@@ -111,6 +115,22 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
 		#region Private Methods
 
+		private void EnsureSerializerAssigned() {
+			// return if a serializer was assigned
+			if (JsonSerializer != null) return;
+
+			// else try to find one in the assembly and assign that
+			var type = typeof(IGraphQLWebsocketJsonSerializer);
+			var serializerType = AppDomain.CurrentDomain
+				.GetAssemblies()
+				.SelectMany(s => s.GetTypes())
+				.FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
+			if(serializerType == null)
+				throw new InvalidOperationException($"no implementation of \"{type}\" found");
+
+			Options.JsonSerializer = (IGraphQLWebsocketJsonSerializer) Activator.CreateInstance(serializerType);
+		}
+
 		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			var preprocessedRequest = await Options.PreprocessRequest(request, this);
 			using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest);

From b138e27940f876c3bc1f39ecba817452679b1320 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 16:13:37 +0100
Subject: [PATCH 140/455] create LocalExecutionClient

---
 GraphQL.Client.sln                            |   9 +-
 ...aphQL.Client.Abstractions.Websocket.csproj |  13 ++-
 .../IGraphQLWebsocketJsonSerializer.cs        |   1 -
 .../GraphQLJsonSerializerExtensions.cs        |  22 ++++
 .../IGraphQLClient.cs                         |   5 -
 .../IGraphQLJsonSerializer.cs                 |   2 +
 .../ExecutionResultExtensions.cs              |   5 +
 .../GraphQL.Client.LocalExecution.csproj      |  20 ++++
 .../GraphQLEnumConverter.cs                   |  31 +++++
 .../GraphQLLocalExecutionClient.cs            | 109 ++++++++++++++++++
 src/GraphQL.Client/GraphQLHttpClient.cs       |  24 +---
 11 files changed, 208 insertions(+), 33 deletions(-)
 create mode 100644 src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
 create mode 100644 src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
 create mode 100644 src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
 create mode 100644 src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
 create mode 100644 src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 6d958137..071e73f1 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -58,10 +58,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Abstractions
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client", "src\GraphQL.Client\GraphQL.Client.csproj", "{ED3541C9-D2B2-4D06-A464-38E404A3919A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Abstractions.Websocket", "src\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj", "{4D581CE1-523D-46BF-BAA5-F7D79A1B7654}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Abstractions.Websocket", "src\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj", "{4D581CE1-523D-46BF-BAA5-F7D79A1B7654}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.Newtonsoft", "src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj", "{11F28E78-ADE4-4153-B97C-56136EB7BD5B}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.LocalExecution", "src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj", "{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -108,6 +110,10 @@ Global
 		{11F28E78-ADE4-4153-B97C-56136EB7BD5B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{11F28E78-ADE4-4153-B97C-56136EB7BD5B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{11F28E78-ADE4-4153-B97C-56136EB7BD5B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -123,6 +129,7 @@ Global
 		{ED3541C9-D2B2-4D06-A464-38E404A3919A} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{4D581CE1-523D-46BF-BAA5-F7D79A1B7654} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{11F28E78-ADE4-4153-B97C-56136EB7BD5B} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
+		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index 5dc9217a..30202e85 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -1,12 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
+	<Import Project="../src.props" />
 
-  <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+	<PropertyGroup>
+	<TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
 	  <LangVersion>8.0</LangVersion>
-  </PropertyGroup>
+	</PropertyGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
-  </ItemGroup>
+	<ItemGroup>
+	<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+	</ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index 10448b80..7a215911 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -1,4 +1,3 @@
-using System;
 using System.IO;
 
 namespace GraphQL.Client.Abstractions.Websocket
diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
new file mode 100644
index 00000000..8e574e57
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Linq;
+
+namespace GraphQL.Client.Abstractions {
+	public static class GraphQLJsonSerializerExtensions {
+		public static void EnsureAssigned<TSerializerInterface>(this TSerializerInterface jsonSerializer) where TSerializerInterface: IGraphQLJsonSerializer {
+			// return if a serializer was assigned
+			if (jsonSerializer != null) return;
+
+			// else try to find one in the assembly and assign that
+			var type = typeof(TSerializerInterface);
+			var serializerType = AppDomain.CurrentDomain
+				.GetAssemblies()
+				.SelectMany(s => s.GetTypes())
+				.FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
+			if (serializerType == null)
+				throw new InvalidOperationException($"no implementation of \"{type}\" found");
+
+			jsonSerializer = (TSerializerInterface)Activator.CreateInstance(serializerType);
+		}
+	}
+}
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
index 3b47a932..6889a179 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
@@ -31,11 +31,6 @@ public interface IGraphQLClient : IDisposable {
 		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
 		/// <returns>an observable stream for the specified subscription</returns>
 		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler);
-
-		/// <summary>
-		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
-		/// </summary>
-		IObservable<Exception> WebSocketReceiveErrors { get; }
 	}
 
 }
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
index f1f6cfb3..d29378ca 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
@@ -9,4 +9,6 @@ public interface IGraphQLJsonSerializer {
 		Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream,
 			CancellationToken cancellationToken);
 	}
+
+
 }
diff --git a/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs b/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
new file mode 100644
index 00000000..a8ce44d8
--- /dev/null
+++ b/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
@@ -0,0 +1,5 @@
+namespace GraphQL.Client.LocalExecution {
+	public class ExecutionResultExtensions {
+		
+	}
+}
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
new file mode 100644
index 00000000..3cd19e04
--- /dev/null
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<Import Project="../src.props" />
+
+	<PropertyGroup>
+		<Description>A GraphQL Client which executes the queries directly on a provided C# schema</Description>
+		<TargetFramework>netstandard2.0</TargetFramework>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="GraphQL" Version="2.4.0" />
+		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+		<PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+	</ItemGroup>
+
+</Project>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs b/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
new file mode 100644
index 00000000..a9919454
--- /dev/null
+++ b/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using GraphQL.Utilities;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace GraphQL.Client.LocalExecution {
+	public class GraphQLEnumConverter : StringEnumConverter {
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {
+			if (value == null) {
+				writer.WriteNull();
+			}
+			else {
+				var enumString = ((Enum)value).ToString("G");
+				var memberName = value.GetType()
+					.GetMember(enumString, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
+					.FirstOrDefault()?.Name;
+				if (string.IsNullOrEmpty(memberName)) {
+					if (!AllowIntegerValues)
+						throw new JsonSerializationException($"Integer value {value} is not allowed.");
+					writer.WriteValue(value);
+				}
+				else {
+					writer.WriteValue(StringUtils.ToConstantCase(memberName));
+				}
+			}
+		}
+	}
+
+}
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
new file mode 100644
index 00000000..763be879
--- /dev/null
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Client.Abstractions;
+using GraphQL.Subscription;
+using GraphQL.Types;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+
+namespace GraphQL.Client.LocalExecution
+{
+    public class GraphQLLocalExecutionClient<TSchema>: IGraphQLClient where TSchema: ISchema
+    {
+
+	    private static readonly JsonSerializerSettings VariablesSerializerSettings = new JsonSerializerSettings {
+		    Formatting = Formatting.Indented,
+		    DateTimeZoneHandling = DateTimeZoneHandling.Local,
+		    ContractResolver = new CamelCasePropertyNamesContractResolver(),
+		    Converters = new List<JsonConverter>
+		    {
+			    new GraphQLEnumConverter()
+		    }
+	    };
+
+		public TSchema Schema { get; }
+		public IGraphQLJsonSerializer Serializer { get; }
+
+
+		private readonly DocumentExecuter documentExecuter;
+
+		public GraphQLLocalExecutionClient(TSchema schema) {
+			Serializer.EnsureAssigned();
+			Schema = schema;
+			if (!Schema.Initialized) Schema.Initialize();
+			documentExecuter = new DocumentExecuter();
+		}
+
+		public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer) : this(schema) {
+			Serializer = serializer;
+		}
+
+		public void Dispose() { }
+
+	    public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+		    => ExecuteQueryAsync<TResponse>(request, cancellationToken);
+
+	    public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+		    => ExecuteQueryAsync<TResponse>(request, cancellationToken);
+
+		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) {
+			return Observable.Defer(() => ExecuteSubscriptionAsync<TResponse>(request).ToObservable())
+				.Concat()
+				.Publish()
+				.RefCount();
+		}
+
+		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request,
+			Action<Exception> exceptionHandler)
+			=> CreateSubscriptionStream<TResponse>(request);
+
+	    #region Private Methods
+
+	    private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken) {
+		    var executionResult = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+		    return await ExecutionResultToGraphQLResponse<TResponse>(executionResult, cancellationToken).ConfigureAwait(false);
+	    }
+	    private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		    var result = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+		    return ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault()?
+			    .SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
+	    }
+
+	    private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		    var serializedRequest = Serializer.SerializeToString(request);
+
+		    var deserializedRequest = JsonConvert.DeserializeObject<GraphQLRequest>(serializedRequest);
+		    var inputs = deserializedRequest.Variables != null
+			    ? (JObject.FromObject(request.Variables, JsonSerializer.Create(VariablesSerializerSettings)) as JObject)
+			    .ToInputs()
+			    : null;
+
+		    var result = await documentExecuter.ExecuteAsync(options => {
+			    options.Schema = Schema;
+			    options.OperationName = request.OperationName;
+			    options.Query = request.Query;
+			    options.Inputs = inputs;
+			    options.CancellationToken = cancellationToken;
+		    }).ConfigureAwait(false);
+
+		    return result;
+	    }
+
+	    private Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponse<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default) {
+		    // serialize result into utf8 byte stream
+		    var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(executionResult, VariablesSerializerSettings)));
+		    // deserialize using the provided serializer
+		    return Serializer.DeserializeFromUtf8StreamAsync<TResponse>(resultStream, cancellationToken);
+	    }
+
+	    #endregion
+	}
+}
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 3f5bd89d..b59eb820 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -16,7 +16,7 @@ public class GraphQLHttpClient : IGraphQLClient {
 		private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 		private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
-		private IGraphQLJsonSerializer JsonSerializer => Options.JsonSerializer;
+		private IGraphQLWebsocketJsonSerializer JsonSerializer => Options.JsonSerializer;
 
 		/// <summary>
 		/// the instance of <see cref="HttpClient"/> which is used internally
@@ -40,21 +40,21 @@ public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
 			configure(Options);
 			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			EnsureSerializerAssigned();
+			JsonSerializer.EnsureAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			Options = options;
 			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			EnsureSerializerAssigned();
+			JsonSerializer.EnsureAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
 			Options = options;
 			this.HttpClient = httpClient;
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			EnsureSerializerAssigned();
+			JsonSerializer.EnsureAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer) {
@@ -115,22 +115,6 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
 		#region Private Methods
 
-		private void EnsureSerializerAssigned() {
-			// return if a serializer was assigned
-			if (JsonSerializer != null) return;
-
-			// else try to find one in the assembly and assign that
-			var type = typeof(IGraphQLWebsocketJsonSerializer);
-			var serializerType = AppDomain.CurrentDomain
-				.GetAssemblies()
-				.SelectMany(s => s.GetTypes())
-				.FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
-			if(serializerType == null)
-				throw new InvalidOperationException($"no implementation of \"{type}\" found");
-
-			Options.JsonSerializer = (IGraphQLWebsocketJsonSerializer) Activator.CreateInstance(serializerType);
-		}
-
 		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			var preprocessedRequest = await Options.PreprocessRequest(request, this);
 			using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest);

From a2dc54074d11c610265c65fc4e237bd8c9db5aa2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 18:24:04 +0100
Subject: [PATCH 141/455] create test setup for serializers

---
 GraphQL.Client.sln                            | 14 ++++
 .../GraphQL.Client.Abstractions.csproj        |  2 +-
 .../GraphQLJsonSerializerExtensions.cs        | 26 +++---
 .../GraphQLLocalExecutionClient.cs            | 12 ++-
 .../NewtonsoftJsonSerializer.cs               | 11 ++-
 src/GraphQL.Client/GraphQLHttpClient.cs       |  6 +-
 .../BaseSerializerTest.cs                     | 79 +++++++++++++++++++
 .../GraphQL.Client.Serializer.Tests.csproj    | 24 ++++++
 .../NewtonsoftSerializerTest.cs               | 30 +++++++
 .../Chat/AddMessageMutationResult.cs          |  9 +++
 .../Chat/AddMessageVariables.cs               | 15 ++++
 .../Chat/GraphQLClientChatExtensions.cs       | 39 +++++++++
 .../Chat/JoinDeveloperMutationResult.cs       | 10 +++
 .../Schema}/CapitalizedFieldsGraphType.cs     |  7 +-
 .../Chat/Schema}/ChatMutation.cs              |  2 +-
 .../Chat/Schema}/ChatQuery.cs                 |  3 +-
 .../Chat/Schema/ChatSchema.cs                 | 10 +++
 .../Chat/Schema}/ChatSubscriptions.cs         |  3 +-
 .../Chat/Schema}/IChat.cs                     |  2 +-
 .../Chat/Schema}/Message.cs                   |  2 +-
 .../Chat/Schema}/MessageFrom.cs               |  2 +-
 .../Chat/Schema}/MessageFromType.cs           |  2 +-
 .../Chat/Schema}/MessageType.cs               |  2 +-
 .../Chat/Schema}/ReceivedMessage.cs           |  2 +-
 tests/GraphQL.Client.Tests.Common/Common.cs   | 46 +++++++++++
 .../GraphQL.Client.Tests.Common.csproj        | 20 +++++
 .../StarWars}/StarWarsHumans.cs               |  2 +-
 .../Extensions/GraphQLClientTestExtensions.cs | 15 ++--
 .../ExtensionsTest.cs                         | 26 ------
 .../QueryAndMutationTests.cs                  |  2 +-
 .../ChatSchema/ChatSchema.cs                  | 11 ---
 .../IntegrationTestServer.csproj              |  8 +-
 tests/IntegrationTestServer/StartupChat.cs    | 15 ++--
 .../IntegrationTestServer/StartupStarWars.cs  | 13 +--
 34 files changed, 365 insertions(+), 107 deletions(-)
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/CapitalizedFieldsGraphType.cs (58%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/ChatMutation.cs (94%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/ChatQuery.cs (91%)
 create mode 100644 tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/ChatSubscriptions.cs (97%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/IChat.cs (97%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/Message.cs (79%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/MessageFrom.cs (67%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/MessageFromType.cs (76%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/MessageType.cs (88%)
 rename tests/{IntegrationTestServer/ChatSchema => GraphQL.Client.Tests.Common/Chat/Schema}/ReceivedMessage.cs (76%)
 create mode 100644 tests/GraphQL.Client.Tests.Common/Common.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
 rename tests/{GraphQL.Integration.Tests/TestData => GraphQL.Client.Tests.Common/StarWars}/StarWarsHumans.cs (87%)
 delete mode 100644 tests/IntegrationTestServer/ChatSchema/ChatSchema.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 071e73f1..df866b4e 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -64,6 +64,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.N
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.LocalExecution", "src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj", "{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Serializer.Tests", "tests\GraphQL.Client.Serializer.Tests\GraphQL.Client.Serializer.Tests.csproj", "{CA842D18-FC4A-4281-B1FF-080FA91887B8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Tests.Common", "tests\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj", "{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -114,6 +118,14 @@ Global
 		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CA842D18-FC4A-4281-B1FF-080FA91887B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CA842D18-FC4A-4281-B1FF-080FA91887B8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CA842D18-FC4A-4281-B1FF-080FA91887B8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CA842D18-FC4A-4281-B1FF-080FA91887B8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -130,6 +142,8 @@ Global
 		{4D581CE1-523D-46BF-BAA5-F7D79A1B7654} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{11F28E78-ADE4-4153-B97C-56136EB7BD5B} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
+		{CA842D18-FC4A-4281-B1FF-080FA91887B8} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 6430f4b7..78972572 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -13,7 +13,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="System.Reactive" Version="4.1.2" />
+		<PackageReference Include="System.Reactive" Version="4.3.2" />
 	</ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index 8e574e57..b652c782 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -3,20 +3,22 @@
 
 namespace GraphQL.Client.Abstractions {
 	public static class GraphQLJsonSerializerExtensions {
-		public static void EnsureAssigned<TSerializerInterface>(this TSerializerInterface jsonSerializer) where TSerializerInterface: IGraphQLJsonSerializer {
-			// return if a serializer was assigned
-			if (jsonSerializer != null) return;
+		public static TSerializerInterface EnsureAssigned<TSerializerInterface>(this TSerializerInterface jsonSerializer) where TSerializerInterface: IGraphQLJsonSerializer {
+			// if no serializer was assigned
+			if (jsonSerializer == null) {
+				// try to find one in the assembly and assign that
+				var type = typeof(TSerializerInterface);
+				var serializerType = AppDomain.CurrentDomain
+					.GetAssemblies()
+					.SelectMany(s => s.GetTypes())
+					.FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
+				if (serializerType == null)
+					throw new InvalidOperationException($"no implementation of \"{type}\" found");
 
-			// else try to find one in the assembly and assign that
-			var type = typeof(TSerializerInterface);
-			var serializerType = AppDomain.CurrentDomain
-				.GetAssemblies()
-				.SelectMany(s => s.GetTypes())
-				.FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
-			if (serializerType == null)
-				throw new InvalidOperationException($"no implementation of \"{type}\" found");
+				jsonSerializer = (TSerializerInterface)Activator.CreateInstance(serializerType);
+			}
 
-			jsonSerializer = (TSerializerInterface)Activator.CreateInstance(serializerType);
+			return jsonSerializer;
 		}
 	}
 }
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 763be879..d73e2cc6 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -16,8 +16,16 @@
 
 namespace GraphQL.Client.LocalExecution
 {
-    public class GraphQLLocalExecutionClient<TSchema>: IGraphQLClient where TSchema: ISchema
-    {
+	public static class GraphQLLocalExecutionClient {
+		public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema) where TSchema : ISchema
+			=> new GraphQLLocalExecutionClient<TSchema>(schema);
+
+		public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer serializer) where TSchema : ISchema
+			=> new GraphQLLocalExecutionClient<TSchema>(schema, serializer);
+	}
+
+
+	public class GraphQLLocalExecutionClient<TSchema>: IGraphQLClient where TSchema: ISchema {
 
 	    private static readonly JsonSerializerSettings VariablesSerializerSettings = new JsonSerializerSettings {
 		    Formatting = Formatting.Indented,
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 08afd595..62308cb8 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -15,13 +15,18 @@ public class NewtonsoftJsonSerializer: IGraphQLWebsocketJsonSerializer
 	    public NewtonsoftJsonSerializer()
 	    {
 			Options = new NewtonsoftJsonSerializerOptions();
-	    }
+		}
+		public NewtonsoftJsonSerializer(Action<NewtonsoftJsonSerializerOptions> configure) {
+			Options = new NewtonsoftJsonSerializerOptions();
+			configure(Options);
+		}
 
-	    public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
+		public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
 		    Options = options;
 	    }
 
-	    public string SerializeToString(GraphQLRequest request) {
+
+		public string SerializeToString(GraphQLRequest request) {
 		    return JsonConvert.SerializeObject(request, Options.JsonSerializerSettings);
 		}
 
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index b59eb820..85339e6a 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -40,21 +40,21 @@ public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
 			configure(Options);
 			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			JsonSerializer.EnsureAssigned();
+			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
 			Options = options;
 			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			JsonSerializer.EnsureAssigned();
+			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
 			Options = options;
 			this.HttpClient = httpClient;
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			JsonSerializer.EnsureAssigned();
+			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer) {
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
new file mode 100644
index 00000000..4168ef79
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using FluentAssertions;
+using GraphQL.Client.Abstractions;
+using GraphQL.Client.Abstractions.Websocket;
+using GraphQL.Client.LocalExecution;
+using GraphQL.Client.Tests.Common;
+using GraphQL.Client.Tests.Common.Chat;
+using GraphQL.Client.Tests.Common.Chat.Schema;
+using GraphQL.Client.Tests.Common.StarWars;
+using Xunit;
+
+namespace GraphQL.Client.Serializer.Tests
+{
+    public abstract class BaseSerializerTest
+    {
+	    public IGraphQLClient ChatClient { get; }
+	    public IGraphQLClient StarWarsClient { get; }
+
+		protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer serializer) {
+			ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
+			StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
+		}
+
+		[Fact]
+		public async void CanDeserializeExtensions() {
+
+			var response = await ChatClient.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
+					() => new { extensionsTest = "" })
+				.ConfigureAwait(false);
+
+			response.Errors.Should().NotBeNull();
+			response.Errors.Should().ContainSingle();
+			response.Errors[0].Extensions.Should().NotBeNull();
+			response.Errors[0].Extensions.Should().ContainKey("data");
+
+			AssertGraphQlErrorDataExtensions(response.Errors[0].Extensions["data"], ChatQuery.TestExtensions);
+		}
+
+		/// <summary>
+		/// serializer-specific assertion of the <see cref="GraphQLError.Extensions"/> field
+		/// </summary>
+		/// <param name="dataField">the field with key "data" from <see cref="GraphQLError.Extensions"/></param>
+		/// <param name="expectedContent"><see cref="ChatQuery.TestExtensions"/></param>
+		protected abstract void AssertGraphQlErrorDataExtensions(object dataField, IDictionary<string, object> expectedContent);
+
+		[Theory]
+		[ClassData(typeof(StarWarsHumans))]
+		public async void CanDoSerializationWithAnonymousTypes(int id, string name) {
+			var graphQLRequest = new GraphQLRequest(@"
+				query Human($id: String!){
+					human(id: $id) {
+						name
+					}
+				}
+
+				query Droid($id: String!) {
+				  droid(id: $id) {
+				    name
+				  }
+				}",
+				new { id = id.ToString() },
+				"Human");
+
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
+				.ConfigureAwait(false);
+
+			Assert.Null(response.Errors);
+			Assert.Equal(name, response.Data.Human.Name);
+		}
+
+		[Fact]
+		public async void CanDoSerializationWithPredefinedTypes() {
+				const string message = "some random testing message";
+				var response = await ChatClient.AddMessageAsync(message).ConfigureAwait(false);
+
+				Assert.Equal(message, response.Data.AddMessage.Content);
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
new file mode 100644
index 00000000..f84cef2c
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+    <PackageReference Include="coverlet.collector" Version="1.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
+    <ProjectReference Include="..\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
new file mode 100644
index 00000000..9cbb7b4e
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using FluentAssertions;
+using GraphQL.Client.Serializer.Newtonsoft;
+using Newtonsoft.Json.Linq;
+using Xunit;
+
+namespace GraphQL.Client.Serializer.Tests {
+	public class NewtonsoftSerializerTest : BaseSerializerTest {
+		public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
+
+		protected override void AssertGraphQlErrorDataExtensions(object dataField, IDictionary<string, object> expectedContent) {
+			dataField.Should().BeOfType<JObject>().Which.Should().ContainKeys(expectedContent.Keys);
+			var data = (JObject) dataField;
+
+			foreach (var item in expectedContent) {
+				switch (item.Value) {
+					case int i:
+						data[item.Key].Value<int>().Should().Be(i);
+						break;
+					case string s:
+						data[item.Key].Value<string>().Should().BeEquivalentTo(s);
+						break;
+					default:
+						Assert.True(false, $"unexpected value type \"{item.Value.GetType()}\" in expected content! Please review this unit test and add the missing type case!");
+						break;
+				}
+			}
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
new file mode 100644
index 00000000..e3aaaf1c
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
@@ -0,0 +1,9 @@
+namespace GraphQL.Client.Tests.Common.Chat
+{
+	public class AddMessageMutationResult {
+		public AddMessageContent AddMessage { get; set; }
+		public class AddMessageContent {
+			public string Content { get; set; }
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
new file mode 100644
index 00000000..129c5c2d
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Client.Tests.Common.Chat {
+	public class AddMessageVariables {
+
+		public AddMessageInput Input { get; set; }
+		public class AddMessageInput {
+			public string FromId { get; set; }
+			public string Content { get; set; }
+			public DateTime SentAt { get; set; }
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
new file mode 100644
index 00000000..44319a17
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+using GraphQL.Client.Abstractions;
+
+namespace GraphQL.Client.Tests.Common.Chat {
+	public static class GraphQLClientChatExtensions {
+		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message) {
+			var graphQLRequest = new GraphQLRequest(
+				@"mutation($input: MessageInputType){
+				  addMessage(message: $input){
+				    content
+				  }
+				}",
+				new {
+					input = new {
+						fromId = "2",
+						content = message,
+						sentAt = DateTime.Now
+					}
+				});
+			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
+		}
+
+		public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this IGraphQLClient client) {
+			var graphQLRequest = new GraphQLRequest(@"
+				mutation($userId: String){
+				  join(userId: $userId){
+				    displayName
+				    id
+				  }
+				}",
+				new {
+					userId = "1"
+				});
+			return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
+		}
+
+	}
+}
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
new file mode 100644
index 00000000..2807a5b2
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
@@ -0,0 +1,10 @@
+namespace GraphQL.Client.Tests.Common.Chat
+{
+	public class JoinDeveloperMutationResult {
+		public JoinContent Join { get; set; }
+		public class JoinContent {
+			public string DisplayName { get; set; }
+			public string Id { get; set; }
+		}
+	}
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/CapitalizedFieldsGraphType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
similarity index 58%
rename from tests/IntegrationTestServer/ChatSchema/CapitalizedFieldsGraphType.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
index 32b235e5..ddcd1238 100644
--- a/tests/IntegrationTestServer/ChatSchema/CapitalizedFieldsGraphType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
@@ -1,11 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection.Metadata.Ecma335;
-using System.Threading.Tasks;
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class CapitalizedFieldsGraphType: ObjectGraphType {
 		public CapitalizedFieldsGraphType() {
 			Name = "CapitalizedFields";
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
similarity index 94%
rename from tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
index 43895aec..384639ab 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
@@ -1,6 +1,6 @@
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class ChatMutation : ObjectGraphType<object> {
 		public ChatMutation(IChat chat) {
 			Field<MessageType>("addMessage",
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
similarity index 91%
rename from tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 8b423f95..32357338 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -1,9 +1,8 @@
 using System.Collections.Generic;
 using System.Linq;
-using GraphQL;
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class ChatQuery : ObjectGraphType {
 
 		public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
new file mode 100644
index 00000000..8ef13e43
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
@@ -0,0 +1,10 @@
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
+	public class ChatSchema : Types.Schema {
+		public ChatSchema(IDependencyResolver resolver)
+			: base(resolver) {
+			Query = resolver.Resolve<ChatQuery>();
+			Mutation = resolver.Resolve<ChatMutation>();
+			Subscription = resolver.Resolve<ChatSubscriptions>();
+		}
+	}
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
similarity index 97%
rename from tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
index 8f3c43ed..f7df7dd5 100644
--- a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
@@ -2,13 +2,12 @@
 using System.Linq;
 using System.Reactive.Linq;
 using System.Security.Claims;
-using GraphQL;
 using GraphQL.Resolvers;
 using GraphQL.Server.Transports.Subscriptions.Abstractions;
 using GraphQL.Subscription;
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class ChatSubscriptions : ObjectGraphType<object> {
 		private readonly IChat _chat;
 
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
similarity index 97%
rename from tests/IntegrationTestServer/ChatSchema/IChat.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index ef1bd08f..2e31e8b4 100644
--- a/tests/IntegrationTestServer/ChatSchema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -3,7 +3,7 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public interface IChat {
 		ConcurrentStack<Message> AllMessages { get; }
 
diff --git a/tests/IntegrationTestServer/ChatSchema/Message.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
similarity index 79%
rename from tests/IntegrationTestServer/ChatSchema/Message.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
index 93451aaa..1b68c7e4 100644
--- a/tests/IntegrationTestServer/ChatSchema/Message.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
@@ -1,6 +1,6 @@
 using System;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class Message {
 		public MessageFrom From { get; set; }
 
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
similarity index 67%
rename from tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
index 8dff8852..b6bc81a4 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
@@ -1,4 +1,4 @@
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class MessageFrom {
 		public string Id { get; set; }
 
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
similarity index 76%
rename from tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
index da243ee9..4d82c69e 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
@@ -1,6 +1,6 @@
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class MessageFromType : ObjectGraphType<MessageFrom> {
 		public MessageFromType() {
 			Field(o => o.Id);
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
similarity index 88%
rename from tests/IntegrationTestServer/ChatSchema/MessageType.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
index 6740189a..c5172cf3 100644
--- a/tests/IntegrationTestServer/ChatSchema/MessageType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
@@ -1,6 +1,6 @@
 using GraphQL.Types;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class MessageType : ObjectGraphType<Message> {
 		public MessageType() {
 			Field(o => o.Content);
diff --git a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
similarity index 76%
rename from tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
rename to tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
index a3d9025b..ab1b05f8 100644
--- a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
@@ -1,6 +1,6 @@
 using System;
 
-namespace IntegrationTestServer.ChatSchema {
+namespace GraphQL.Client.Tests.Common.Chat.Schema {
 	public class ReceivedMessage {
 		public string FromId { get; set; }
 
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
new file mode 100644
index 00000000..e912d907
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -0,0 +1,46 @@
+using GraphQL.Client.Tests.Common.Chat.Schema;
+using GraphQL.StarWars;
+using GraphQL.StarWars.Types;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GraphQL.Client.Tests.Common
+{
+    public static class Common
+    {
+	    public static StarWarsSchema GetStarWarsSchema() {
+			var services = new ServiceCollection();
+			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
+			services.AddStarWarsSchema();
+			return services.BuildServiceProvider().GetRequiredService<StarWarsSchema>();
+		}
+		public static ChatSchema GetChatSchema() {
+			var services = new ServiceCollection();
+			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
+			services.AddChatSchema();
+			return services.BuildServiceProvider().GetRequiredService<ChatSchema>();
+		}
+
+		public static void AddStarWarsSchema(this IServiceCollection services) {
+		    services.AddSingleton<StarWarsData>();
+		    services.AddSingleton<StarWarsQuery>();
+		    services.AddSingleton<StarWarsMutation>();
+		    services.AddSingleton<StarWarsSchema>();
+		    services.AddTransient<CharacterInterface>();
+		    services.AddTransient<DroidType>();
+		    services.AddTransient<EpisodeEnum>();
+		    services.AddTransient<HumanType>();
+		    services.AddTransient<HumanInputType>();
+		}
+		
+	    public static void AddChatSchema(this IServiceCollection services) {
+		    services.AddSingleton<IChat, Chat.Schema.Chat>();
+			services.AddSingleton<ChatSchema>();
+		    services.AddSingleton<ChatQuery>();
+		    services.AddSingleton<ChatMutation>();
+		    services.AddSingleton<ChatSubscriptions>();
+		    services.AddSingleton<MessageType>();
+		    services.AddSingleton<MessageInputType>();
+		    services.AddSingleton<MessageFromType>();
+		}
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
new file mode 100644
index 00000000..d9db0515
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GraphQL" Version="2.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
+    <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
+    <PackageReference Include="System.Reactive" Version="4.3.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
similarity index 87%
rename from tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs
rename to tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
index 99312c8c..44a9f6bd 100644
--- a/tests/GraphQL.Integration.Tests/TestData/StarWarsHumans.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
@@ -1,7 +1,7 @@
 using System.Collections;
 using System.Collections.Generic;
 
-namespace GraphQL.Integration.Tests.TestData {
+namespace GraphQL.Client.Tests.Common.StarWars {
 	public class StarWarsHumans: IEnumerable<object[]> {
 		public IEnumerator<object[]> GetEnumerator() {
 			yield return new object[] { 1, "Luke" };
diff --git a/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
index f698b247..93a8a4bc 100644
--- a/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
@@ -2,9 +2,12 @@
 using System.Threading.Tasks;
 using GraphQL.Client;
 using GraphQL.Client.Http;
+using GraphQL.Client.Tests.Common.Chat;
 
 namespace GraphQL.Integration.Tests.Extensions {
 	public static class GraphQLClientTestExtensions {
+		
+
 		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this GraphQLHttpClient client, string message) {
 			var graphQLRequest = new GraphQLRequest(
 				@"mutation($input: MessageInputType){
@@ -12,13 +15,11 @@ public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(th
 				    content
 				  }
 				}",
-				new {
-					input = new {
-						fromId = "2",
-						content = message,
-						sentAt = DateTime.Now
-					}
-				});
+				new AddMessageVariables { Input = {
+					FromId = "2",
+					Content = message,
+					SentAt = DateTime.Now
+				}});
 			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
 		}
 
diff --git a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
index 1ffaabd2..cdfb5622 100644
--- a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
@@ -1,37 +1,11 @@
-using System;
-using System.Text.Json;
-using FluentAssertions;
-using GraphQL.Client.Abstractions;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
-using IntegrationTestServer.ChatSchema;
-using Newtonsoft.Json;
-using Xunit;
 
 namespace GraphQL.Integration.Tests {
 	public class ExtensionsTest {
 		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) =>
 			WebHostHelpers.SetupTest<StartupChat>(requestsViaWebsocket);
 
-		//[Fact]
-		//public async void CanDeserializeExtensions() {
-
-		//	using var setup = SetupTest();
-		//	var response = await setup.Client.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
-		//			() => new {extensionsTest = ""})
-		//		.ConfigureAwait(false);
-
-		//	response.Errors.Should().NotBeNull();
-		//	response.Errors.Should().ContainSingle();
-		//	response.Errors[0].Extensions.Should().NotBeNull();
-		//	response.Errors[0].Extensions.Should().ContainKey("data");
-
-		//	foreach (var item in ChatQuery.TestExtensions) {
-				
-
-		//	}
-		//}
-
 		//[Fact]
 		//public async void DontNeedToUseCamelCaseNamingStrategy() {
 
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
index d897884f..82826164 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
@@ -2,8 +2,8 @@
 using System.Text.Json;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http;
+using GraphQL.Client.Tests.Common.StarWars;
 using GraphQL.Integration.Tests.Helpers;
-using GraphQL.Integration.Tests.TestData;
 using IntegrationTestServer;
 using Newtonsoft.Json.Linq;
 using Xunit;
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
deleted file mode 100644
index 3878bcf5..00000000
--- a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using GraphQL.Types;
-
-namespace IntegrationTestServer.ChatSchema {
-	public class ChatSchema : Schema {
-		public ChatSchema(IChat chat) {
-			Query = new ChatQuery(chat);
-			Mutation = new ChatMutation(chat);
-			Subscription = new ChatSubscriptions(chat);
-		}
-	}
-}
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 6ecc6a43..a1f28376 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -16,8 +16,12 @@
     <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
-    <PackageReference Include="System.Reactive" Version="4.1.2" />
-    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+    <PackageReference Include="System.Reactive" Version="4.3.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/IntegrationTestServer/StartupChat.cs b/tests/IntegrationTestServer/StartupChat.cs
index 37c205e7..2a782991 100644
--- a/tests/IntegrationTestServer/StartupChat.cs
+++ b/tests/IntegrationTestServer/StartupChat.cs
@@ -1,5 +1,6 @@
+using GraphQL.Client.Tests.Common;
+using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Server;
-using IntegrationTestServer.ChatSchema;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
@@ -10,18 +11,12 @@ public class StartupChat: Startup {
 		public StartupChat(IConfiguration configuration, IWebHostEnvironment environment): base(configuration, environment) { }
 
 		public override void ConfigureGraphQLSchemaServices(IServiceCollection services) {
-			services.AddSingleton<IChat, Chat>();
-			services.AddSingleton<ChatSchema.ChatSchema>();
-			services.AddSingleton<ChatQuery>();
-			services.AddSingleton<ChatMutation>();
-			services.AddSingleton<ChatSubscriptions>();
-			services.AddSingleton<MessageType>();
-			services.AddSingleton<MessageInputType>();
+			services.AddChatSchema();
 		}
 
 		public override void ConfigureGraphQLSchema(IApplicationBuilder app) {
-			app.UseGraphQLWebSockets<ChatSchema.ChatSchema>("/graphql");
-			app.UseGraphQL<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphQLWebSockets<ChatSchema>("/graphql");
+			app.UseGraphQL<ChatSchema>("/graphql");
 		}
 	}
 }
diff --git a/tests/IntegrationTestServer/StartupStarWars.cs b/tests/IntegrationTestServer/StartupStarWars.cs
index c62dc5f2..15609515 100644
--- a/tests/IntegrationTestServer/StartupStarWars.cs
+++ b/tests/IntegrationTestServer/StartupStarWars.cs
@@ -1,6 +1,6 @@
+using GraphQL.Client.Tests.Common;
 using GraphQL.Server;
 using GraphQL.StarWars;
-using GraphQL.StarWars.Types;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
@@ -11,16 +11,7 @@ public class StartupStarWars: Startup {
 		public StartupStarWars(IConfiguration configuration, IWebHostEnvironment environment): base(configuration, environment) { }
 
 		public override void ConfigureGraphQLSchemaServices(IServiceCollection services) {
-			services.AddSingleton<StarWarsData>();
-			services.AddSingleton<StarWarsQuery>();
-			services.AddSingleton<StarWarsMutation>();
-			services.AddSingleton<StarWarsSchema>();
-
-			services.AddTransient<CharacterInterface>();
-			services.AddTransient<DroidType>();
-			services.AddTransient<EpisodeEnum>();
-			services.AddTransient<HumanType>();
-			services.AddTransient<HumanInputType>();
+			services.AddStarWarsSchema();
 		}
 
 		public override void ConfigureGraphQLSchema(IApplicationBuilder app) {

From 0c66960725ba402d4688a77f37901b7f1a0ddb8f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 19:29:14 +0100
Subject: [PATCH 142/455] homogenize stream consuming serialization methods

---
 .../IGraphQLWebsocketJsonSerializer.cs              |  3 ++-
 .../GraphQL.Client.Serializer.Newtonsoft.csproj     |  3 ++-
 .../NewtonsoftJsonSerializer.cs                     | 13 +++++++------
 .../Websocket/GraphQLHttpWebSocket.cs               |  2 +-
 4 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index 7a215911..e2f445f5 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace GraphQL.Client.Abstractions.Websocket
 {
@@ -9,7 +10,7 @@ namespace GraphQL.Client.Abstractions.Websocket
     public interface IGraphQLWebsocketJsonSerializer: IGraphQLJsonSerializer {
 	    byte[] SerializeToBytes(GraphQLWebSocketRequest request);
 
-	    WebsocketResponseWrapper DeserializeToWebsocketResponseWrapper(Stream stream);
+	    Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
 	    GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
 
 	}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index 9ae19080..4c6e0e77 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -1,7 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
+	<Import Project="../src.props" />
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
 	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 62308cb8..269293c0 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -17,8 +17,9 @@ public NewtonsoftJsonSerializer()
 			Options = new NewtonsoftJsonSerializerOptions();
 		}
 		public NewtonsoftJsonSerializer(Action<NewtonsoftJsonSerializerOptions> configure) {
-			Options = new NewtonsoftJsonSerializerOptions();
-			configure(Options);
+			var options = new NewtonsoftJsonSerializerOptions();
+			configure(options);
+			Options = options;
 		}
 
 		public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
@@ -35,7 +36,7 @@ public byte[] SerializeToBytes(GraphQLWebSocketRequest request) {
 			return Encoding.UTF8.GetBytes(json);
 		}
 
-		public WebsocketResponseWrapper DeserializeToWebsocketResponseWrapper(Stream stream) {
+		public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
 			return DeserializeFromUtf8Stream<WebsocketResponseWrapper>(stream);
 		}
 
@@ -45,15 +46,15 @@ public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsock
 		}
 
 		public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
-			return Task.FromResult(DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream));
+			return DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
 		}
 
 
-		private T DeserializeFromUtf8Stream<T>(Stream stream) {
+		private Task<T> DeserializeFromUtf8Stream<T>(Stream stream) {
 			using StreamReader sr = new StreamReader(stream);
 			using JsonReader reader = new JsonTextReader(sr);
 			JsonSerializer serializer = JsonSerializer.Create(Options.JsonSerializerSettings);
-			return serializer.Deserialize<T>(reader);
+			return Task.FromResult(serializer.Deserialize<T>(reader));
 		}
 
 	}
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index d5bdcc04..579be9e7 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -223,7 +223,7 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 					ms.Seek(0, SeekOrigin.Begin);
 
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
-						var response = _options.JsonSerializer.DeserializeToWebsocketResponseWrapper(ms);
+						var response = await _options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
 						response.MessageBytes = ms.ToArray();
 						return response;
 					}

From 6aba359f3ca46a7ecbabfbd6f436e3eea07393d6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 22:07:37 +0100
Subject: [PATCH 143/455] implement system.text.json serializer

---
 GraphQL.Client.sln                            | 13 +++-
 ...QL.Client.Serializer.SystemTextJson.csproj | 21 ++++++
 .../GraphQLExtensionsConverter.cs             | 73 +++++++++++++++++++
 .../SystemTextJsonSerializer.cs               | 49 +++++++++++++
 .../SystemTextJsonSerializerOptions.cs        | 23 ++++++
 src/GraphQL.Primitives/GraphQLError.cs        |  6 +-
 .../GraphQLExtensionsType.cs                  |  9 +++
 src/GraphQL.Primitives/GraphQLResponse.cs     |  6 +-
 .../GraphQL.Client.Serializer.Tests.csproj    |  1 +
 .../SystemTextJsonSerializerTests.cs          | 18 +++++
 .../Extensions/GraphQLClientTestExtensions.cs | 14 ++--
 .../Helpers/WebHostHelpers.cs                 |  4 +-
 12 files changed, 218 insertions(+), 19 deletions(-)
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
 create mode 100644 src/GraphQL.Primitives/GraphQLExtensionsType.cs
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index df866b4e..510fa0b0 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -62,11 +62,13 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Abstractions
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.Newtonsoft", "src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj", "{11F28E78-ADE4-4153-B97C-56136EB7BD5B}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.LocalExecution", "src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj", "{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.LocalExecution", "src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj", "{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Serializer.Tests", "tests\GraphQL.Client.Serializer.Tests\GraphQL.Client.Serializer.Tests.csproj", "{CA842D18-FC4A-4281-B1FF-080FA91887B8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.Tests", "tests\GraphQL.Client.Serializer.Tests\GraphQL.Client.Serializer.Tests.csproj", "{CA842D18-FC4A-4281-B1FF-080FA91887B8}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Tests.Common", "tests\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj", "{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Tests.Common", "tests\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj", "{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Serializer.SystemTextJson", "src\GraphQL.Client.Serializer.SystemTextJson\GraphQL.Client.Serializer.SystemTextJson.csproj", "{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -126,6 +128,10 @@ Global
 		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -144,6 +150,7 @@ Global
 		{2BEC821C-E405-43CB-9BC9-A6BB0322F6C2} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{CA842D18-FC4A-4281-B1FF-080FA91887B8} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
new file mode 100644
index 00000000..024b0681
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<Import Project="../src.props" />
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
+	  <LangVersion>8.0</LangVersion>
+  </PropertyGroup>
+
+	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+		<PackageReference Include="System.Text.Json" Version="4.7.0" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <PackageReference Include="Dahomey.Json" Version="1.6.0" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
+	</ItemGroup>
+
+</Project>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
new file mode 100644
index 00000000..e10c8635
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace GraphQL.Client.Serializer.SystemTextJson {
+	/// <summary>
+	/// A custom JsonConverter for reading the extension fields of <see cref="GraphQLResponse{T}"/> and <see cref="GraphQLError"/>.
+	/// </summary>
+	/// <remarks>
+	/// Taken and modified from GraphQL.SystemTextJson.ObjectDictionaryConverter (GraphQL.NET)
+	/// </remarks>
+	public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType> {
+		public override GraphQLExtensionsType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
+			using var doc = JsonDocument.ParseValue(ref reader);
+
+			if (doc?.RootElement == null || doc?.RootElement.ValueKind != JsonValueKind.Object) {
+				throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+			}
+
+			return ReadDictionary<GraphQLExtensionsType>(doc.RootElement);
+		}
+
+		public override void Write(Utf8JsonWriter writer, GraphQLExtensionsType value, JsonSerializerOptions options)
+			=> throw new NotImplementedException(
+				"This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+
+		private TDictionary ReadDictionary<TDictionary>(JsonElement element) where TDictionary: Dictionary<string, object> {
+			var result = Activator.CreateInstance<TDictionary>();
+			foreach (var property in element.EnumerateObject()) {
+				result[property.Name] = ReadValue(property.Value);
+			}
+			return result;
+		}
+
+		private IEnumerable<object> ReadArray(JsonElement value) {
+			foreach (var item in value.EnumerateArray()) {
+				yield return ReadValue(item);
+			}
+		}
+
+		private object ReadValue(JsonElement value)
+			=> value.ValueKind switch
+			{
+				JsonValueKind.Array => ReadArray(value).ToList(),
+				JsonValueKind.Object => ReadDictionary<Dictionary<string, object>>(value),
+				JsonValueKind.Number => ReadNumber(value),
+				JsonValueKind.True => true,
+				JsonValueKind.False => false,
+				JsonValueKind.String => value.GetString(),
+				JsonValueKind.Null => null,
+				JsonValueKind.Undefined => null,
+				_ => throw new InvalidOperationException($"Unexpected value kind: {value.ValueKind}")
+			};
+
+		private object ReadNumber(JsonElement value) {
+			if (value.TryGetInt32(out var i))
+				return i;
+			else if (value.TryGetInt64(out var l))
+				return l;
+			else if (BigInteger.TryParse(value.GetRawText(), out var bi))
+				return bi;
+			else if (value.TryGetDouble(out var d))
+				return d;
+			else if (value.TryGetDecimal(out var dd))
+				return dd;
+
+			throw new NotImplementedException($"Unexpected Number value. Raw text was: {value.GetRawText()}");
+		}
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
new file mode 100644
index 00000000..a8cf7cde
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -0,0 +1,49 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Client.Abstractions.Websocket;
+
+namespace GraphQL.Client.Serializer.SystemTextJson
+{
+    public class SystemTextJsonSerializer: IGraphQLWebsocketJsonSerializer
+    {
+	    public SystemTextJsonSerializerOptions Options { get; }
+
+	    public SystemTextJsonSerializer()
+	    {
+			Options = new SystemTextJsonSerializerOptions();
+	    }
+	    public SystemTextJsonSerializer(Action<SystemTextJsonSerializerOptions> configure) {
+		    var options = new SystemTextJsonSerializerOptions();
+		    configure(options);
+		    Options = options;
+	    }
+
+		public SystemTextJsonSerializer(SystemTextJsonSerializerOptions options) {
+		    Options = options;
+	    }
+
+	    public string SerializeToString(GraphQLRequest request) {
+		    return JsonSerializer.Serialize(request, Options.JsonSerializerOptions);
+	    }
+
+	    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
+		    return JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options.JsonSerializerOptions, cancellationToken).AsTask();
+	    }
+
+	    public byte[] SerializeToBytes(GraphQLWebSocketRequest request) {
+		    return JsonSerializer.SerializeToUtf8Bytes(request, Options.JsonSerializerOptions);
+	    }
+
+	    public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
+		    return JsonSerializer.DeserializeAsync<WebsocketResponseWrapper>(stream, Options.JsonSerializerOptions).AsTask();
+		}
+
+	    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
+		    return JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
+			    Options.JsonSerializerOptions);
+	    }
+    }
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
new file mode 100644
index 00000000..64b65b6c
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
@@ -0,0 +1,23 @@
+using System.Text.Json;
+using Dahomey.Json;
+
+namespace GraphQL.Client.Serializer.SystemTextJson {
+	public class SystemTextJsonSerializerOptions {
+		public JsonSerializerOptions JsonSerializerOptions { get; set; } = DefaultJsonSerializerOptions;
+
+		public static JsonSerializerOptions DefaultJsonSerializerOptions {
+			get {
+				var options = new JsonSerializerOptions {
+					PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+				};
+
+				options.Converters.Add(new GraphQLExtensionsConverter());
+
+				// Use extensions brought by Dahomey.Json to allow to deserialize anonymous types
+				options.SetupExtensions(); 
+
+				return options;
+			}
+		}
+	}
+}
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 7c0b0c62..3392e97c 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -32,7 +32,7 @@ public class GraphQLError : IEquatable<GraphQLError?> {
 		/// The extensions of the error
 		/// </summary> 
 		[DataMember(Name = "extensions")]
-		public ExtensionsType? Extensions { get; set; }
+		public GraphQLExtensionsType? Extensions { get; set; }
 
 		/// <summary>
 		/// Returns a value that indicates whether this instance is equal to a specified object
@@ -101,10 +101,6 @@ public override int GetHashCode() {
 		public static bool operator !=(GraphQLError? left, GraphQLError? right) =>
 			!EqualityComparer<GraphQLError?>.Default.Equals(left, right);
 
-		/// <summary>
-		/// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
-		/// </summary>
-		public class ExtensionsType : Dictionary<string, object?> { }
 	}
 
 }
diff --git a/src/GraphQL.Primitives/GraphQLExtensionsType.cs b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
new file mode 100644
index 00000000..2de718d0
--- /dev/null
+++ b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace GraphQL {
+
+	/// <summary>
+	/// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
+	/// </summary>
+	public class GraphQLExtensionsType: Dictionary<string, object> { }
+}
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index aa58ff77..088be7bd 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -14,7 +14,7 @@ public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
 		public GraphQLError[]? Errors { get; set; }
 
 		[DataMember(Name = "extensions")]
-		public ExtensionsType? Extensions { get; set; }
+		public GraphQLExtensionsType? Extensions { get; set; }
 
 		public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
 
@@ -54,10 +54,6 @@ public override int GetHashCode() {
 
 		public static bool operator !=(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => !(response1 == response2);
 
-		/// <summary>
-		/// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
-		/// </summary>
-		public class ExtensionsType : Dictionary<string, object?> { }
 	}
 
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index f84cef2c..583a8e82 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -18,6 +18,7 @@
     <ProjectReference Include="..\..\src\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Client.Serializer.SystemTextJson\GraphQL.Client.Serializer.SystemTextJson.csproj" />
     <ProjectReference Include="..\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
new file mode 100644
index 00000000..5d54898a
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using FluentAssertions;
+using GraphQL.Client.Abstractions.Websocket;
+using GraphQL.Client.Serializer.SystemTextJson;
+using Xunit;
+
+namespace GraphQL.Client.Serializer.Tests {
+	public class SystemTextJsonSerializerTests: BaseSerializerTest {
+		public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer())
+		{
+		}
+
+		protected override void AssertGraphQlErrorDataExtensions(object dataField, IDictionary<string, object> expectedContent) {
+			dataField.Should().BeEquivalentTo(expectedContent);
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
index 93a8a4bc..59a6c0e3 100644
--- a/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
@@ -9,17 +9,21 @@ public static class GraphQLClientTestExtensions {
 		
 
 		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this GraphQLHttpClient client, string message) {
+			var variables = new AddMessageVariables {
+				Input = new AddMessageVariables.AddMessageInput{
+					FromId = "2",
+					Content = message,
+					SentAt = DateTime.Now
+				}
+			};
+
 			var graphQLRequest = new GraphQLRequest(
 				@"mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
 				}",
-				new AddMessageVariables { Input = {
-					FromId = "2",
-					Content = message,
-					SentAt = DateTime.Now
-				}});
+				variables);
 			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
 		}
 
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 8c32f558..45c54392 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,6 +1,7 @@
 using System;
 using GraphQL.Client;
 using GraphQL.Client.Http;
+using GraphQL.Client.Serializer.Newtonsoft;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -34,7 +35,8 @@ public static IWebHost CreateServer<TStartup>(int port) where TStartup : class
 		public static GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions {
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
-				UseWebSocketForQueriesAndMutations = requestsViaWebsocket
+				UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
+				JsonSerializer = new NewtonsoftJsonSerializer()
 			});
 		
 		public static TestServerSetup SetupTest<TStartup>(bool requestsViaWebsocket = false) where TStartup : class

From 48249b2cdf383e637be5fc8349d2c7928ecab509 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 22:46:48 +0100
Subject: [PATCH 144/455] remove netstandard2.1 target

---
 .../GraphQL.Client.Abstractions.Websocket.csproj                | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index 30202e85..8623791f 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -2,7 +2,7 @@
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
-	<TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+	<TargetFramework>netstandard2.0</TargetFramework>
 	  <LangVersion>8.0</LangVersion>
 	</PropertyGroup>
 

From 28053f31e3334558d06f2d86d99a586f83d981f2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 23:20:31 +0100
Subject: [PATCH 145/455] override request classes for system.text.json

---
 .../GraphQLWebSocketRequest.cs                | 13 +++++++---
 .../STJGraphQLRequest.cs                      | 21 ++++++++++++++++
 .../STJGraphQLWebSocketRequest.cs             | 24 +++++++++++++++++++
 .../SystemTextJsonSerializer.cs               |  5 ++--
 src/GraphQL.Primitives/GraphQLRequest.cs      | 15 +++++++-----
 5 files changed, 67 insertions(+), 11 deletions(-)
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLWebSocketRequest.cs

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index f43995e2..0f486482 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.Serialization;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client.Abstractions.Websocket {
@@ -8,21 +9,27 @@ namespace GraphQL.Client.Abstractions.Websocket {
 	/// A Subscription Request
 	/// </summary>
 	public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
+		public const string IdKey = "id";
+		public const string TypeKey = "type";
+		public const string PayloadKey = "payload";
 
 		/// <summary>
 		/// The Identifier of the Response
 		/// </summary>
-		public string Id { get; set; }
+		[DataMember(Name = IdKey)]
+		public virtual string Id { get; set; }
 
 		/// <summary>
 		/// The Type of the Request
 		/// </summary>
-		public string Type { get; set; }
+		[DataMember(Name = TypeKey)]
+		public virtual string Type { get; set; }
 
 		/// <summary>
 		/// The payload of the websocket request
 		/// </summary>
-		public GraphQLRequest Payload { get; set; }
+		[DataMember(Name = PayloadKey)]
+		public virtual GraphQLRequest Payload { get; set; }
 
 		private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
new file mode 100644
index 00000000..ba44b66d
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
@@ -0,0 +1,21 @@
+using System.Text.Json.Serialization;
+
+namespace GraphQL.Client.Serializer.SystemTextJson {
+	public class STJGraphQLRequest: GraphQLRequest {
+		[JsonPropertyName(QueryKey)]
+		public override string Query { get; set; }
+		[JsonPropertyName(OperationNameKey)]
+		public override string? OperationName { get; set; }
+		[JsonPropertyName(VariablesKey)]
+		public override object? Variables { get; set; }
+
+		public STJGraphQLRequest() { }
+
+		public STJGraphQLRequest(GraphQLRequest other) {
+			Query = other.Query;
+			OperationName = other.OperationName;
+			Variables = other.Variables;
+		}
+
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLWebSocketRequest.cs
new file mode 100644
index 00000000..bf6adbeb
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLWebSocketRequest.cs
@@ -0,0 +1,24 @@
+using System.Text.Json.Serialization;
+using GraphQL.Client.Abstractions.Websocket;
+
+namespace GraphQL.Client.Serializer.SystemTextJson {
+	public class STJGraphQLWebSocketRequest: GraphQLWebSocketRequest {
+
+		[JsonPropertyName(IdKey)]
+		public override string Id { get; set; }
+		[JsonPropertyName(TypeKey)]
+		public override string Type { get; set; }
+		[JsonPropertyName(PayloadKey)]
+		public override GraphQLRequest Payload { get; set; }
+
+		public STJGraphQLWebSocketRequest()
+		{
+		}
+
+		public STJGraphQLWebSocketRequest(GraphQLWebSocketRequest other) {
+			Id = other.Id;
+			Type = other.Type;
+			Payload = new STJGraphQLRequest(other.Payload);
+		}
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index a8cf7cde..599a402b 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -26,7 +26,7 @@ public SystemTextJsonSerializer(SystemTextJsonSerializerOptions options) {
 	    }
 
 	    public string SerializeToString(GraphQLRequest request) {
-		    return JsonSerializer.Serialize(request, Options.JsonSerializerOptions);
+		    return JsonSerializer.Serialize(new STJGraphQLRequest(request), Options.JsonSerializerOptions);
 	    }
 
 	    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
@@ -34,7 +34,7 @@ public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse
 	    }
 
 	    public byte[] SerializeToBytes(GraphQLWebSocketRequest request) {
-		    return JsonSerializer.SerializeToUtf8Bytes(request, Options.JsonSerializerOptions);
+		    return JsonSerializer.SerializeToUtf8Bytes(new STJGraphQLWebSocketRequest(request), Options.JsonSerializerOptions);
 	    }
 
 	    public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
@@ -45,5 +45,6 @@ public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsock
 		    return JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
 			    Options.JsonSerializerOptions);
 	    }
+
     }
 }
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index d39d2cea..f7e48e24 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -8,24 +8,27 @@ namespace GraphQL {
 	/// A GraphQL request
 	/// </summary>
 	public class GraphQLRequest : IEquatable<GraphQLRequest?> {
+		public const string OperationNameKey = "operationName";
+		public const string QueryKey = "query";
+		public const string VariablesKey = "variables";
 
 		/// <summary>
 		/// The Query
 		/// </summary>
-		[DataMember(Name = "query")]
-		public string Query { get; set; }
+		[DataMember(Name = QueryKey)]
+		public virtual string Query { get; set; }
 
 		/// <summary>
 		/// The name of the Operation
 		/// </summary>
-		[DataMember(Name = "operationName")]
-		public string? OperationName { get; set; }
+		[DataMember(Name = OperationNameKey)]
+		public virtual string? OperationName { get; set; }
 
 		/// <summary>
 		/// Represents the request variables
 		/// </summary>
-		[DataMember(Name = "variables")]
-		public object? Variables { get; set; }
+		[DataMember(Name = VariablesKey)]
+		public virtual object? Variables { get; set; }
 
 		public GraphQLRequest() { }
 

From 98a53bfebdcbd56e9b98f6f8da4ecfdd4409dc5b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 11 Feb 2020 23:42:49 +0100
Subject: [PATCH 146/455] add SerializeToStringTest theory (data incomplete)

---
 .../STJGraphQLRequest.cs                      |  1 +
 .../BaseSerializerTest.cs                     | 10 +++
 .../TestData/SerializeToStringTestData.cs     | 18 ++++++
 .../Chat/GraphQLClientChatExtensions.cs       | 29 +++++----
 .../Extensions/GraphQLClientTestExtensions.cs | 61 -------------------
 .../WebsocketTest.cs                          |  2 +-
 6 files changed, 46 insertions(+), 75 deletions(-)
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
 delete mode 100644 tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs

diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
index ba44b66d..9ffa3afa 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
@@ -1,4 +1,5 @@
 using System.Text.Json.Serialization;
+using Dahomey.Json.Attributes;
 
 namespace GraphQL.Client.Serializer.SystemTextJson {
 	public class STJGraphQLRequest: GraphQLRequest {
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 4168ef79..2a0efef2 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -3,6 +3,7 @@
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.LocalExecution;
+using GraphQL.Client.Serializer.Tests.TestData;
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Client.Tests.Common.Chat.Schema;
@@ -13,14 +14,23 @@ namespace GraphQL.Client.Serializer.Tests
 {
     public abstract class BaseSerializerTest
     {
+	    public IGraphQLWebsocketJsonSerializer Serializer { get; }
 	    public IGraphQLClient ChatClient { get; }
 	    public IGraphQLClient StarWarsClient { get; }
 
 		protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer serializer) {
+			Serializer = serializer;
 			ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
 			StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
 		}
 
+		[Theory]
+		[ClassData(typeof(SerializeToStringTestData))]
+		public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
+			var json = Serializer.SerializeToString(request);
+			json.Should().BeEquivalentTo(expectedJson);
+		}
+
 		[Fact]
 		public async void CanDeserializeExtensions() {
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
new file mode 100644
index 00000000..5f4f18a1
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -0,0 +1,18 @@
+using System.Collections;
+using System.Collections.Generic;
+using GraphQL.Client.Tests.Common.Chat;
+
+namespace GraphQL.Client.Serializer.Tests.TestData {
+	public class SerializeToStringTestData : IEnumerable<object[]> {
+		public IEnumerator<object[]> GetEnumerator() {
+			yield return new object[] {
+				"{\"query\":\"simple query string\",\"operationName\":null,\"variables\":null}",
+				new GraphQLRequest("simple query string")
+			};
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return GetEnumerator();
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index 44319a17..d76aedcf 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -4,20 +4,23 @@
 
 namespace GraphQL.Client.Tests.Common.Chat {
 	public static class GraphQLClientChatExtensions {
+		public const string AddMessageQuery =
+@"mutation($input: MessageInputType){
+  addMessage(message: $input){
+    content
+  }
+}";
+
 		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message) {
-			var graphQLRequest = new GraphQLRequest(
-				@"mutation($input: MessageInputType){
-				  addMessage(message: $input){
-				    content
-				  }
-				}",
-				new {
-					input = new {
-						fromId = "2",
-						content = message,
-						sentAt = DateTime.Now
-					}
-				});
+			var variables = new AddMessageVariables {
+				Input = new AddMessageVariables.AddMessageInput {
+					FromId = "2",
+					Content = message,
+					SentAt = DateTime.Now
+				}
+			};
+
+			var graphQLRequest = new GraphQLRequest(AddMessageQuery, variables);
 			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
 		}
 
diff --git a/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs b/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
deleted file mode 100644
index 59a6c0e3..00000000
--- a/tests/GraphQL.Integration.Tests/Extensions/GraphQLClientTestExtensions.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using GraphQL.Client;
-using GraphQL.Client.Http;
-using GraphQL.Client.Tests.Common.Chat;
-
-namespace GraphQL.Integration.Tests.Extensions {
-	public static class GraphQLClientTestExtensions {
-		
-
-		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this GraphQLHttpClient client, string message) {
-			var variables = new AddMessageVariables {
-				Input = new AddMessageVariables.AddMessageInput{
-					FromId = "2",
-					Content = message,
-					SentAt = DateTime.Now
-				}
-			};
-
-			var graphQLRequest = new GraphQLRequest(
-				@"mutation($input: MessageInputType){
-				  addMessage(message: $input){
-				    content
-				  }
-				}",
-				variables);
-			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
-		}
-
-		public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this GraphQLHttpClient client) {
-			var graphQLRequest = new GraphQLRequest(@"
-				mutation($userId: String){
-				  join(userId: $userId){
-				    displayName
-				    id
-				  }
-				}",
-				new {
-					userId = "1"
-				});
-			return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
-		}
-
-	}
-
-
-	public class AddMessageMutationResult {
-		public AddMessageContent AddMessage { get; set; }
-		public class AddMessageContent {
-			public string Content { get; set; }
-		}
-	}
-
-	public class JoinDeveloperMutationResult {
-		public JoinContent Join { get; set; }
-		public class JoinContent {
-			public string DisplayName { get; set; }
-			public string Id { get; set; }
-		}
-	}
-}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
index 4bd1fade..655aac5f 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
@@ -4,7 +4,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
-using GraphQL.Integration.Tests.Extensions;
+using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
 using Microsoft.AspNetCore.Hosting;

From 82a0a315e08b0bba8975bc3137f752e19221e88d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 12 Feb 2020 11:06:09 +0100
Subject: [PATCH 147/455] create converter for JSON.Net to achieve the same
 result as with system.text.json

---
 .../GraphQLExtensionsConverter.cs             | 75 +++++++++++++++++++
 .../NewtonsoftJsonSerializer.cs               |  5 +-
 .../SystemTextJsonSerializer.cs               |  9 ++-
 .../SystemTextJsonSerializerOptions.cs        | 19 +----
 .../BaseSerializerTest.cs                     |  8 +-
 .../NewtonsoftSerializerTest.cs               | 23 ------
 .../SystemTextJsonSerializerTests.cs          |  9 ---
 .../Chat/GraphQLClientChatExtensions.cs       |  2 +-
 8 files changed, 90 insertions(+), 60 deletions(-)
 create mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
new file mode 100644
index 00000000..0ff13a0f
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace GraphQL.Client.Serializer.Newtonsoft {
+	public class GraphQLExtensionsConverter: JsonConverter<GraphQLExtensionsType> {
+		public override void WriteJson(JsonWriter writer, GraphQLExtensionsType value, JsonSerializer serializer) {
+			throw new NotImplementedException(
+				"This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+		}
+
+		public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectType, GraphQLExtensionsType existingValue,
+			bool hasExistingValue, JsonSerializer serializer) {
+			var rootToken = JToken.ReadFrom(reader);
+			if (rootToken is JObject) {
+				return ReadDictionary<GraphQLExtensionsType>(rootToken);
+			}
+			else
+				throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+		}
+
+		private object ReadToken(JToken? token) {
+			switch (token.Type) {
+				case JTokenType.Undefined:
+				case JTokenType.None:
+					return null;
+				case JTokenType.Object:
+					return ReadDictionary<Dictionary<string, object>>(token);
+				case JTokenType.Array:
+					return ReadArray(token);
+				case JTokenType.Integer:
+					return token.Value<int>();
+				case JTokenType.Float:
+					return token.Value<double>();
+				case JTokenType.Raw:
+				case JTokenType.String:
+				case JTokenType.Uri:
+					return token.Value<string>();
+				case JTokenType.Boolean:
+					return token.Value<bool>();
+				case JTokenType.Date:
+					return token.Value<DateTime>();
+				case JTokenType.Bytes:
+					return token.Value<byte[]>();
+				case JTokenType.Guid:
+					return token.Value<Guid>();
+				case JTokenType.TimeSpan:
+					return token.Value<TimeSpan>();
+				case JTokenType.Constructor:
+				case JTokenType.Property:
+				case JTokenType.Comment:
+				default:
+					throw new ArgumentOutOfRangeException();
+			}
+		}
+
+		private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionary : Dictionary<string, object> {
+			var result = Activator.CreateInstance<TDictionary>();
+			foreach (var property in ((JObject)element).Properties()) {
+				result[property.Name] = ReadToken(property.Value);
+			}
+			return result;
+		}
+
+		private IEnumerable<object> ReadArray(JToken element) {
+			foreach (var item in element.Values()) {
+				yield return ReadToken(item);
+			}
+		}
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 269293c0..fad57216 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -15,16 +15,19 @@ public class NewtonsoftJsonSerializer: IGraphQLWebsocketJsonSerializer
 	    public NewtonsoftJsonSerializer()
 	    {
 			Options = new NewtonsoftJsonSerializerOptions();
+			Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
 		}
 		public NewtonsoftJsonSerializer(Action<NewtonsoftJsonSerializerOptions> configure) {
 			var options = new NewtonsoftJsonSerializerOptions();
 			configure(options);
 			Options = options;
+			Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
 		}
 
 		public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
 		    Options = options;
-	    }
+		    Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
+		}
 
 
 		public string SerializeToString(GraphQLRequest request) {
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 599a402b..d4ab07d3 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -14,16 +14,19 @@ public class SystemTextJsonSerializer: IGraphQLWebsocketJsonSerializer
 	    public SystemTextJsonSerializer()
 	    {
 			Options = new SystemTextJsonSerializerOptions();
-	    }
+			Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
+		}
 	    public SystemTextJsonSerializer(Action<SystemTextJsonSerializerOptions> configure) {
 		    var options = new SystemTextJsonSerializerOptions();
 		    configure(options);
 		    Options = options;
-	    }
+		    Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
+		}
 
 		public SystemTextJsonSerializer(SystemTextJsonSerializerOptions options) {
 		    Options = options;
-	    }
+		    Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
+		}
 
 	    public string SerializeToString(GraphQLRequest request) {
 		    return JsonSerializer.Serialize(new STJGraphQLRequest(request), Options.JsonSerializerOptions);
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
index 64b65b6c..af9bbc35 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
@@ -3,21 +3,8 @@
 
 namespace GraphQL.Client.Serializer.SystemTextJson {
 	public class SystemTextJsonSerializerOptions {
-		public JsonSerializerOptions JsonSerializerOptions { get; set; } = DefaultJsonSerializerOptions;
-
-		public static JsonSerializerOptions DefaultJsonSerializerOptions {
-			get {
-				var options = new JsonSerializerOptions {
-					PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-				};
-
-				options.Converters.Add(new GraphQLExtensionsConverter());
-
-				// Use extensions brought by Dahomey.Json to allow to deserialize anonymous types
-				options.SetupExtensions(); 
-
-				return options;
-			}
-		}
+		public JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions {
+				PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+			}.SetupExtensions();
 	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 2a0efef2..c5275342 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -43,15 +43,9 @@ public async void CanDeserializeExtensions() {
 			response.Errors[0].Extensions.Should().NotBeNull();
 			response.Errors[0].Extensions.Should().ContainKey("data");
 
-			AssertGraphQlErrorDataExtensions(response.Errors[0].Extensions["data"], ChatQuery.TestExtensions);
+			response.Errors[0].Extensions["data"].Should().BeEquivalentTo(ChatQuery.TestExtensions);
 		}
 
-		/// <summary>
-		/// serializer-specific assertion of the <see cref="GraphQLError.Extensions"/> field
-		/// </summary>
-		/// <param name="dataField">the field with key "data" from <see cref="GraphQLError.Extensions"/></param>
-		/// <param name="expectedContent"><see cref="ChatQuery.TestExtensions"/></param>
-		protected abstract void AssertGraphQlErrorDataExtensions(object dataField, IDictionary<string, object> expectedContent);
 
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 9cbb7b4e..8a4196a6 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -1,30 +1,7 @@
-using System.Collections.Generic;
-using FluentAssertions;
 using GraphQL.Client.Serializer.Newtonsoft;
-using Newtonsoft.Json.Linq;
-using Xunit;
 
 namespace GraphQL.Client.Serializer.Tests {
 	public class NewtonsoftSerializerTest : BaseSerializerTest {
 		public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
-
-		protected override void AssertGraphQlErrorDataExtensions(object dataField, IDictionary<string, object> expectedContent) {
-			dataField.Should().BeOfType<JObject>().Which.Should().ContainKeys(expectedContent.Keys);
-			var data = (JObject) dataField;
-
-			foreach (var item in expectedContent) {
-				switch (item.Value) {
-					case int i:
-						data[item.Key].Value<int>().Should().Be(i);
-						break;
-					case string s:
-						data[item.Key].Value<string>().Should().BeEquivalentTo(s);
-						break;
-					default:
-						Assert.True(false, $"unexpected value type \"{item.Value.GetType()}\" in expected content! Please review this unit test and add the missing type case!");
-						break;
-				}
-			}
-		}
 	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index 5d54898a..177bb64b 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -1,18 +1,9 @@
-using System.Collections.Generic;
-using System.Text.Json;
-using FluentAssertions;
-using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Serializer.SystemTextJson;
-using Xunit;
 
 namespace GraphQL.Client.Serializer.Tests {
 	public class SystemTextJsonSerializerTests: BaseSerializerTest {
 		public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer())
 		{
 		}
-
-		protected override void AssertGraphQlErrorDataExtensions(object dataField, IDictionary<string, object> expectedContent) {
-			dataField.Should().BeEquivalentTo(expectedContent);
-		}
 	}
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index d76aedcf..f3d95cf7 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -8,7 +8,7 @@ public static class GraphQLClientChatExtensions {
 @"mutation($input: MessageInputType){
   addMessage(message: $input){
     content
-  }
+  }  
 }";
 
 		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message) {

From 949afcaf485884e00c5318d84e671a7f136be347 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 12 Feb 2020 11:32:39 +0100
Subject: [PATCH 148/455] consolidate constructors, add mandatory serializer
 settings in constructors

---
 .../GraphQLJsonSerializerExtensions.cs        |  7 ++++
 .../NewtonsoftJsonSerializer.cs               | 22 ++++++-------
 .../SystemTextJsonSerializer.cs               | 24 +++++++-------
 src/GraphQL.Client/GraphQLHttpClient.cs       | 32 +++++++++----------
 4 files changed, 45 insertions(+), 40 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index b652c782..e544e75f 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.Linq;
 
 namespace GraphQL.Client.Abstractions {
@@ -20,5 +21,11 @@ public static TSerializerInterface EnsureAssigned<TSerializerInterface>(this TSe
 
 			return jsonSerializer;
 		}
+
+		public static TOptions New<TOptions>(this Action<TOptions> configure) {
+			var options = Activator.CreateInstance<TOptions>();
+			configure(options);
+			return options;
+		}
 	}
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index fad57216..7115c763 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -1,8 +1,10 @@
 using System;
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using Newtonsoft.Json;
 
@@ -12,23 +14,19 @@ public class NewtonsoftJsonSerializer: IGraphQLWebsocketJsonSerializer
     {
 	    public NewtonsoftJsonSerializerOptions Options { get; }
 
-	    public NewtonsoftJsonSerializer()
-	    {
-			Options = new NewtonsoftJsonSerializerOptions();
-			Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
-		}
-		public NewtonsoftJsonSerializer(Action<NewtonsoftJsonSerializerOptions> configure) {
-			var options = new NewtonsoftJsonSerializerOptions();
-			configure(options);
-			Options = options;
-			Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
-		}
+	    public NewtonsoftJsonSerializer() : this(new NewtonsoftJsonSerializerOptions()) { }
+
+		public NewtonsoftJsonSerializer(Action<NewtonsoftJsonSerializerOptions> configure) : this(configure.New()) { }
 
 		public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
 		    Options = options;
-		    Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
+		    ConfigureMandatorySerializerOptions();
 		}
 
+		private void ConfigureMandatorySerializerOptions() {
+			// deserialize extensions to Dictionary<string, object>
+			Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
+		}
 
 		public string SerializeToString(GraphQLRequest request) {
 		    return JsonConvert.SerializeObject(request, Options.JsonSerializerSettings);
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index d4ab07d3..f2b793d1 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -3,6 +3,7 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Serializer.SystemTextJson
@@ -11,21 +12,20 @@ public class SystemTextJsonSerializer: IGraphQLWebsocketJsonSerializer
     {
 	    public SystemTextJsonSerializerOptions Options { get; }
 
-	    public SystemTextJsonSerializer()
-	    {
-			Options = new SystemTextJsonSerializerOptions();
-			Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
-		}
-	    public SystemTextJsonSerializer(Action<SystemTextJsonSerializerOptions> configure) {
-		    var options = new SystemTextJsonSerializerOptions();
-		    configure(options);
-		    Options = options;
-		    Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
-		}
+	    public SystemTextJsonSerializer() : this(new SystemTextJsonSerializerOptions()) { }
+
+	    public SystemTextJsonSerializer(Action<SystemTextJsonSerializerOptions> configure) : this(configure.New()) { }
 
 		public SystemTextJsonSerializer(SystemTextJsonSerializerOptions options) {
 		    Options = options;
-		    Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
+		    ConfigureMandatorySerializerOptions();
+		}
+
+		private void ConfigureMandatorySerializerOptions() {
+			// deserialize extensions to Dictionary<string, object>
+			Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
+			// allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
+			Options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
 		}
 
 	    public string SerializeToString(GraphQLRequest request) {
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 85339e6a..465a0286 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -28,42 +28,40 @@ public class GraphQLHttpClient : IGraphQLClient {
 		/// </summary>
 		public GraphQLHttpClientOptions Options { get; }
 
-		/// <inheritdoc />
+		/// <summary>
+		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+		/// </summary>
 		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
 
+
+		#region Constructors
+
 		public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint)) { }
 
 		public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
 
-		public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) {
-			Options = new GraphQLHttpClientOptions();
-			configure(Options);
-			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
-		}
+		public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) : this(configure.New()) { }
 
-		public GraphQLHttpClient(GraphQLHttpClientOptions options) {
-			Options = options;
-			this.HttpClient = new HttpClient(Options.HttpMessageHandler);
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
-			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
-		}
+		public GraphQLHttpClient(GraphQLHttpClientOptions options) : this(options, new HttpClient(options.HttpMessageHandler)) { }
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
 			Options = options;
-			this.HttpClient = httpClient;
+			this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
 		}
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer) {
-			Options = options;
+			Options = options ?? throw new ArgumentNullException(nameof(options));
 			Options.JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
 			this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
 			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
 		}
 
+		#endregion
+
+		#region IGraphQLClient
+
 		/// <inheritdoc />
 		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
@@ -107,6 +105,8 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			return observable;
 		}
 
+		#endregion
+
 		/// <summary>
 		/// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
 		/// </summary>

From 25459289c5e70fffe33a05c510b6f67ee686a9be Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 12 Feb 2020 12:25:50 +0100
Subject: [PATCH 149/455] test basic functionality of serializer without
 camelCase

---
 .../BaseSerializeNoCamelCaseTest.cs           | 56 +++++++++++++++++++
 .../BaseSerializerTest.cs                     |  5 +-
 .../NewtonsoftSerializerTest.cs               |  6 ++
 .../SystemTextJsonSerializerTests.cs          | 11 +++-
 .../TestData/SerializeToStringTestData.cs     |  6 +-
 .../GraphQL.Client.Tests.Common.csproj        |  1 +
 .../Helpers/CallbackTester.cs                 |  2 +-
 .../Helpers/MiscellaneousExtensions.cs        | 11 ++++
 .../Helpers/NetworkHelpers.cs                 |  2 +-
 .../Helpers/ObservableTester.cs               |  2 +-
 .../Helpers/WebHostHelpers.cs                 |  1 +
 .../QueryAndMutationTests.cs                  |  1 +
 .../WebsocketTest.cs                          |  1 +
 13 files changed, 96 insertions(+), 9 deletions(-)
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
 rename tests/{GraphQL.Integration.Tests => GraphQL.Client.Tests.Common}/Helpers/CallbackTester.cs (97%)
 create mode 100644 tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
 rename tests/{GraphQL.Integration.Tests => GraphQL.Client.Tests.Common}/Helpers/NetworkHelpers.cs (85%)
 rename tests/{GraphQL.Integration.Tests => GraphQL.Client.Tests.Common}/Helpers/ObservableTester.cs (98%)

diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
new file mode 100644
index 00000000..dbf11f52
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using FluentAssertions;
+using GraphQL.Client.Abstractions;
+using GraphQL.Client.Abstractions.Websocket;
+using GraphQL.Client.LocalExecution;
+using GraphQL.Client.Serializer.Tests.TestData;
+using GraphQL.Client.Tests.Common;
+using GraphQL.Client.Tests.Common.Helpers;
+using Newtonsoft.Json;
+using Xunit;
+
+namespace GraphQL.Client.Serializer.Tests {
+	public abstract class BaseSerializeNoCamelCaseTest {
+
+		public IGraphQLWebsocketJsonSerializer Serializer { get; }
+		public IGraphQLClient ChatClient { get; }
+		public IGraphQLClient StarWarsClient { get; }
+
+		protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer serializer) {
+			Serializer = serializer;
+			ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
+			StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
+		}
+
+		[Theory]
+		[ClassData(typeof(SerializeToStringTestData))]
+		public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
+			var json = Serializer.SerializeToString(request).RemoveWhitespace();
+			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
+		}
+
+		[Fact]
+		public async void WorksWithoutCamelCaseNamingStrategy() {
+
+			const string message = "some random testing message";
+			var graphQLRequest = new GraphQLRequest(
+				@"mutation($input: MessageInputType){
+				  addMessage(message: $input){
+				    content
+				  }
+				}",
+				new {
+					input = new {
+						fromId = "2",
+						content = message,
+						sentAt = DateTime.Now
+					}
+				});
+			var response = await ChatClient.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
+
+			Assert.Equal(message, response.Data.addMessage.content);
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index c5275342..92226813 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -7,6 +7,7 @@
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Client.Tests.Common.Chat.Schema;
+using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Client.Tests.Common.StarWars;
 using Xunit;
 
@@ -27,8 +28,8 @@ protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer serializer) {
 		[Theory]
 		[ClassData(typeof(SerializeToStringTestData))]
 		public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
-			var json = Serializer.SerializeToString(request);
-			json.Should().BeEquivalentTo(expectedJson);
+			var json = Serializer.SerializeToString(request).RemoveWhitespace();
+			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
 		}
 
 		[Fact]
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 8a4196a6..5e77e74d 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -1,7 +1,13 @@
 using GraphQL.Client.Serializer.Newtonsoft;
+using Newtonsoft.Json;
 
 namespace GraphQL.Client.Serializer.Tests {
 	public class NewtonsoftSerializerTest : BaseSerializerTest {
 		public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
 	}
+
+	public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
+		public NewtonsoftSerializeNoCamelCaseTest()
+			: base(new NewtonsoftJsonSerializer(options => options.JsonSerializerSettings = new JsonSerializerSettings())) { }
+	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index 177bb64b..c0bec30f 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -1,9 +1,14 @@
+using System.Text.Json;
+using Dahomey.Json;
 using GraphQL.Client.Serializer.SystemTextJson;
 
 namespace GraphQL.Client.Serializer.Tests {
 	public class SystemTextJsonSerializerTests: BaseSerializerTest {
-		public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer())
-		{
-		}
+		public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) { }
+	}
+
+	public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
+		public SystemTextJsonSerializeNoCamelCaseTest()
+			: base(new SystemTextJsonSerializer(options => options.JsonSerializerOptions = new JsonSerializerOptions().SetupExtensions())) { }
 	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 5f4f18a1..fed5d193 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -6,9 +6,13 @@ namespace GraphQL.Client.Serializer.Tests.TestData {
 	public class SerializeToStringTestData : IEnumerable<object[]> {
 		public IEnumerator<object[]> GetEnumerator() {
 			yield return new object[] {
-				"{\"query\":\"simple query string\",\"operationName\":null,\"variables\":null}",
+				"{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":null}",
 				new GraphQLRequest("simple query string")
 			};
+			yield return new object[] {
+				"{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":{\"camelCaseProperty\":\"test\",\"pascalCaseProperty\":\"test\"}}",
+				new GraphQLRequest("simple query string", new { camelCaseProperty = "test", PascalCaseProperty = "test"})
+			};
 		}
 
 		IEnumerator IEnumerable.GetEnumerator() {
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index d9db0515..3919581f 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -11,6 +11,7 @@
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+    <PackageReference Include="xunit" Version="2.4.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
similarity index 97%
rename from tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs
rename to tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
index e0d46b5f..7525d2b5 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
@@ -2,7 +2,7 @@
 using System.Threading;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.Helpers {
+namespace GraphQL.Client.Tests.Common.Helpers {
 	public class CallbackTester<T> {
 		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
 
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
new file mode 100644
index 00000000..2da34009
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
@@ -0,0 +1,11 @@
+using System.Linq;
+
+namespace GraphQL.Client.Tests.Common.Helpers {
+	public static class MiscellaneousExtensions {
+		public static string RemoveWhitespace(this string input) {
+			return new string(input.ToCharArray()
+				.Where(c => !char.IsWhiteSpace(c))
+				.ToArray());
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
similarity index 85%
rename from tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs
rename to tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
index 6995ee54..ec08de02 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
@@ -1,7 +1,7 @@
 using System.Net;
 using System.Net.Sockets;
 
-namespace GraphQL.Integration.Tests.Helpers {
+namespace GraphQL.Client.Tests.Common.Helpers {
 	public static class NetworkHelpers {
 		public static int GetFreeTcpPortNumber() {
 			var l = new TcpListener(IPAddress.Loopback, 0);
diff --git a/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
similarity index 98%
rename from tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
rename to tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index a650237b..55c63c51 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -2,7 +2,7 @@
 using System.Threading;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.Helpers {
+namespace GraphQL.Client.Tests.Common.Helpers {
 	public class ObservableTester<T> : IDisposable {
 		private readonly IDisposable _subscription;
 		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 45c54392..7bb87cde 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -2,6 +2,7 @@
 using GraphQL.Client;
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Client.Tests.Common.Helpers;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
index 82826164..fa6e301e 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
@@ -2,6 +2,7 @@
 using System.Text.Json;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http;
+using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Client.Tests.Common.StarWars;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
index 655aac5f..baf7569c 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
@@ -5,6 +5,7 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Tests.Common.Chat;
+using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
 using Microsoft.AspNetCore.Hosting;

From e2402cb4801fb68bd0bcb52a2a68c520d9aee528 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 12 Feb 2020 12:56:36 +0100
Subject: [PATCH 150/455] fix naming for NewtonSoft

---
 .../GraphQLRequest.cs                         | 21 +++++++++++++++++
 .../GraphQLWebSocketRequest.cs                | 23 +++++++++++++++++++
 .../NewtonsoftJsonSerializer.cs               |  6 ++---
 .../NewtonsoftJsonSerializerOptions.cs        |  2 +-
 ...STJGraphQLRequest.cs => GraphQLRequest.cs} |  7 +++---
 ...tRequest.cs => GraphQLWebSocketRequest.cs} | 11 ++++-----
 .../SystemTextJsonSerializer.cs               |  8 +++----
 .../BaseSerializeNoCamelCaseTest.cs           |  2 +-
 .../TestData/SerializeToStringTestData.cs     |  4 ++--
 9 files changed, 63 insertions(+), 21 deletions(-)
 create mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs
 create mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
 rename src/GraphQL.Client.Serializer.SystemTextJson/{STJGraphQLRequest.cs => GraphQLRequest.cs} (73%)
 rename src/GraphQL.Client.Serializer.SystemTextJson/{STJGraphQLWebSocketRequest.cs => GraphQLWebSocketRequest.cs} (50%)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs
new file mode 100644
index 00000000..cf012c92
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs
@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+
+namespace GraphQL.Client.Serializer.Newtonsoft {
+	public class GraphQLRequest: GraphQL.GraphQLRequest {
+		[JsonProperty(QueryKey)]
+		public override string Query { get; set; }
+		[JsonProperty(OperationNameKey)]
+		public override string? OperationName { get; set; }
+		[JsonProperty(VariablesKey)]
+		public override object? Variables { get; set; }
+
+		public GraphQLRequest() { }
+
+		public GraphQLRequest(GraphQL.GraphQLRequest other) {
+			Query = other.Query;
+			OperationName = other.OperationName;
+			Variables = other.Variables;
+		}
+
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
new file mode 100644
index 00000000..e5fa6999
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
@@ -0,0 +1,23 @@
+using Newtonsoft.Json;
+
+namespace GraphQL.Client.Serializer.Newtonsoft {
+	public class GraphQLWebSocketRequest: Abstractions.Websocket.GraphQLWebSocketRequest {
+
+		[JsonProperty(IdKey)]
+		public override string Id { get; set; }
+		[JsonProperty(TypeKey)]
+		public override string Type { get; set; }
+		[JsonProperty(PayloadKey)]
+		public override GraphQL.GraphQLRequest Payload { get; set; }
+
+		public GraphQLWebSocketRequest()
+		{
+		}
+
+		public GraphQLWebSocketRequest(Abstractions.Websocket.GraphQLWebSocketRequest other) {
+			Id = other.Id;
+			Type = other.Type;
+			Payload = new Newtonsoft.GraphQLRequest(other.Payload);
+		}
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 7115c763..f7ec6269 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -28,11 +28,11 @@ private void ConfigureMandatorySerializerOptions() {
 			Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
 		}
 
-		public string SerializeToString(GraphQLRequest request) {
-		    return JsonConvert.SerializeObject(request, Options.JsonSerializerSettings);
+		public string SerializeToString(GraphQL.GraphQLRequest request) {
+		    return JsonConvert.SerializeObject(new GraphQLRequest(request), Options.JsonSerializerSettings);
 		}
 
-		public byte[] SerializeToBytes(GraphQLWebSocketRequest request) {
+		public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
 			var json = JsonConvert.SerializeObject(request, Options.JsonSerializerSettings);
 			return Encoding.UTF8.GetBytes(json);
 		}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
index 9148ed2e..d05f1dda 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
@@ -4,7 +4,7 @@
 namespace GraphQL.Client.Serializer.Newtonsoft {
 	public class NewtonsoftJsonSerializerOptions {
 		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver()
+			ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true }
 		};
 	}
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLRequest.cs
similarity index 73%
rename from src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
rename to src/GraphQL.Client.Serializer.SystemTextJson/GraphQLRequest.cs
index 9ffa3afa..1f3b7908 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLRequest.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLRequest.cs
@@ -1,8 +1,7 @@
 using System.Text.Json.Serialization;
-using Dahomey.Json.Attributes;
 
 namespace GraphQL.Client.Serializer.SystemTextJson {
-	public class STJGraphQLRequest: GraphQLRequest {
+	public class GraphQLRequest: GraphQL.GraphQLRequest {
 		[JsonPropertyName(QueryKey)]
 		public override string Query { get; set; }
 		[JsonPropertyName(OperationNameKey)]
@@ -10,9 +9,9 @@ public class STJGraphQLRequest: GraphQLRequest {
 		[JsonPropertyName(VariablesKey)]
 		public override object? Variables { get; set; }
 
-		public STJGraphQLRequest() { }
+		public GraphQLRequest() { }
 
-		public STJGraphQLRequest(GraphQLRequest other) {
+		public GraphQLRequest(GraphQL.GraphQLRequest other) {
 			Query = other.Query;
 			OperationName = other.OperationName;
 			Variables = other.Variables;
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
similarity index 50%
rename from src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLWebSocketRequest.cs
rename to src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
index bf6adbeb..f7599391 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/STJGraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
@@ -1,24 +1,23 @@
 using System.Text.Json.Serialization;
-using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Serializer.SystemTextJson {
-	public class STJGraphQLWebSocketRequest: GraphQLWebSocketRequest {
+	public class GraphQLWebSocketRequest: Abstractions.Websocket.GraphQLWebSocketRequest {
 
 		[JsonPropertyName(IdKey)]
 		public override string Id { get; set; }
 		[JsonPropertyName(TypeKey)]
 		public override string Type { get; set; }
 		[JsonPropertyName(PayloadKey)]
-		public override GraphQLRequest Payload { get; set; }
+		public override GraphQL.GraphQLRequest Payload { get; set; }
 
-		public STJGraphQLWebSocketRequest()
+		public GraphQLWebSocketRequest()
 		{
 		}
 
-		public STJGraphQLWebSocketRequest(GraphQLWebSocketRequest other) {
+		public GraphQLWebSocketRequest(Abstractions.Websocket.GraphQLWebSocketRequest other) {
 			Id = other.Id;
 			Type = other.Type;
-			Payload = new STJGraphQLRequest(other.Payload);
+			Payload = new GraphQLRequest(other.Payload);
 		}
 	}
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index f2b793d1..51f7b796 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -28,16 +28,16 @@ private void ConfigureMandatorySerializerOptions() {
 			Options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
 		}
 
-	    public string SerializeToString(GraphQLRequest request) {
-		    return JsonSerializer.Serialize(new STJGraphQLRequest(request), Options.JsonSerializerOptions);
+	    public string SerializeToString(GraphQL.GraphQLRequest request) {
+		    return JsonSerializer.Serialize(new GraphQLRequest(request), Options.JsonSerializerOptions);
 	    }
 
 	    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
 		    return JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options.JsonSerializerOptions, cancellationToken).AsTask();
 	    }
 
-	    public byte[] SerializeToBytes(GraphQLWebSocketRequest request) {
-		    return JsonSerializer.SerializeToUtf8Bytes(new STJGraphQLWebSocketRequest(request), Options.JsonSerializerOptions);
+	    public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
+		    return JsonSerializer.SerializeToUtf8Bytes(new GraphQLWebSocketRequest(request), Options.JsonSerializerOptions);
 	    }
 
 	    public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index dbf11f52..833334b7 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -28,7 +28,7 @@ protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer serialize
 		[ClassData(typeof(SerializeToStringTestData))]
 		public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
 			var json = Serializer.SerializeToString(request).RemoveWhitespace();
-			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
+			json.Should().Be(expectedJson.RemoveWhitespace());
 		}
 
 		[Fact]
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index fed5d193..86d1ae9f 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -10,8 +10,8 @@ public IEnumerator<object[]> GetEnumerator() {
 				new GraphQLRequest("simple query string")
 			};
 			yield return new object[] {
-				"{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":{\"camelCaseProperty\":\"test\",\"pascalCaseProperty\":\"test\"}}",
-				new GraphQLRequest("simple query string", new { camelCaseProperty = "test", PascalCaseProperty = "test"})
+				"{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"}}",
+				new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
 			};
 		}
 

From 4557e27be59b94690879f85fd9c62536c4631596 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 12 Feb 2020 13:13:09 +0100
Subject: [PATCH 151/455] test websocket serialization

---
 .../GraphQLWebSocketRequest.cs                |  2 +-
 .../NewtonsoftJsonSerializer.cs               |  2 +-
 .../BaseSerializeNoCamelCaseTest.cs           |  8 +++++
 .../BaseSerializerTest.cs                     |  9 ++++++
 .../TestData/SerializeToBytesTestData.cs      | 32 +++++++++++++++++++
 5 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
index e5fa6999..c7796bb7 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
@@ -17,7 +17,7 @@ public GraphQLWebSocketRequest()
 		public GraphQLWebSocketRequest(Abstractions.Websocket.GraphQLWebSocketRequest other) {
 			Id = other.Id;
 			Type = other.Type;
-			Payload = new Newtonsoft.GraphQLRequest(other.Payload);
+			Payload = new GraphQLRequest(other.Payload); // create serializer-specific type
 		}
 	}
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index f7ec6269..055fab98 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -33,7 +33,7 @@ public string SerializeToString(GraphQL.GraphQLRequest request) {
 		}
 
 		public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
-			var json = JsonConvert.SerializeObject(request, Options.JsonSerializerSettings);
+			var json = JsonConvert.SerializeObject(new GraphQLWebSocketRequest(request), Options.JsonSerializerSettings);
 			return Encoding.UTF8.GetBytes(json);
 		}
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index 833334b7..13106fcd 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -31,6 +31,14 @@ public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
 			json.Should().Be(expectedJson.RemoveWhitespace());
 		}
 
+		[Theory]
+		[ClassData(typeof(SerializeToBytesTestData))]
+		public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request) {
+			var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
+			json.Should().Be(expectedJson.RemoveWhitespace());
+		}
+
+
 		[Fact]
 		public async void WorksWithoutCamelCaseNamingStrategy() {
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 92226813..a07f38f1 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
@@ -32,6 +34,13 @@ public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
 			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
 		}
 
+		[Theory]
+		[ClassData(typeof(SerializeToBytesTestData))]
+		public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request) {
+			var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
+			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
+		}
+
 		[Fact]
 		public async void CanDeserializeExtensions() {
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
new file mode 100644
index 00000000..41d15ce0
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
@@ -0,0 +1,32 @@
+using System.Collections;
+using System.Collections.Generic;
+using GraphQL.Client.Abstractions.Websocket;
+using GraphQL.Client.Tests.Common.Chat;
+
+namespace GraphQL.Client.Serializer.Tests.TestData {
+	public class SerializeToBytesTestData : IEnumerable<object[]> {
+		public IEnumerator<object[]> GetEnumerator() {
+			yield return new object[] {
+				"{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":null}}",
+				new GraphQLWebSocketRequest {
+					Id = "1234567",
+					Type = GraphQLWebSocketMessageType.GQL_START,
+					Payload = new GraphQLRequest("simplequerystring")
+				}
+			};
+			yield return new object[] {
+				"{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"}}}",
+				new GraphQLWebSocketRequest {
+					Id = "34476567",
+					Type = GraphQLWebSocketMessageType.GQL_START,
+					Payload = new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
+				}
+				
+			};
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return GetEnumerator();
+		}
+	}
+}

From a6f192b7fdb4227558ecd43feb316419e2db4377 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 12 Feb 2020 15:18:45 +0100
Subject: [PATCH 152/455] remove Options classes from serializers, fix
 GraphQLWebsocketRequest transformation

---
 .../GraphQLJsonSerializerExtensions.cs        |   6 +-
 .../GraphQLWebSocketRequest.cs                |   2 +-
 .../NewtonsoftJsonSerializer.cs               |  27 +--
 .../NewtonsoftJsonSerializerOptions.cs        |  10 --
 .../GraphQLWebSocketRequest.cs                |   2 +-
 .../SystemTextJsonSerializer.cs               |  27 +--
 .../SystemTextJsonSerializerOptions.cs        |  10 --
 .../NewtonsoftSerializerTest.cs               |   2 +-
 .../SystemTextJsonSerializerTests.cs          |   2 +-
 .../GraphQL.Client.Tests.Common.csproj        |   2 +-
 .../Helpers/CallbackTester.cs                 |   9 +-
 .../Helpers/ObservableTester.cs               | 155 +++++++++---------
 .../WebsocketTest.cs                          | 139 ++++++++--------
 13 files changed, 190 insertions(+), 203 deletions(-)
 delete mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
 delete mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs

diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index e544e75f..960f687f 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -22,8 +22,10 @@ public static TSerializerInterface EnsureAssigned<TSerializerInterface>(this TSe
 			return jsonSerializer;
 		}
 
-		public static TOptions New<TOptions>(this Action<TOptions> configure) {
-			var options = Activator.CreateInstance<TOptions>();
+		public static TOptions New<TOptions>(this Action<TOptions> configure) =>
+			configure.AndReturn(Activator.CreateInstance<TOptions>());
+
+		public static TOptions AndReturn<TOptions>(this Action<TOptions> configure, TOptions options) {
 			configure(options);
 			return options;
 		}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
index c7796bb7..c575b9d3 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
@@ -17,7 +17,7 @@ public GraphQLWebSocketRequest()
 		public GraphQLWebSocketRequest(Abstractions.Websocket.GraphQLWebSocketRequest other) {
 			Id = other.Id;
 			Type = other.Type;
-			Payload = new GraphQLRequest(other.Payload); // create serializer-specific type
+			Payload = other.Payload != null ? new GraphQLRequest(other.Payload) : null; // create serializer-specific type
 		}
 	}
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 055fab98..a40ad456 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -1,39 +1,44 @@
 using System;
 using System.IO;
-using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.Serializer.Newtonsoft
 {
     public class NewtonsoftJsonSerializer: IGraphQLWebsocketJsonSerializer
     {
-	    public NewtonsoftJsonSerializerOptions Options { get; }
+		public static JsonSerializerSettings DefaultJsonSerializerSettings => new JsonSerializerSettings {
+			ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
+			MissingMemberHandling = MissingMemberHandling.Ignore
+		};
 
-	    public NewtonsoftJsonSerializer() : this(new NewtonsoftJsonSerializerOptions()) { }
+		public JsonSerializerSettings JsonSerializerSettings { get; }
 
-		public NewtonsoftJsonSerializer(Action<NewtonsoftJsonSerializerOptions> configure) : this(configure.New()) { }
+	    public NewtonsoftJsonSerializer() : this(DefaultJsonSerializerSettings) { }
 
-		public NewtonsoftJsonSerializer(NewtonsoftJsonSerializerOptions options) {
-		    Options = options;
+		public NewtonsoftJsonSerializer(Action<JsonSerializerSettings> configure) : this(configure.AndReturn(DefaultJsonSerializerSettings)) { }
+
+		public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings) {
+		    JsonSerializerSettings = jsonSerializerSettings;
 		    ConfigureMandatorySerializerOptions();
 		}
 
 		private void ConfigureMandatorySerializerOptions() {
 			// deserialize extensions to Dictionary<string, object>
-			Options.JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
+			JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
 		}
 
 		public string SerializeToString(GraphQL.GraphQLRequest request) {
-		    return JsonConvert.SerializeObject(new GraphQLRequest(request), Options.JsonSerializerSettings);
+		    return JsonConvert.SerializeObject(new GraphQLRequest(request), JsonSerializerSettings);
 		}
 
 		public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
-			var json = JsonConvert.SerializeObject(new GraphQLWebSocketRequest(request), Options.JsonSerializerSettings);
+			var json = JsonConvert.SerializeObject(new GraphQLWebSocketRequest(request), JsonSerializerSettings);
 			return Encoding.UTF8.GetBytes(json);
 		}
 
@@ -43,7 +48,7 @@ public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync
 
 		public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
 			return JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
-				Options.JsonSerializerSettings);
+				JsonSerializerSettings);
 		}
 
 		public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
@@ -54,7 +59,7 @@ public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse
 		private Task<T> DeserializeFromUtf8Stream<T>(Stream stream) {
 			using StreamReader sr = new StreamReader(stream);
 			using JsonReader reader = new JsonTextReader(sr);
-			JsonSerializer serializer = JsonSerializer.Create(Options.JsonSerializerSettings);
+			JsonSerializer serializer = JsonSerializer.Create(JsonSerializerSettings);
 			return Task.FromResult(serializer.Deserialize<T>(reader));
 		}
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
deleted file mode 100644
index d05f1dda..00000000
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializerOptions.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Serialization;
-
-namespace GraphQL.Client.Serializer.Newtonsoft {
-	public class NewtonsoftJsonSerializerOptions {
-		public JsonSerializerSettings JsonSerializerSettings { get; set; } = new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true }
-		};
-	}
-}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
index f7599391..4961e00d 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
@@ -17,7 +17,7 @@ public GraphQLWebSocketRequest()
 		public GraphQLWebSocketRequest(Abstractions.Websocket.GraphQLWebSocketRequest other) {
 			Id = other.Id;
 			Type = other.Type;
-			Payload = new GraphQLRequest(other.Payload);
+			Payload = other.Payload != null ? new GraphQLRequest(other.Payload) : null; // create serializer-specific type;
 		}
 	}
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 51f7b796..420a8522 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -3,6 +3,7 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using Dahomey.Json;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 
@@ -10,43 +11,47 @@ namespace GraphQL.Client.Serializer.SystemTextJson
 {
     public class SystemTextJsonSerializer: IGraphQLWebsocketJsonSerializer
     {
-	    public SystemTextJsonSerializerOptions Options { get; }
+	    public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions {
+		    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+	    }.SetupExtensions();
 
-	    public SystemTextJsonSerializer() : this(new SystemTextJsonSerializerOptions()) { }
+		public JsonSerializerOptions Options { get; }
 
-	    public SystemTextJsonSerializer(Action<SystemTextJsonSerializerOptions> configure) : this(configure.New()) { }
+	    public SystemTextJsonSerializer() : this(DefaultJsonSerializerOptions) { }
 
-		public SystemTextJsonSerializer(SystemTextJsonSerializerOptions options) {
+	    public SystemTextJsonSerializer(Action<JsonSerializerOptions> configure) : this(configure.AndReturn(DefaultJsonSerializerOptions)) { }
+
+		public SystemTextJsonSerializer(JsonSerializerOptions options) {
 		    Options = options;
 		    ConfigureMandatorySerializerOptions();
 		}
 
 		private void ConfigureMandatorySerializerOptions() {
 			// deserialize extensions to Dictionary<string, object>
-			Options.JsonSerializerOptions.Converters.Insert(0, new GraphQLExtensionsConverter());
+			Options.Converters.Insert(0, new GraphQLExtensionsConverter());
 			// allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
-			Options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
+			Options.PropertyNameCaseInsensitive = true;
 		}
 
 	    public string SerializeToString(GraphQL.GraphQLRequest request) {
-		    return JsonSerializer.Serialize(new GraphQLRequest(request), Options.JsonSerializerOptions);
+		    return JsonSerializer.Serialize(new GraphQLRequest(request), Options);
 	    }
 
 	    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
-		    return JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options.JsonSerializerOptions, cancellationToken).AsTask();
+		    return JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options, cancellationToken).AsTask();
 	    }
 
 	    public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
-		    return JsonSerializer.SerializeToUtf8Bytes(new GraphQLWebSocketRequest(request), Options.JsonSerializerOptions);
+		    return JsonSerializer.SerializeToUtf8Bytes(new GraphQLWebSocketRequest(request), Options);
 	    }
 
 	    public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
-		    return JsonSerializer.DeserializeAsync<WebsocketResponseWrapper>(stream, Options.JsonSerializerOptions).AsTask();
+		    return JsonSerializer.DeserializeAsync<WebsocketResponseWrapper>(stream, Options).AsTask();
 		}
 
 	    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
 		    return JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
-			    Options.JsonSerializerOptions);
+			    Options);
 	    }
 
     }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
deleted file mode 100644
index af9bbc35..00000000
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializerOptions.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System.Text.Json;
-using Dahomey.Json;
-
-namespace GraphQL.Client.Serializer.SystemTextJson {
-	public class SystemTextJsonSerializerOptions {
-		public JsonSerializerOptions JsonSerializerOptions { get; set; } = new JsonSerializerOptions {
-				PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-			}.SetupExtensions();
-	}
-}
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 5e77e74d..84bb5e84 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -8,6 +8,6 @@ public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
 
 	public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
 		public NewtonsoftSerializeNoCamelCaseTest()
-			: base(new NewtonsoftJsonSerializer(options => options.JsonSerializerSettings = new JsonSerializerSettings())) { }
+			: base(new NewtonsoftJsonSerializer(new JsonSerializerSettings())) { }
 	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index c0bec30f..a3d393dc 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -9,6 +9,6 @@ public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) {
 
 	public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
 		public SystemTextJsonSerializeNoCamelCaseTest()
-			: base(new SystemTextJsonSerializer(options => options.JsonSerializerOptions = new JsonSerializerOptions().SetupExtensions())) { }
+			: base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupExtensions())) { }
 	}
 }
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 3919581f..8526c03a 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -5,13 +5,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.0" />
     <PackageReference Include="GraphQL" Version="2.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
-    <PackageReference Include="xunit" Version="2.4.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
index 7525d2b5..c8ca29c5 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Threading;
-using Xunit;
+using FluentAssertions;
 
 namespace GraphQL.Client.Tests.Common.Helpers {
 	public class CallbackTester<T> {
@@ -32,8 +32,8 @@ public void Callback(T param) {
 		/// <param name="assertPayload">action to assert the contents of the payload</param>
 		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null) {
 			try {
-				if (!_callbackInvoked.Wait(timeout ?? Timeout))
-					Assert.True(false, $"callback not invoked within {(timeout ?? Timeout).TotalSeconds} s!");
+				_callbackInvoked.Wait(timeout ?? Timeout).Should().BeTrue("because the callback method should have been invoked (timeout: {0} s)",
+					(timeout ?? Timeout).TotalSeconds);
 
 				assertPayload?.Invoke(LastPayload);
 			}
@@ -49,8 +49,7 @@ public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSp
 		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null) {
 			if (!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
 			try {
-				if (_callbackInvoked.Wait(timeout.Value))
-					Assert.True(false, "callback was inadvertently invoked pushed!");
+				_callbackInvoked.Wait(timeout.Value).Should().BeFalse("because the callback method should not have been invoked");
 			}
 			finally {
 				Reset();
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 55c63c51..1b8d8030 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -1,27 +1,31 @@
 using System;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
 using System.Threading;
-using Xunit;
+using FluentAssertions;
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
 
 namespace GraphQL.Client.Tests.Common.Helpers {
-	public class ObservableTester<T> : IDisposable {
-		private readonly IDisposable _subscription;
-		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
-		private ManualResetEventSlim _completed { get; } = new ManualResetEventSlim();
-		private ManualResetEventSlim _error { get; } = new ManualResetEventSlim();
+	public class ObservableTester<TPayload> : IDisposable {
+		private readonly IDisposable subscription;
+		private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
+		private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
+		private readonly ManualResetEventSlim error = new ManualResetEventSlim();
 
 		/// <summary>
 		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
 		/// </summary>
-		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
 		/// <summary>
 		/// Indicates that an update has been received since the last <see cref="_reset"/>
 		/// </summary>
-		public bool UpdateReceived => _updateReceived.IsSet;
+		public bool UpdateReceived => updateReceived.IsSet;
 		/// <summary>
 		/// The last payload which was received.
 		/// </summary>
-		public T LastPayload { get; private set; }
+		public TPayload LastPayload { get; private set; }
 
 		public Exception Error { get; private set; }
 
@@ -29,101 +33,104 @@ public class ObservableTester<T> : IDisposable {
 		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
-		public ObservableTester(IObservable<T> observable) {
-			_subscription = observable.Subscribe(
+		public ObservableTester(IObservable<TPayload> observable) {
+			subscription = observable.ObserveOn(TaskPoolScheduler.Default).Subscribe(
 				obj => {
 					LastPayload = obj;
-					_updateReceived.Set();
+					updateReceived.Set();
 				},
 				ex => {
 					Error = ex;
-					_error.Set();
+					error.Set();
 				},
-				() => _completed.Set()
+				() => completed.Set()
 			);
 		}
 
 		/// <summary>
-		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>.
-		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
-		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null, TimeSpan? timeout = null) {
-			try {
-				if (!_updateReceived.Wait(timeout ?? Timeout))
-					Assert.True(false, $"no update received within {(timeout ?? Timeout).TotalSeconds} s!");
+		private void Reset() {
+			updateReceived.Reset();
+		}
 
-				assertPayload?.Invoke(LastPayload);
-			}
-			finally {
-				_reset();
-			}
+		/// <inheritdoc />
+		public void Dispose() {
+			subscription?.Dispose();
 		}
 
-		/// <summary>
-		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="_reset"/>
-		/// </summary>
-		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void ShouldNotHaveReceivedUpdate(TimeSpan? timeout = null) {
-			if (!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
-			try {
-				if (_updateReceived.Wait(timeout.Value))
-					Assert.True(false, "update was inadvertently pushed!");
-			}
-			finally {
-				_reset();
-			}
+		public SubscriptionAssertions<TPayload> Should() {
+			return new SubscriptionAssertions<TPayload>(this);
 		}
 
-		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
-		/// </summary>
-		public void ShouldHaveCompleted(TimeSpan? timeout = null) {
-			try {
-				if (!_completed.Wait(timeout ?? Timeout))
-					Assert.True(false, $"subscription did not complete within {(timeout ?? Timeout).TotalSeconds} s!");
+		public class SubscriptionAssertions<TPayload> : ReferenceTypeAssertions<ObservableTester<TPayload>, SubscriptionAssertions<TPayload>> {
+			public SubscriptionAssertions(ObservableTester<TPayload> tester) {
+				Subject = tester;
 			}
-			finally {
-				_reset();
+
+			protected override string Identifier => "Subscription";
+
+			public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(TimeSpan timeout,
+				string because = "", params object[] becauseArgs) {
+				Execute.Assertion
+					.BecauseOf(because, becauseArgs)
+					.Given(() => Subject.updateReceived.Wait(timeout))
+					.ForCondition(isSet => isSet)
+					.FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
+
+				Subject.updateReceived.Reset();
+				return new AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
 			}
-		}
+			public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(string because = "", params object[] becauseArgs)
+				=> HaveReceivedPayload(Subject.Timeout, because, becauseArgs);
 
-		/// <summary>
-		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="_reset"/>
-		/// </summary>
-		public void ShouldHaveThrownError(Action<Exception> assertError = null, TimeSpan? timeout = null) {
-			try {
-				if (!_error.Wait(timeout ?? Timeout))
-					Assert.True(false, $"subscription did not throw an error within {(timeout ?? Timeout).TotalSeconds} s!");
+			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(TimeSpan timeout,
+				string because = "", params object[] becauseArgs) {
+				Execute.Assertion
+					.BecauseOf(because, becauseArgs)
+					.Given(() => Subject.updateReceived.Wait(timeout))
+					.ForCondition(isSet => !isSet)
+					.FailWith("Expected {context:Subscription} to not receive a new payload{reason}, but did receive an update: {0}", Subject.LastPayload);
 
-				assertError?.Invoke(Error);
+				Subject.updateReceived.Reset();
+				return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
 			}
-			finally {
-				_reset();
+			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(string because = "", params object[] becauseArgs)
+				=> NotHaveReceivedPayload(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+
+			public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(TimeSpan timeout,
+				string because = "", params object[] becauseArgs) {
+				Execute.Assertion
+					.BecauseOf(because, becauseArgs)
+					.Given(() => Subject.error.Wait(timeout))
+					.ForCondition(isSet => isSet)
+					.FailWith("Expected {context:Subscription} to fail{reason}, but did not receive an error within {0}", timeout);
+
+				return new AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception>(this, Subject.Error);
 			}
-		}
+			public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(string because = "", params object[] becauseArgs)
+				=> HaveReceivedError(Subject.Timeout, because, becauseArgs);
 
-		/// <summary>
-		/// Resets the tester class. Should be called before triggering the potential update
-		/// </summary>
-		private void _reset() {
-			//if (_completed.IsSet)
-			//	throw new InvalidOperationException(
-			//		"the subscription sequence has completed. this tester instance cannot be reused");
 
-			LastPayload = default(T);
-			_updateReceived.Reset();
-		}
+			public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(TimeSpan timeout,
+				string because = "", params object[] becauseArgs) {
+				Execute.Assertion
+					.BecauseOf(because, becauseArgs)
+					.Given(() => Subject.completed.Wait(timeout))
+					.ForCondition(isSet => isSet)
+					.FailWith("Expected {context:Subscription} to complete{reason}, but did not complete within {0}", timeout);
 
-		/// <inheritdoc />
-		public void Dispose() {
-			_subscription?.Dispose();
+				return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
+			}
+			public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(string because = "", params object[] becauseArgs)
+				=> HaveCompleted(Subject.Timeout, because, becauseArgs);
 		}
 	}
 
 	public static class ObservableExtensions {
-		public static ObservableTester<T> SubscribeTester<T>(this IObservable<T> observable) {
+		public static ObservableTester<T> Monitor<T>(this IObservable<T> observable) {
 			return new ObservableTester<T>(observable);
 		}
 	}
+
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
index baf7569c..a568693e 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
@@ -11,6 +11,7 @@
 using Microsoft.AspNetCore.Hosting;
 using Xunit;
 using Xunit.Abstractions;
+using FluentAssertions;
 
 namespace GraphQL.Integration.Tests {
 	public class WebsocketTest {
@@ -78,26 +79,24 @@ public async void CanCreateObservableSubscription() {
 				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
-				var tester = observable.SubscribeTester();
-				const string message1 = "Hello World";
-
-				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, response.Data.AddMessage.Content);
-
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
-				});
-
-				const string message2 = "lorem ipsum dolor si amet";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content);
-				});
-
-				// disposing the client should throw a TaskCanceledException on the subscription
-				client.Dispose();
-				tester.ShouldHaveCompleted();
+				using (var tester = observable.Monitor()) {
+					const string message1 = "Hello World";
+
+					var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+					response.Data.AddMessage.Content.Should().Be(message1);
+					tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
+						.Which.Data.MessageAdded.Content.Should().Be(message1);
+
+					const string message2 = "lorem ipsum dolor si amet";
+					response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+					response.Data.AddMessage.Content.Should().Be(message2);
+					tester.Should().HaveReceivedPayload()
+						.Which.Data.MessageAdded.Content.Should().Be(message2);
+
+					// disposing the client should throw a TaskCanceledException on the subscription
+					client.Dispose();
+					tester.Should().HaveCompleted();
+				}
 			}
 		}
 
@@ -120,21 +119,19 @@ public async void CanReconnectWithSameObservable() {
 				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
-				var tester = observable.SubscribeTester();
+				var tester = observable.Monitor();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
-				});
+				response.Data.AddMessage.Content.Should().Be(message1);
+				tester.Should().HaveReceivedPayload()
+					.Which.Data.MessageAdded.Content.Should().Be(message1);
 
 				const string message2 = "How are you?";
 				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				Assert.Equal(message2, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content);
-				});
+				response.Data.AddMessage.Content.Should().Be(message2);
+				tester.Should().HaveReceivedPayload()
+					.Which.Data.MessageAdded.Content.Should().Be(message2);
 
 				Debug.WriteLine("disposing subscription...");
 				tester.Dispose();
@@ -142,20 +139,19 @@ public async void CanReconnectWithSameObservable() {
 				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating new subscription...");
-				tester = observable.SubscribeTester();
-				tester.ShouldHaveReceivedUpdate(
-					gqlResponse => { Assert.Equal(message2, gqlResponse.Data.MessageAdded.Content); },
-					TimeSpan.FromSeconds(10));
+				tester = observable.Monitor();
+				tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10))
+					.Which.Data.MessageAdded.Content.Should().Be(message2);
+
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
-				Assert.Equal(message3, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal(message3, gqlResponse.Data.MessageAdded.Content);
-				});
+				response.Data.AddMessage.Content.Should().Be(message3);
+				tester.Should().HaveReceivedPayload()
+					.Which.Data.MessageAdded.Content.Should().Be(message3);
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester.ShouldHaveCompleted();
+				tester.Should().HaveCompleted();
 			}
 		}
 
@@ -193,39 +189,36 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
-				var tester = observable1.SubscribeTester();
-				var tester2 = observable2.SubscribeTester();
+				var tester = observable1.Monitor();
+				var tester2 = observable2.Monitor();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				Assert.Equal(message1, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
-				});
+				response.Data.AddMessage.Content.Should().Be(message1);
+				tester.Should().HaveReceivedPayload()
+					.Which.Data.MessageAdded.Content.Should().Be(message1);
 
 				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
 
 				var joinResponse = await client.JoinDeveloperUser().ConfigureAwait(false);
-				Assert.Equal("developer", joinResponse.Data.Join.DisplayName);
+				joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
-				tester2.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal("1", gqlResponse.Data.UserJoined.Id);
-					Assert.Equal("developer", gqlResponse.Data.UserJoined.DisplayName);
-				});
+				var payload = tester2.Should().HaveReceivedPayload().Subject;
+				payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
+				payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
 				Debug.WriteLine("disposing subscription...");
 				tester2.Dispose();
 
 				const string message3 = "lorem ipsum dolor si amet";
 				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
-				Assert.Equal(message3, response.Data.AddMessage.Content);
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Equal(message3, gqlResponse.Data.MessageAdded.Content);
-				});
+				response.Data.AddMessage.Content.Should().Be(message3);
+				tester.Should().HaveReceivedPayload()
+					.Which.Data.MessageAdded.Content.Should().Be(message3);
 
 				// disposing the client should complete the subscription
 				client.Dispose();
-				tester.ShouldHaveCompleted();
+				tester.Should().HaveCompleted();
 			}
 		}
 
@@ -241,15 +234,13 @@ public async void CanHandleConnectionTimeout() {
 			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
 
 			Debug.WriteLine("subscribing...");
-			var tester = observable.SubscribeTester();
+			var tester = observable.Monitor();
 			const string message1 = "Hello World";
 
 			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-			Assert.Equal(message1, response.Data.AddMessage.Content);
-
-			tester.ShouldHaveReceivedUpdate(gqlResponse => {
-				Assert.Equal(message1, gqlResponse.Data.MessageAdded.Content);
-			});
+			response.Data.AddMessage.Content.Should().Be(message1);
+			tester.Should().HaveReceivedPayload()
+				.Which.Data.MessageAdded.Content.Should().Be(message1);
 
 			Debug.WriteLine("stopping web host...");
 			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
@@ -268,7 +259,7 @@ public async void CanHandleConnectionTimeout() {
 
 			// disposing the client should complete the subscription
 			client.Dispose();
-			tester.ShouldHaveCompleted(TimeSpan.FromSeconds(5));
+			tester.Should().HaveCompleted(TimeSpan.FromSeconds(5));
 			server.Dispose();
 		}
 
@@ -289,13 +280,12 @@ public async void CanHandleSubscriptionError() {
 					);
 
 				Debug.WriteLine("subscribing...");
-				var tester = observable.SubscribeTester();
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Single(gqlResponse.Errors);
-				});
-				tester.ShouldHaveCompleted();
-
-				client.Dispose();
+				using (var tester = observable.Monitor()) {
+					tester.Should().HaveReceivedPayload()
+						.Which.Errors.Should().ContainSingle();
+					tester.Should().HaveCompleted();
+					client.Dispose();
+				}
 			}
 		}
 
@@ -319,13 +309,12 @@ public async void CanHandleQueryErrorInSubscription() {
 				);
 
 				Debug.WriteLine("subscribing...");
-				var tester = observable.SubscribeTester();
-				tester.ShouldHaveReceivedUpdate(gqlResponse => {
-					Assert.Single(gqlResponse.Errors);
-				});
-				tester.ShouldHaveCompleted();
-
-				client.Dispose();
+				using (var tester = observable.Monitor()) {
+					tester.Should().HaveReceivedPayload()
+						.Which.Errors.Should().ContainSingle();
+					tester.Should().HaveCompleted();
+					client.Dispose();
+				}
 			}
 		}
 	}

From a47cae1f0d483ae0cd514f05ccdc1831a64e02b5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 12 Feb 2020 15:39:48 +0100
Subject: [PATCH 153/455] run websocket tests for all available serializers

---
 .../Helpers/AvailableJsonSerializers.cs       | 24 ++++++
 .../GraphQL.Integration.Tests.csproj          |  2 +
 .../Helpers/WebHostHelpers.cs                 | 10 ++-
 .../NewtonsoftWebsocketTest.cs                |  5 ++
 .../WebsocketTest.cs                          | 83 +++++++++++--------
 5 files changed, 87 insertions(+), 37 deletions(-)
 create mode 100644 tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
 create mode 100644 tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs

diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
new file mode 100644
index 00000000..637c5861
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using GraphQL.Client.Abstractions;
+
+namespace GraphQL.Client.Tests.Common.Helpers {
+	public class AvailableJsonSerializers<TSerializerInterface> : IEnumerable<object[]> where TSerializerInterface : IGraphQLJsonSerializer {
+		public IEnumerator<object[]> GetEnumerator() {
+				// try to find one in the assembly and assign that
+				var type = typeof(TSerializerInterface);
+				return AppDomain.CurrentDomain
+					.GetAssemblies()
+					.SelectMany(s => s.GetTypes())
+					.Where(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract)
+					.Select(serializerType => new object[]{Activator.CreateInstance(serializerType)})
+					.GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return GetEnumerator();
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index b1731cc1..3273adae 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -21,6 +21,8 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Client.Serializer.SystemTextJson\GraphQL.Client.Serializer.SystemTextJson.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
   </ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 7bb87cde..0ee54a08 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,5 +1,6 @@
 using System;
 using GraphQL.Client;
+using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Client.Tests.Common.Helpers;
@@ -33,19 +34,20 @@ public static IWebHost CreateServer<TStartup>(int port) where TStartup : class
 		}
 
 
-		public static GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false)
+		public static GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions {
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
 				UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
-				JsonSerializer = new NewtonsoftJsonSerializer()
+				JsonSerializer = serializer ?? new NewtonsoftJsonSerializer()
 			});
 		
-		public static TestServerSetup SetupTest<TStartup>(bool requestsViaWebsocket = false) where TStartup : class
+		public static TestServerSetup SetupTest<TStartup>(bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
+			where TStartup : class
 		{
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			return new TestServerSetup {
 				Server = CreateServer<TStartup>(port),
-				Client = GetGraphQLClient(port)
+				Client = GetGraphQLClient(port, requestsViaWebsocket, serializer)
 			};
 		}
 	}
diff --git a/tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs b/tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs
new file mode 100644
index 00000000..fd0491b0
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs
@@ -0,0 +1,5 @@
+namespace GraphQL.Integration.Tests {
+	public class NewtonsoftWebsocketTest {
+		
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
index a568693e..1715cd3c 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTest.cs
@@ -12,22 +12,23 @@
 using Xunit;
 using Xunit.Abstractions;
 using FluentAssertions;
+using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Integration.Tests {
 	public class WebsocketTest {
 		private readonly ITestOutputHelper output;
-
 		private static IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
 
 		public WebsocketTest(ITestOutputHelper output) {
 			this.output = output;
 		}
 		
-		[Fact]
-		public async void AssertTestingHarness() {
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void AssertTestingHarness(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
 
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
@@ -36,11 +37,13 @@ public async void AssertTestingHarness() {
 			}
 		}
 
-		[Fact]
-		public async void CanSendRequestViaWebsocket() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanSendRequestViaWebsocket(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, true);
+				var client = WebHostHelpers.GetGraphQLClient(port, true, serializer);
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
@@ -48,11 +51,13 @@ public async void CanSendRequestViaWebsocket() {
 			}
 		}
 
-		[Fact]
-		public async void CanHandleRequestErrorViaWebsocket() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanHandleRequestErrorViaWebsocket(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, true);
+				var client = WebHostHelpers.GetGraphQLClient(port, true, serializer);
 				var response = await client.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
 
 				Assert.Single(response.Errors);
@@ -68,11 +73,13 @@ public async void CanHandleRequestErrorViaWebsocket() {
 
 		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
-		[Fact]
-		public async void CanCreateObservableSubscription() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanCreateObservableSubscription(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
 				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating subscription stream");
@@ -108,11 +115,13 @@ public class MessageAddedContent {
 			}
 		}
 
-		[Fact]
-		public async void CanReconnectWithSameObservable() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanReconnectWithSameObservable(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
 				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating subscription stream");
@@ -175,18 +184,22 @@ public class UserJoinedContent {
 
 		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
-		[Fact]
-		public async void CanConnectTwoSubscriptionsSimultaneously() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanConnectTwoSubscriptionsSimultaneously(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackTester<Exception>();
 			var callbackTester2 = new CallbackTester<Exception>();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
 				await client.InitializeWebsocketConnection();
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable1 = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
-				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable1 =
+					client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 =
+					client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable1.Monitor();
@@ -197,9 +210,7 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 				response.Data.AddMessage.Content.Should().Be(message1);
 				tester.Should().HaveReceivedPayload()
 					.Which.Data.MessageAdded.Content.Should().Be(message1);
-
-				await Task.Delay(500); // ToDo: can be removed after https://github.com/graphql-dotnet/server/pull/199 was merged and released
-
+				
 				var joinResponse = await client.JoinDeveloperUser().ConfigureAwait(false);
 				joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
@@ -222,13 +233,15 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			}
 		}
 
-		[Fact]
-		public async void CanHandleConnectionTimeout() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanHandleConnectionTimeout(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var server = CreateServer(port);
 			var callbackTester = new CallbackTester<Exception>();
 
-			var client = WebHostHelpers.GetGraphQLClient(port);
+			var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
 			await client.InitializeWebsocketConnection();
 			Debug.WriteLine("creating subscription stream");
 			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
@@ -263,11 +276,13 @@ public async void CanHandleConnectionTimeout() {
 			server.Dispose();
 		}
 
-		[Fact]
-		public async void CanHandleSubscriptionError() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanHandleSubscriptionError(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
 				await client.InitializeWebsocketConnection();
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
@@ -289,14 +304,16 @@ public async void CanHandleSubscriptionError() {
 			}
 		}
 
-		[Fact]
-		public async void CanHandleQueryErrorInSubscription() {
+
+		[Theory]
+		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
+		public async void CanHandleQueryErrorInSubscription(IGraphQLWebsocketJsonSerializer serializer) {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 
 				var test = new GraphQLRequest("tset", new { test = "blaa" });
 
-				var client = WebHostHelpers.GetGraphQLClient(port);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
 				await client.InitializeWebsocketConnection();
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(

From 673ccaa4c9a024226e74077ac7182bea5974f5f9 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 13 Feb 2020 08:21:34 +0100
Subject: [PATCH 154/455] Fix example in README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f55b48dd..3f0c61ff 100644
--- a/README.md
+++ b/README.md
@@ -45,7 +45,7 @@ var heroAndFriendsRequest = new GraphQLRequest {
 
 ### Execute Query/Mutation:
 ```csharp
-var graphQLClient = new GraphQLClient("https://swapi.apis.guru/");
+var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
 
 public class HeroAndFriendsResponse {
     public Hero Hero {get; set;}

From 94c2d918c3a650fa089a80dabf56e12faf419d6e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 14 Feb 2020 11:25:31 +0100
Subject: [PATCH 155/455] restructure test classes

---
 .../ExtensionsTest.cs                         | 34 ----------
 .../NewtonsoftWebsocketTest.cs                |  5 --
 .../Base.cs}                                  | 18 +++--
 .../QueryAndMutationTests/Newtonsoft.cs       |  9 +++
 .../QueryAndMutationTests/SystemTextJson.cs   |  9 +++
 .../Base.cs}                                  | 66 +++++++++----------
 .../WebsocketTests/Newtonsoft.cs              | 10 +++
 .../WebsocketTests/SystemTextJson.cs          | 10 +++
 8 files changed, 81 insertions(+), 80 deletions(-)
 delete mode 100644 tests/GraphQL.Integration.Tests/ExtensionsTest.cs
 delete mode 100644 tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs
 rename tests/GraphQL.Integration.Tests/{QueryAndMutationTests.cs => QueryAndMutationTests/Base.cs} (90%)
 create mode 100644 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
 create mode 100644 tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
 rename tests/GraphQL.Integration.Tests/{WebsocketTest.cs => WebsocketTests/Base.cs} (84%)
 create mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs

diff --git a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs b/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
deleted file mode 100644
index cdfb5622..00000000
--- a/tests/GraphQL.Integration.Tests/ExtensionsTest.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using GraphQL.Integration.Tests.Helpers;
-using IntegrationTestServer;
-
-namespace GraphQL.Integration.Tests {
-	public class ExtensionsTest {
-		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) =>
-			WebHostHelpers.SetupTest<StartupChat>(requestsViaWebsocket);
-
-		//[Fact]
-		//public async void DontNeedToUseCamelCaseNamingStrategy() {
-
-		//	using var setup = SetupTest();
-		//	setup.Client.Options.JsonSerializerSettings = new JsonSerializerSettings();
-
-		//	const string message = "some random testing message";
-		//	var graphQLRequest = new GraphQLRequest(
-		//		@"mutation($input: MessageInputType){
-		//		  addMessage(message: $input){
-		//		    content
-		//		  }
-		//		}",
-		//		new {
-		//			input = new {
-		//				fromId = "2",
-		//				content = message,
-		//				sentAt = DateTime.Now
-		//			}
-		//		});
-		//	var response = await setup.Client.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
-
-		//	Assert.Equal(message, response.Data.addMessage.content);
-		//}
-	}
-}
diff --git a/tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs b/tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs
deleted file mode 100644
index fd0491b0..00000000
--- a/tests/GraphQL.Integration.Tests/NewtonsoftWebsocketTest.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-namespace GraphQL.Integration.Tests {
-	public class NewtonsoftWebsocketTest {
-		
-	}
-}
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
similarity index 90%
rename from tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
rename to tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index fa6e301e..be153ba2 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -1,19 +1,25 @@
 using System.Net.Http;
-using System.Text.Json;
 using GraphQL.Client.Abstractions;
+using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Client.Tests.Common.StarWars;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
-using Newtonsoft.Json.Linq;
 using Xunit;
 
-namespace GraphQL.Integration.Tests {
-	public class QueryAndMutationTests {
+namespace GraphQL.Integration.Tests.QueryAndMutationTests {
+
+	public abstract class Base {
+
+		protected IGraphQLWebsocketJsonSerializer serializer;
+
+		private TestServerSetup SetupTest(bool requestsViaWebsocket = false) => WebHostHelpers.SetupTest<StartupStarWars>(requestsViaWebsocket, serializer);
+
+		protected Base(IGraphQLWebsocketJsonSerializer serializer) {
+			this.serializer = serializer;
+		}
 
-		private static TestServerSetup SetupTest(bool requestsViaWebsocket = false) => WebHostHelpers.SetupTest<StartupStarWars>(requestsViaWebsocket);
-		
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
 		public async void QueryTheory(int id, string name) {
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
new file mode 100644
index 00000000..1046ed6d
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
@@ -0,0 +1,9 @@
+using GraphQL.Client.Serializer.Newtonsoft;
+
+namespace GraphQL.Integration.Tests.QueryAndMutationTests {
+	public class Newtonsoft: Base {
+		public Newtonsoft() : base(new NewtonsoftJsonSerializer())
+		{
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
new file mode 100644
index 00000000..dd725b4d
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
@@ -0,0 +1,9 @@
+using GraphQL.Client.Serializer.SystemTextJson;
+
+namespace GraphQL.Integration.Tests.QueryAndMutationTests {
+	public class SystemTextJson: Base {
+		public SystemTextJson() : base(new SystemTextJsonSerializer())
+		{
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
similarity index 84%
rename from tests/GraphQL.Integration.Tests/WebsocketTest.cs
rename to tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 1715cd3c..ff1cabe1 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -3,7 +3,9 @@
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
+using FluentAssertions;
 using GraphQL.Client.Abstractions;
+using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
@@ -11,21 +13,24 @@
 using Microsoft.AspNetCore.Hosting;
 using Xunit;
 using Xunit.Abstractions;
-using FluentAssertions;
-using GraphQL.Client.Abstractions.Websocket;
 
-namespace GraphQL.Integration.Tests {
-	public class WebsocketTest {
-		private readonly ITestOutputHelper output;
-		private static IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
+namespace GraphQL.Integration.Tests.WebsocketTests {
+	public abstract class Base {
+		protected readonly ITestOutputHelper output;
+		protected readonly IGraphQLWebsocketJsonSerializer serializer;
+		protected IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
 
-		public WebsocketTest(ITestOutputHelper output) {
+		public Base(ITestOutputHelper output, IGraphQLWebsocketJsonSerializer serializer) {
+			this.output = output;
+			this.serializer = serializer;
+		}
+
+		public Base(ITestOutputHelper output) {
 			this.output = output;
 		}
 		
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void AssertTestingHarness(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void AssertTestingHarness() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
@@ -38,9 +43,8 @@ public async void AssertTestingHarness(IGraphQLWebsocketJsonSerializer serialize
 		}
 
 
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanSendRequestViaWebsocket(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanSendRequestViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port, true, serializer);
@@ -51,10 +55,8 @@ public async void CanSendRequestViaWebsocket(IGraphQLWebsocketJsonSerializer ser
 			}
 		}
 
-
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanHandleRequestErrorViaWebsocket(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanHandleRequestErrorViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port, true, serializer);
@@ -74,9 +76,8 @@ public async void CanHandleRequestErrorViaWebsocket(IGraphQLWebsocketJsonSeriali
 		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
 
 
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanCreateObservableSubscription(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanCreateObservableSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
@@ -116,9 +117,8 @@ public class MessageAddedContent {
 		}
 
 
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanReconnectWithSameObservable(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanReconnectWithSameObservable() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
@@ -185,9 +185,8 @@ public class UserJoinedContent {
 		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
 
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanConnectTwoSubscriptionsSimultaneously(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackTester<Exception>();
 			var callbackTester2 = new CallbackTester<Exception>();
@@ -234,9 +233,8 @@ public async void CanConnectTwoSubscriptionsSimultaneously(IGraphQLWebsocketJson
 		}
 
 
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanHandleConnectionTimeout(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanHandleConnectionTimeout() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var server = CreateServer(port);
 			var callbackTester = new CallbackTester<Exception>();
@@ -277,9 +275,8 @@ public async void CanHandleConnectionTimeout(IGraphQLWebsocketJsonSerializer ser
 		}
 
 
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanHandleSubscriptionError(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanHandleSubscriptionError() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
@@ -305,9 +302,8 @@ public async void CanHandleSubscriptionError(IGraphQLWebsocketJsonSerializer ser
 		}
 
 
-		[Theory]
-		[ClassData(typeof(AvailableJsonSerializers<IGraphQLWebsocketJsonSerializer>))]
-		public async void CanHandleQueryErrorInSubscription(IGraphQLWebsocketJsonSerializer serializer) {
+		[Fact]
+		public async void CanHandleQueryErrorInSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
new file mode 100644
index 00000000..02a0b030
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
@@ -0,0 +1,10 @@
+using GraphQL.Client.Serializer.Newtonsoft;
+using Xunit.Abstractions;
+
+namespace GraphQL.Integration.Tests.WebsocketTests {
+	public class Newtonsoft: Base {
+		public Newtonsoft(ITestOutputHelper output) : base(output, new NewtonsoftJsonSerializer())
+		{
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
new file mode 100644
index 00000000..3a7882e4
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
@@ -0,0 +1,10 @@
+using GraphQL.Client.Serializer.SystemTextJson;
+using Xunit.Abstractions;
+
+namespace GraphQL.Integration.Tests.WebsocketTests {
+	public class SystemTextJson: Base {
+		public SystemTextJson(ITestOutputHelper output) : base(output, new SystemTextJsonSerializer())
+		{
+		}
+	}
+}

From 1a35989a357360a43946dbf3e31891cfc6724993 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 16 Feb 2020 12:48:52 +0100
Subject: [PATCH 156/455] Update README.md

Added note on using `byte[]` in variables (see #163)
---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 3f0c61ff..95d46939 100644
--- a/README.md
+++ b/README.md
@@ -43,6 +43,8 @@ var heroAndFriendsRequest = new GraphQLRequest {
 };
 ```
 
+Be careful when using `byte[]` in your variables object, as most JSON serializers will treat that as binary data! If you really need to send a *list of bytes* with a `byte[]` as a source, then convert it to a `List<byte>` first, which will tell the serializer to output a list of numbers instead of a base64-encoded string.
+
 ### Execute Query/Mutation:
 ```csharp
 var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
@@ -62,6 +64,8 @@ var graphQLResponse = await graphQLClient.SendQueryAsync<HeroAndFriendsResponse>
 var heroName = graphQLResponse.Data.Hero.Name;
 ```
 
+
+
 ### Use Subscriptions
 
 ```csharp

From bfa906ba25f4505200d6564ac44f6091c327561e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 17 Feb 2020 10:14:49 +0100
Subject: [PATCH 157/455] fix dispose on websocket

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 579be9e7..a79eb597 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -21,7 +21,7 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private Subject<WebsocketResponseWrapper> _responseSubject;
 		private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
-		private IDisposable _requestSubscription;
+		private readonly IDisposable _requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 
@@ -272,6 +272,7 @@ private async Task DisposeAsync() {
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
 			await _closeAsync().ConfigureAwait(false);
+			_requestSubscription?.Dispose();
 			clientWebSocket?.Dispose();
 			_cancellationTokenSource.Dispose();
 			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");

From d3fa68675400501c10b6fe1299a26984cf9221d3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 17 Feb 2020 10:35:01 +0100
Subject: [PATCH 158/455] refactor disposing to better match steven clearys
 example

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 28 ++++++++++++-------
 .../GraphQL.Client.Serializer.Tests.csproj    |  3 +-
 .../GraphQL.Client.Tests.Common.csproj        |  1 +
 3 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index a79eb597..2b2f1db4 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -90,7 +90,7 @@ private Task _backOff() {
 
 		public Task InitializeWebSocket() {
 			// do not attempt to initialize if cancellation is requested
-			if (_disposed != null)
+			if (Completion != null)
 				throw new OperationCanceledException();
 
 			lock (_initializeLock) {
@@ -254,20 +254,28 @@ private async Task _closeAsync(CancellationToken cancellationToken = default) {
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
 		}
 
-#endregion
+		#endregion
 
-#region IDisposable
+		#region IDisposable
+		public void Dispose() => Complete();
 
-		private Task _disposed;
-		private object _disposedLocker = new object();
-		public void Dispose() {
-			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-			lock (_disposedLocker) {
-				if (_disposed == null) _disposed = DisposeAsync();
+		/// <summary>
+		/// Cancels the current operation, closes the websocket connection and disposes of internal resources.
+		/// </summary>
+		public void Complete() {
+			lock (completedLocker) {
+				if (Completion == null) Completion = CompleteAsync();
 			}
 		}
 
-		private async Task DisposeAsync() {
+		/// <summary>
+		/// Task to await the completion (a.k.a. disposal) of this websocket.
+		/// </summary> 
+		/// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+		public Task Completion { get; private set; }
+
+		private readonly object completedLocker = new object();
+		private async Task CompleteAsync() {
 			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 583a8e82..b61c1466 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -2,8 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-
-    <IsPackable>false</IsPackable>
+	  <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 8526c03a..7b8d4982 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+	  <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>

From 72500b51c4dbc127586aaf95a7d12239d14e7089 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 17 Feb 2020 10:48:20 +0100
Subject: [PATCH 159/455] cleanup websocket code

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 133 +++++++++---------
 1 file changed, 65 insertions(+), 68 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 2b2f1db4..2789a305 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -14,57 +14,57 @@
 namespace GraphQL.Client.Http.Websocket {
 	internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly Uri webSocketUri;
-		private readonly GraphQLHttpClientOptions _options;
+		private readonly GraphQLHttpClientOptions options;
 		private readonly ArraySegment<byte> buffer;
-		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 
-		private Subject<WebsocketResponseWrapper> _responseSubject;
-		private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
-		private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
-		private readonly IDisposable _requestSubscription;
+		private Subject<WebsocketResponseWrapper> responseSubject;
+		private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
+		private readonly IDisposable requestSubscription;
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
+		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
+		public IObservable<WebsocketResponseWrapper> ResponseStream { get; }
 
 #if NETFRAMEWORK
 		private WebSocket clientWebSocket = null;
 #else
 		private ClientWebSocket clientWebSocket = null;
 #endif
-		private int _connectionAttempt = 0;
+		private int connectionAttempt = 0;
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options) {
 			this.webSocketUri = webSocketUri;
-			_options = options;
+			this.options = options;
 			buffer = new ArraySegment<byte>(new byte[8192]);
-			_responseStream = _createResponseStream();
+			ResponseStream = _createResponseStream();
 
-			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
+			requestSubscription = requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
 		}
 
-		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
 
-		public IObservable<WebsocketResponseWrapper> ResponseStream => _responseStream;
-		public readonly IObservable<WebsocketResponseWrapper> _responseStream;
+		#region Send requests
 
 		public Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
-			_requestSubject.OnNext(request);
+			requestSubject.OnNext(request);
 			return request.SendTask();
 		}
 
 		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request) {
 			try {
-				if (_cancellationTokenSource.Token.IsCancellationRequested) {
+				if (cancellationTokenSource.Token.IsCancellationRequested) {
 					request.SendCanceled();
 					return;
 				}
 
 				await InitializeWebSocket().ConfigureAwait(false);
-				var requestBytes = _options.JsonSerializer.SerializeToBytes(request);
+				var requestBytes = options.JsonSerializer.SerializeToBytes(request);
 				await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
 					true,
-					_cancellationTokenSource.Token).ConfigureAwait(false);
+					cancellationTokenSource.Token).ConfigureAwait(false);
 				request.SendCompleted();
 			}
 			catch (Exception e) {
@@ -72,28 +72,18 @@ await this.clientWebSocket.SendAsync(
 			}
 		}
 
-		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
-
-		private readonly object _initializeLock = new object();
-
-#region Private Methods
-
-		private Task _backOff() {
-			_connectionAttempt++;
-
-			if (_connectionAttempt == 1) return Task.CompletedTask;
+		#endregion
 
-			var delay = _options.BackOffStrategy(_connectionAttempt - 1);
-			Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
-			return Task.Delay(delay);
-		}
+		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
 
+		private readonly object initializeLock = new object();
+		
 		public Task InitializeWebSocket() {
 			// do not attempt to initialize if cancellation is requested
 			if (Completion != null)
 				throw new OperationCanceledException();
 
-			lock (_initializeLock) {
+			lock (initializeLock) {
 				// if an initialization task is already running, return that
 				if (InitializeWebSocketTask != null &&
 				   !InitializeWebSocketTask.IsFaulted &&
@@ -115,13 +105,13 @@ public Task InitializeWebSocket() {
 				switch (clientWebSocket) {
 					case ClientWebSocket nativeWebSocket:
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
-						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)_options.HttpMessageHandler).ClientCertificates;
-						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)_options.HttpMessageHandler).UseDefaultCredentials;
+						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)options.HttpMessageHandler).ClientCertificates;
+						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)options.HttpMessageHandler).UseDefaultCredentials;
 						break;
 					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
 						managedWebSocket.Options.AddSubProtocol("graphql-ws");
-						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)_options.HttpMessageHandler).ClientCertificates;
-						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)_options.HttpMessageHandler).UseDefaultCredentials;
+						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)options.HttpMessageHandler).ClientCertificates;
+						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)options.HttpMessageHandler).UseDefaultCredentials;
 						break;
 					default:
 						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
@@ -129,10 +119,10 @@ public Task InitializeWebSocket() {
 #else
 				clientWebSocket = new ClientWebSocket();
 				clientWebSocket.Options.AddSubProtocol("graphql-ws");
-				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)_options.HttpMessageHandler).ClientCertificates;
-				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)_options.HttpMessageHandler).UseDefaultCredentials;
+				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)options.HttpMessageHandler).ClientCertificates;
+				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)options.HttpMessageHandler).UseDefaultCredentials;
 #endif
-				return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+				return InitializeWebSocketTask = _connectAsync(cancellationTokenSource.Token);
 			}
 		}
 
@@ -144,25 +134,25 @@ private IObservable<WebsocketResponseWrapper> _createResponseStream() {
 		}
 
 		private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseWrapper> observer, CancellationToken token) {
-			if (_responseSubject == null || _responseSubject.IsDisposed) {
-				_responseSubject = new Subject<WebsocketResponseWrapper>();
+			if (responseSubject == null || responseSubject.IsDisposed) {
+				responseSubject = new Subject<WebsocketResponseWrapper>();
 				var observable = await _getReceiveResultStream().ConfigureAwait(false);
-				observable.Subscribe(_responseSubject);
+				observable.Subscribe(responseSubject);
 
-				_responseSubject.Subscribe(_ => { }, ex => {
-					_exceptionSubject.OnNext(ex);
-					_responseSubject?.Dispose();
-					_responseSubject = null;
+				responseSubject.Subscribe(_ => { }, ex => {
+					exceptionSubject.OnNext(ex);
+					responseSubject?.Dispose();
+					responseSubject = null;
 				},
 				() => {
-					_responseSubject?.Dispose();
-					_responseSubject = null;
+					responseSubject?.Dispose();
+					responseSubject = null;
 				});
 			}
 
 			return new CompositeDisposable
 			(
-				_responseSubject.Subscribe(observer),
+				responseSubject.Subscribe(observer),
 				Disposable.Create(() => {
 					Debug.WriteLine("response stream disposed");
 				})
@@ -180,30 +170,39 @@ private async Task _connectAsync(CancellationToken token) {
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
 				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
-				_connectionAttempt = 1;
+				connectionAttempt = 1;
 			}
 			catch (Exception e) {
-				_exceptionSubject.OnNext(e);
+				exceptionSubject.OnNext(e);
 				throw;
 			}
 		}
+		
+		private Task _backOff() {
+			connectionAttempt++;
+
+			if (connectionAttempt == 1) return Task.CompletedTask;
 
+			var delay = options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
+			Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
+			return Task.Delay(delay);
+		}
 
-		private Task<WebsocketResponseWrapper> _receiveAsyncTask = null;
-		private readonly object _receiveTaskLocker = new object();
+		private Task<WebsocketResponseWrapper> receiveAsyncTask = null;
+		private readonly object receiveTaskLocker = new object();
 		/// <summary>
 		/// wrapper method to pick up the existing request task if already running
 		/// </summary>
 		/// <returns></returns>
 		private Task<WebsocketResponseWrapper> _getReceiveTask() {
-			lock (_receiveTaskLocker) {
-				if (_receiveAsyncTask == null ||
-					_receiveAsyncTask.IsFaulted ||
-					_receiveAsyncTask.IsCompleted)
-					_receiveAsyncTask = _receiveResultAsync();
+			lock (receiveTaskLocker) {
+				if (receiveAsyncTask == null ||
+					receiveAsyncTask.IsFaulted ||
+					receiveAsyncTask.IsCompleted)
+					receiveAsyncTask = _receiveResultAsync();
 			}
 
-			return _receiveAsyncTask;
+			return receiveAsyncTask;
 		}
 
 		private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
@@ -213,17 +212,17 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 				using (var ms = new MemoryStream()) {
 					WebSocketReceiveResult webSocketReceiveResult = null;
 					do {
-						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+						cancellationTokenSource.Token.ThrowIfCancellationRequested();
 						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
 						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
 					}
 					while (!webSocketReceiveResult.EndOfMessage);
 
-					_cancellationTokenSource.Token.ThrowIfCancellationRequested();
+					cancellationTokenSource.Token.ThrowIfCancellationRequested();
 					ms.Seek(0, SeekOrigin.Begin);
 
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
-						var response = await _options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+						var response = await options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
 						response.MessageBytes = ms.ToArray();
 						return response;
 					}
@@ -254,8 +253,6 @@ private async Task _closeAsync(CancellationToken cancellationToken = default) {
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
 		}
 
-		#endregion
-
 		#region IDisposable
 		public void Dispose() => Complete();
 
@@ -277,12 +274,12 @@ public void Complete() {
 		private readonly object completedLocker = new object();
 		private async Task CompleteAsync() {
 			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
-			if (!_cancellationTokenSource.IsCancellationRequested)
-				_cancellationTokenSource.Cancel();
+			if (!cancellationTokenSource.IsCancellationRequested)
+				cancellationTokenSource.Cancel();
 			await _closeAsync().ConfigureAwait(false);
-			_requestSubscription?.Dispose();
+			requestSubscription?.Dispose();
 			clientWebSocket?.Dispose();
-			_cancellationTokenSource.Dispose();
+			cancellationTokenSource.Dispose();
 			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
 		}
 #endregion

From 56bde94867dcaaea8210ddc404e581be637f2ef6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 17 Feb 2020 11:00:46 +0100
Subject: [PATCH 160/455] add some comments

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 98 ++++++++++---------
 1 file changed, 54 insertions(+), 44 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 2789a305..4efa0923 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -17,22 +17,23 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly GraphQLHttpClientOptions options;
 		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-
-		private Subject<WebsocketResponseWrapper> responseSubject;
 		private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
 		private readonly IDisposable requestSubscription;
 
-		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
-		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
-		public IObservable<WebsocketResponseWrapper> ResponseStream { get; }
+		private int connectionAttempt = 0;
+		private Subject<WebsocketResponseWrapper> responseSubject;
 
 #if NETFRAMEWORK
 		private WebSocket clientWebSocket = null;
 #else
 		private ClientWebSocket clientWebSocket = null;
 #endif
-		private int connectionAttempt = 0;
+
+
+		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
+		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
+		public IObservable<WebsocketResponseWrapper> ResponseStream { get; }
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options) {
 			this.webSocketUri = webSocketUri;
@@ -74,8 +75,7 @@ await this.clientWebSocket.SendAsync(
 
 		#endregion
 
-		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
-
+		private Task initializeWebSocketTask = Task.CompletedTask;
 		private readonly object initializeLock = new object();
 		
 		public Task InitializeWebSocket() {
@@ -85,10 +85,10 @@ public Task InitializeWebSocket() {
 
 			lock (initializeLock) {
 				// if an initialization task is already running, return that
-				if (InitializeWebSocketTask != null &&
-				   !InitializeWebSocketTask.IsFaulted &&
-				   !InitializeWebSocketTask.IsCompleted)
-					return InitializeWebSocketTask;
+				if (initializeWebSocketTask != null &&
+				   !initializeWebSocketTask.IsFaulted &&
+				   !initializeWebSocketTask.IsCompleted)
+					return initializeWebSocketTask;
 
 				// if the websocket is open, return a completed task
 				if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
@@ -122,10 +122,39 @@ public Task InitializeWebSocket() {
 				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)options.HttpMessageHandler).ClientCertificates;
 				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)options.HttpMessageHandler).UseDefaultCredentials;
 #endif
-				return InitializeWebSocketTask = _connectAsync(cancellationTokenSource.Token);
+				return initializeWebSocketTask = _connectAsync(cancellationTokenSource.Token);
 			}
 		}
 
+		private async Task _connectAsync(CancellationToken token) {
+			try {
+				await _backOff().ConfigureAwait(false);
+				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+				connectionAttempt = 1;
+			}
+			catch (Exception e) {
+				exceptionSubject.OnNext(e);
+				throw;
+			}
+		}
+
+		/// <summary>
+		/// delay the next connection attempt using <see cref="GraphQLHttpClientOptions.BackOffStrategy"/>
+		/// </summary>
+		/// <returns></returns>
+		private Task _backOff() {
+			connectionAttempt++;
+
+			if (connectionAttempt == 1) return Task.CompletedTask;
+
+			var delay = options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
+			Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
+			return Task.Delay(delay);
+		}
+
+
 		private IObservable<WebsocketResponseWrapper> _createResponseStream() {
 			return Observable.Create<WebsocketResponseWrapper>(_createResultStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
@@ -135,10 +164,16 @@ private IObservable<WebsocketResponseWrapper> _createResponseStream() {
 
 		private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseWrapper> observer, CancellationToken token) {
 			if (responseSubject == null || responseSubject.IsDisposed) {
+				// create new response subject
 				responseSubject = new Subject<WebsocketResponseWrapper>();
-				var observable = await _getReceiveResultStream().ConfigureAwait(false);
-				observable.Subscribe(responseSubject);
 
+				// initialize and connect websocket
+				await InitializeWebSocket().ConfigureAwait(false);
+
+				// loop the receive task and subscribe the created subject to the results 
+				Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat().Subscribe(responseSubject);
+
+				// dispose the subject on any error or completion (will be recreated) 
 				responseSubject.Subscribe(_ => { }, ex => {
 					exceptionSubject.OnNext(ex);
 					responseSubject?.Dispose();
@@ -159,35 +194,6 @@ private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseW
 			);
 		}
 
-		private async Task<IObservable<WebsocketResponseWrapper>> _getReceiveResultStream() {
-			await InitializeWebSocket().ConfigureAwait(false);
-			return Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat();
-		}
-
-		private async Task _connectAsync(CancellationToken token) {
-			try {
-				await _backOff().ConfigureAwait(false);
-				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
-				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
-				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
-				connectionAttempt = 1;
-			}
-			catch (Exception e) {
-				exceptionSubject.OnNext(e);
-				throw;
-			}
-		}
-		
-		private Task _backOff() {
-			connectionAttempt++;
-
-			if (connectionAttempt == 1) return Task.CompletedTask;
-
-			var delay = options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
-			Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
-			return Task.Delay(delay);
-		}
-
 		private Task<WebsocketResponseWrapper> receiveAsyncTask = null;
 		private readonly object receiveTaskLocker = new object();
 		/// <summary>
@@ -205,6 +211,10 @@ private Task<WebsocketResponseWrapper> _getReceiveTask() {
 			return receiveAsyncTask;
 		}
 
+		/// <summary>
+		/// read a single message from the websocket
+		/// </summary>
+		/// <returns></returns>
 		private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 			try {
 				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");

From 34010007db664be07833b0bcd26a427b4a91eb47 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 17 Feb 2020 11:14:38 +0100
Subject: [PATCH 161/455] create observable for the websockets connection state

---
 .../GraphQLWebsocketConnectionState.cs                |  7 +++++++
 src/GraphQL.Client/GraphQLHttpClient.cs               |  6 +++++-
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs  | 11 ++++++++++-
 3 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
new file mode 100644
index 00000000..3ab5a0e2
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
@@ -0,0 +1,7 @@
+namespace GraphQL.Client.Abstractions.Websocket {
+	public enum GraphQLWebsocketConnectionState {
+		Disconnected,
+		Connecting,
+		Connected
+	}
+}
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 465a0286..a387aa66 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Concurrent;
-using System.Linq;
 using System.Net.Http;
 using System.Text;
 using System.Threading;
@@ -33,6 +32,11 @@ public class GraphQLHttpClient : IGraphQLClient {
 		/// </summary>
 		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
 
+		/// <summary>
+		/// the websocket connection state
+		/// </summary>
+		public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState =>
+			graphQlHttpWebSocket.ConnectionState;
 
 		#region Constructors
 
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 4efa0923..0e44377f 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -19,6 +19,8 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 		private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
+		private readonly BehaviorSubject<GraphQLWebsocketConnectionState> stateSubject =
+			new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
 		private readonly IDisposable requestSubscription;
 
 		private int connectionAttempt = 0;
@@ -33,6 +35,8 @@ internal class GraphQLHttpWebSocket : IDisposable {
 
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
+		public IObservable<GraphQLWebsocketConnectionState> ConnectionState => stateSubject.DistinctUntilChanged();
+
 		public IObservable<WebsocketResponseWrapper> ResponseStream { get; }
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options) {
@@ -95,8 +99,8 @@ public Task InitializeWebSocket() {
 					return Task.CompletedTask;
 
 				// else (re-)create websocket and connect
-				//_responseStreamConnection?.Dispose();
 				clientWebSocket?.Dispose();
+				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
 
 #if NETFRAMEWORK
 				// fix websocket not supported on win 7 using
@@ -131,10 +135,12 @@ private async Task _connectAsync(CancellationToken token) {
 				await _backOff().ConfigureAwait(false);
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
 				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
 				connectionAttempt = 1;
 			}
 			catch (Exception e) {
+				stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 				exceptionSubject.OnNext(e);
 				throw;
 			}
@@ -178,10 +184,12 @@ private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseW
 					exceptionSubject.OnNext(ex);
 					responseSubject?.Dispose();
 					responseSubject = null;
+					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 				},
 				() => {
 					responseSubject?.Dispose();
 					responseSubject = null;
+					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 				});
 			}
 
@@ -261,6 +269,7 @@ private async Task _closeAsync(CancellationToken cancellationToken = default) {
 
 			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
 			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+			stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 		}
 
 		#region IDisposable

From c546271770a54758b03dd56f254d5b5ffae34e16 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 17 Feb 2020 11:29:36 +0100
Subject: [PATCH 162/455] add OnWebsocketConnected callback

---
 src/GraphQL.Client/GraphQLHttpClient.cs       |  4 +--
 .../GraphQLHttpClientOptions.cs               |  5 ++++
 .../Websocket/GraphQLHttpWebSocket.cs         | 29 ++++++++++---------
 3 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index a387aa66..dbf4bcb7 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -51,7 +51,7 @@ public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) : this(conf
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
 			Options = options;
 			this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
 			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
 		}
 
@@ -59,7 +59,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 			Options = options ?? throw new ArgumentNullException(nameof(options));
 			Options.JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
 			this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), Options);
+			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
 		}
 
 		#endregion
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 8a9afae8..f6b2b6eb 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -49,5 +49,10 @@ public class GraphQLHttpClientOptions {
 		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
 		/// </summary>
 		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
+
+		/// <summary>
+		/// This function is called after successfully establishing a websocket connection but before any regular request is made. 
+		/// </summary>
+		public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
 	}
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 0e44377f..b82ac252 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -14,7 +14,7 @@
 namespace GraphQL.Client.Http.Websocket {
 	internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly Uri webSocketUri;
-		private readonly GraphQLHttpClientOptions options;
+		private readonly GraphQLHttpClient client;
 		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 		private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
@@ -25,6 +25,7 @@ internal class GraphQLHttpWebSocket : IDisposable {
 
 		private int connectionAttempt = 0;
 		private Subject<WebsocketResponseWrapper> responseSubject;
+		private GraphQLHttpClientOptions Options => client.Options;
 
 #if NETFRAMEWORK
 		private WebSocket clientWebSocket = null;
@@ -39,9 +40,9 @@ internal class GraphQLHttpWebSocket : IDisposable {
 
 		public IObservable<WebsocketResponseWrapper> ResponseStream { get; }
 
-		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options) {
+		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
 			this.webSocketUri = webSocketUri;
-			this.options = options;
+			this.client = client;
 			buffer = new ArraySegment<byte>(new byte[8192]);
 			ResponseStream = _createResponseStream();
 
@@ -64,7 +65,7 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request) {
 				}
 
 				await InitializeWebSocket().ConfigureAwait(false);
-				var requestBytes = options.JsonSerializer.SerializeToBytes(request);
+				var requestBytes = Options.JsonSerializer.SerializeToBytes(request);
 				await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
@@ -109,13 +110,13 @@ public Task InitializeWebSocket() {
 				switch (clientWebSocket) {
 					case ClientWebSocket nativeWebSocket:
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
-						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)options.HttpMessageHandler).ClientCertificates;
-						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)options.HttpMessageHandler).UseDefaultCredentials;
+						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 						break;
 					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
 						managedWebSocket.Options.AddSubProtocol("graphql-ws");
-						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)options.HttpMessageHandler).ClientCertificates;
-						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)options.HttpMessageHandler).UseDefaultCredentials;
+						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 						break;
 					default:
 						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
@@ -123,8 +124,8 @@ public Task InitializeWebSocket() {
 #else
 				clientWebSocket = new ClientWebSocket();
 				clientWebSocket.Options.AddSubProtocol("graphql-ws");
-				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)options.HttpMessageHandler).ClientCertificates;
-				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)options.HttpMessageHandler).UseDefaultCredentials;
+				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 #endif
 				return initializeWebSocketTask = _connectAsync(cancellationTokenSource.Token);
 			}
@@ -136,7 +137,9 @@ private async Task _connectAsync(CancellationToken token) {
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
-				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}");
+				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
+				await (Options.OnWebsocketConnected?.Invoke(client) ?? Task.CompletedTask);
+				Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {clientWebSocket.GetHashCode()}");
 				connectionAttempt = 1;
 			}
 			catch (Exception e) {
@@ -155,7 +158,7 @@ private Task _backOff() {
 
 			if (connectionAttempt == 1) return Task.CompletedTask;
 
-			var delay = options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
+			var delay = Options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
 			Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
 			return Task.Delay(delay);
 		}
@@ -240,7 +243,7 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 					ms.Seek(0, SeekOrigin.Begin);
 
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
-						var response = await options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+						var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
 						response.MessageBytes = ms.ToArray();
 						return response;
 					}

From 1080536408d34ccae4a99ad4a2235b324dbcaa49 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Feb 2020 15:05:55 +0100
Subject: [PATCH 163/455] add tests for callback and WebsocketConnectionState

---
 .../GraphQL.Client.Tests.Common.csproj        |   1 +
 .../Helpers/CallbackMonitor.cs                | 115 ++++++++++++++++++
 .../Helpers/CallbackTester.cs                 |  67 ----------
 .../Helpers/MiscellaneousExtensions.cs        |  14 +++
 .../QueryAndMutationTests/Base.cs             |   4 +-
 .../WebsocketTests/Base.cs                    |  94 ++++++++------
 6 files changed, 186 insertions(+), 109 deletions(-)
 create mode 100644 tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
 delete mode 100644 tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 7b8d4982..dfbb9146 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -17,6 +17,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
new file mode 100644
index 00000000..4b623ac6
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Threading;
+using FluentAssertions;
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+
+namespace GraphQL.Client.Tests.Common.Helpers {
+	public class CallbackMonitor<T> {
+		private readonly ManualResetEventSlim callbackInvoked = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool CallbackInvoked => callbackInvoked.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		public void Invoke(T param) {
+			LastPayload = param;
+			callbackInvoked.Set();
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null) {
+			try {
+				callbackInvoked.Wait(timeout ?? Timeout).Should().BeTrue("because the callback method should have been invoked (timeout: {0} s)",
+					(timeout ?? Timeout).TotalSeconds);
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally {
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null) {
+			if (!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
+			try {
+				callbackInvoked.Wait(timeout.Value).Should().BeFalse("because the callback method should not have been invoked");
+			}
+			finally {
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset() {
+			LastPayload = default(T);
+			callbackInvoked.Reset();
+		}
+
+
+		public CallbackAssertions<T> Should() {
+			return new CallbackAssertions<T>(this);
+		}
+
+		public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>> {
+			public CallbackAssertions(CallbackMonitor<TPayload> tester) {
+				Subject = tester;
+			}
+
+			protected override string Identifier => "callback";
+
+			public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(TimeSpan timeout,
+				string because = "", params object[] becauseArgs) {
+				Execute.Assertion
+					.BecauseOf(because, becauseArgs)
+					.Given(() => Subject.callbackInvoked.Wait(timeout))
+					.ForCondition(isSet => isSet)
+					.FailWith("Expected {context:callback} to be invoked{reason}, but did not receive a call within {0}", timeout);
+
+				Subject.callbackInvoked.Reset();
+				return new AndWhichConstraint<CallbackAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
+			}
+			public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(string because = "", params object[] becauseArgs)
+				=> HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
+
+			public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(TimeSpan timeout, string because = "", params object[] becauseArgs)
+				=> HaveBeenInvokedWithPayload(timeout, because, becauseArgs);
+			public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(string because = "", params object[] becauseArgs)
+				=> HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
+
+			public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(TimeSpan timeout,
+				string because = "", params object[] becauseArgs) {
+				Execute.Assertion
+					.BecauseOf(because, becauseArgs)
+					.Given(() => Subject.callbackInvoked.Wait(timeout))
+					.ForCondition(isSet => !isSet)
+					.FailWith("Expected {context:callback} to not be invoked{reason}, but did receive a call: {0}", Subject.LastPayload);
+
+				Subject.callbackInvoked.Reset();
+				return new AndConstraint<CallbackAssertions<TPayload>>(this);
+			}
+			public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(string because = "", params object[] becauseArgs)
+				=> NotHaveBeenInvoked(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+		}
+	}
+}
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
deleted file mode 100644
index c8ca29c5..00000000
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackTester.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using System;
-using System.Threading;
-using FluentAssertions;
-
-namespace GraphQL.Client.Tests.Common.Helpers {
-	public class CallbackTester<T> {
-		private ManualResetEventSlim _callbackInvoked { get; } = new ManualResetEventSlim();
-
-		/// <summary>
-		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
-		/// </summary>
-		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
-
-		/// <summary>
-		/// Indicates that an update has been received since the last <see cref="Reset"/>
-		/// </summary>
-		public bool CallbackInvoked => _callbackInvoked.IsSet;
-		/// <summary>
-		/// The last payload which was received.
-		/// </summary>
-		public T LastPayload { get; private set; }
-
-		public void Callback(T param) {
-			LastPayload = param;
-			_callbackInvoked.Set();
-		}
-
-		/// <summary>
-		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
-		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
-		/// </summary>
-		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null) {
-			try {
-				_callbackInvoked.Wait(timeout ?? Timeout).Should().BeTrue("because the callback method should have been invoked (timeout: {0} s)",
-					(timeout ?? Timeout).TotalSeconds);
-
-				assertPayload?.Invoke(LastPayload);
-			}
-			finally {
-				Reset();
-			}
-		}
-
-		/// <summary>
-		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
-		/// </summary>
-		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null) {
-			if (!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
-			try {
-				_callbackInvoked.Wait(timeout.Value).Should().BeFalse("because the callback method should not have been invoked");
-			}
-			finally {
-				Reset();
-			}
-		}
-
-		/// <summary>
-		/// Resets the tester class. Should be called before triggering the potential update
-		/// </summary>
-		public void Reset() {
-			LastPayload = default(T);
-			_callbackInvoked.Reset();
-		}
-	}
-}
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
index 2da34009..0e254672 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
@@ -1,4 +1,6 @@
 using System.Linq;
+using System.Threading.Tasks;
+using GraphQL.Client.Http;
 
 namespace GraphQL.Client.Tests.Common.Helpers {
 	public static class MiscellaneousExtensions {
@@ -7,5 +9,17 @@ public static string RemoveWhitespace(this string input) {
 				.Where(c => !char.IsWhiteSpace(c))
 				.ToArray());
 		}
+
+		public static CallbackMonitor<GraphQLHttpClient> ConfigureMonitorForOnWebsocketConnected(
+			this GraphQLHttpClient client) {
+			var tester = new CallbackMonitor<GraphQLHttpClient>();
+			client.Options.OnWebsocketConnected = c => {
+				tester.Invoke(c);
+				return Task.CompletedTask;
+			};
+			return tester;
+		}
+
+
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index be153ba2..16e73c92 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -139,9 +139,9 @@ query Human($id: String!){
 
 		[Fact]
 		public async void PreprocessHttpRequestMessageIsCalled() {
-			var callbackTester = new CallbackTester<HttpRequestMessage>();
+			var callbackTester = new CallbackMonitor<HttpRequestMessage>();
 			var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}") {
-				PreprocessHttpRequestMessage = callbackTester.Callback
+				PreprocessHttpRequestMessage = callbackTester.Invoke
 			};
 
 			using (var setup = SetupTest()) {
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index ff1cabe1..fd2d6ffb 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -16,24 +16,20 @@
 
 namespace GraphQL.Integration.Tests.WebsocketTests {
 	public abstract class Base {
-		protected readonly ITestOutputHelper output;
-		protected readonly IGraphQLWebsocketJsonSerializer serializer;
+		protected readonly ITestOutputHelper Output;
+		protected readonly IGraphQLWebsocketJsonSerializer Serializer;
 		protected IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
 
-		public Base(ITestOutputHelper output, IGraphQLWebsocketJsonSerializer serializer) {
-			this.output = output;
-			this.serializer = serializer;
-		}
-
-		public Base(ITestOutputHelper output) {
-			this.output = output;
+		protected Base(ITestOutputHelper output, IGraphQLWebsocketJsonSerializer serializer) {
+			this.Output = output;
+			this.Serializer = serializer;
 		}
 		
 		[Fact]
 		public async void AssertTestingHarness() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
 
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
@@ -47,7 +43,7 @@ public async void AssertTestingHarness() {
 		public async void CanSendRequestViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, true, serializer);
+				var client = WebHostHelpers.GetGraphQLClient(port, true, Serializer);
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
@@ -59,7 +55,7 @@ public async void CanSendRequestViaWebsocket() {
 		public async void CanHandleRequestErrorViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, true, serializer);
+				var client = WebHostHelpers.GetGraphQLClient(port, true, Serializer);
 				var response = await client.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
 
 				Assert.Single(response.Errors);
@@ -79,9 +75,11 @@ public async void CanHandleRequestErrorViaWebsocket() {
 		[Fact]
 		public async void CanCreateObservableSubscription() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
+			using (CreateServer(port)){
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
+				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
 				await client.InitializeWebsocketConnection();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
@@ -121,14 +119,15 @@ public class MessageAddedContent {
 		public async void CanReconnectWithSameObservable() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
-				await client.InitializeWebsocketConnection();
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
+				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+				var observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.Monitor();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
 				const string message1 = "Hello World";
 				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -143,9 +142,7 @@ public async void CanReconnectWithSameObservable() {
 					.Which.Data.MessageAdded.Content.Should().Be(message2);
 
 				Debug.WriteLine("disposing subscription...");
-				tester.Dispose();
-				await Task.Delay(500);
-				await client.InitializeWebsocketConnection();
+				tester.Dispose(); // does not close the websocket connection
 
 				Debug.WriteLine("creating new subscription...");
 				tester = observable.Monitor();
@@ -188,17 +185,19 @@ public class UserJoinedContent {
 		[Fact]
 		public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			var callbackTester = new CallbackTester<Exception>();
-			var callbackTester2 = new CallbackTester<Exception>();
+			var callbackTester = new CallbackMonitor<Exception>();
+			var callbackTester2 = new CallbackMonitor<Exception>();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
+				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
 				await client.InitializeWebsocketConnection();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable1 =
-					client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+					client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Invoke);
 				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 =
-					client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Callback);
+					client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable1.Monitor();
@@ -237,15 +236,24 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 		public async void CanHandleConnectionTimeout() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var server = CreateServer(port);
-			var callbackTester = new CallbackTester<Exception>();
+			var errorMonitor = new CallbackMonitor<Exception>();
+
+			var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
+			var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
+			var statusMonitor = client.WebsocketConnectionState.Monitor();
+			statusMonitor.Should().HaveReceivedPayload().Which.Should()
+				.Be(GraphQLWebsocketConnectionState.Disconnected);
 
-			var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
-			await client.InitializeWebsocketConnection();
 			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Callback);
+			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, errorMonitor.Invoke);
 
 			Debug.WriteLine("subscribing...");
 			var tester = observable.Monitor();
+			statusMonitor.Should().HaveReceivedPayload().Which.Should()
+				.Be(GraphQLWebsocketConnectionState.Connecting);
+			statusMonitor.Should().HaveReceivedPayload().Which.Should()
+				.Be(GraphQLWebsocketConnectionState.Connected);
+			callbackMonitor.Should().HaveBeenInvokedWithPayload();
 			const string message1 = "Hello World";
 
 			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
@@ -255,18 +263,20 @@ public async void CanHandleConnectionTimeout() {
 
 			Debug.WriteLine("stopping web host...");
 			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
+			server.Dispose();
 			Debug.WriteLine("web host stopped...");
 
-			callbackTester.CallbackShouldHaveBeenInvoked(exception => {
-				Assert.IsType<WebSocketException>(exception);
-			}, TimeSpan.FromSeconds(10));
+			errorMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10))
+				.Which.Should().BeOfType<WebSocketException>();
+			statusMonitor.Should().HaveReceivedPayload().Which.Should()
+				.Be(GraphQLWebsocketConnectionState.Disconnected);
 
-			try {
-				server.Start();
-			}
-			catch (Exception e) {
-				output.WriteLine($"failed to restart server: {e}");
-			}
+			server = CreateServer(port);
+			statusMonitor.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10)).Which.Should()
+				.Be(GraphQLWebsocketConnectionState.Connecting);
+			statusMonitor.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10)).Which.Should()
+				.Be(GraphQLWebsocketConnectionState.Connected);
+			callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
 			// disposing the client should complete the subscription
 			client.Dispose();
@@ -279,8 +289,10 @@ public async void CanHandleConnectionTimeout() {
 		public async void CanHandleSubscriptionError() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
+				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
 				await client.InitializeWebsocketConnection();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload();
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
 					new GraphQLRequest(@"
@@ -309,8 +321,10 @@ public async void CanHandleQueryErrorInSubscription() {
 
 				var test = new GraphQLRequest("tset", new { test = "blaa" });
 
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: serializer);
+				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
+				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
 				await client.InitializeWebsocketConnection();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload();
 				Debug.WriteLine("creating subscription stream");
 				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
 					new GraphQLRequest(@"

From e12ea5bb6e48e65feddd61031c1af1226a6908c4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Feb 2020 16:22:23 +0100
Subject: [PATCH 164/455] fix "Connecting" status

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs   | 2 +-
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index b82ac252..832fb4cf 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -101,7 +101,6 @@ public Task InitializeWebSocket() {
 
 				// else (re-)create websocket and connect
 				clientWebSocket?.Dispose();
-				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
 
 #if NETFRAMEWORK
 				// fix websocket not supported on win 7 using
@@ -134,6 +133,7 @@ public Task InitializeWebSocket() {
 		private async Task _connectAsync(CancellationToken token) {
 			try {
 				await _backOff().ConfigureAwait(false);
+				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index fd2d6ffb..7e0e06a2 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -237,9 +237,16 @@ public async void CanHandleConnectionTimeout() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var server = CreateServer(port);
 			var errorMonitor = new CallbackMonitor<Exception>();
+			var reconnectBlocker = new ManualResetEventSlim(false);
 
 			var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
 			var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
+			// configure back-off strategy to allow it to be controlled from within the unit test
+			client.Options.BackOffStrategy = i => {
+				reconnectBlocker.Wait();
+				return TimeSpan.Zero;
+			};
+
 			var statusMonitor = client.WebsocketConnectionState.Monitor();
 			statusMonitor.Should().HaveReceivedPayload().Which.Should()
 				.Be(GraphQLWebsocketConnectionState.Disconnected);
@@ -272,6 +279,7 @@ public async void CanHandleConnectionTimeout() {
 				.Be(GraphQLWebsocketConnectionState.Disconnected);
 
 			server = CreateServer(port);
+			reconnectBlocker.Set();
 			statusMonitor.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10)).Which.Should()
 				.Be(GraphQLWebsocketConnectionState.Connecting);
 			statusMonitor.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10)).Which.Should()

From 40c910806f8f8a8d15fbb0bf3ad9f4fcd0cfd18a Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 18 Feb 2020 16:24:00 +0100
Subject: [PATCH 165/455] fix doc comment in
 src/GraphQL.Client/GraphQLHttpClientOptions.cs

Co-Authored-By: Ivan Maximov <sungam3r@yandex.ru>
---
 src/GraphQL.Client/GraphQLHttpClientOptions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index f6b2b6eb..a52c772c 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -51,7 +51,7 @@ public class GraphQLHttpClientOptions {
 		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
 
 		/// <summary>
-		/// This function is called after successfully establishing a websocket connection but before any regular request is made. 
+		/// This callback is called after successfully establishing a websocket connection but before any regular request is made. 
 		/// </summary>
 		public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
 	}

From d276793d1280324b1bd278d89ff13b267f075980 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 18 Feb 2020 16:48:17 +0100
Subject: [PATCH 166/455] extend timeout on CanHandleSubscriptionError test

---
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 7e0e06a2..b17ba3c0 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -313,7 +313,7 @@ public async void CanHandleSubscriptionError() {
 
 				Debug.WriteLine("subscribing...");
 				using (var tester = observable.Monitor()) {
-					tester.Should().HaveReceivedPayload()
+					tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
 						.Which.Errors.Should().ContainSingle();
 					tester.Should().HaveCompleted();
 					client.Dispose();

From 03d22cef8d37b19645498e9a6af97c3bfdb2d85d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 10:54:46 +0100
Subject: [PATCH 167/455] create branche workflow for ubuntu

---
 .github/workflows/branches-ubuntu.yml    | 80 ++++++++++++++++++++++++
 GraphQL.Client.sln                       |  6 +-
 src/GraphQL.Client/GraphQL.Client.csproj |  2 +-
 3 files changed, 83 insertions(+), 5 deletions(-)
 create mode 100644 .github/workflows/branches-ubuntu.yml

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
new file mode 100644
index 00000000..f9b89c25
--- /dev/null
+++ b/.github/workflows/branches-ubuntu.yml
@@ -0,0 +1,80 @@
+name: Branch workflow (Ubuntu)
+on: 
+  push:
+    branches-ignore:
+      - develop
+      - 'release/**'
+      - 'releases/**'
+jobs:
+  generateVersionInfo:  
+    name: GenerateVersionInfo
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+    - name: Restore dotnet tools
+      run: dotnet tool restore
+    - name: Fetch complete repository 
+      run: git fetch
+    - name: Generate version info from git history
+      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' > gitversion.properties
+    - name: Upload version info file
+      uses: actions/upload-artifact@v1
+      with:
+        name: gitversion
+        path: gitversion.properties
+
+  build:
+    name: Build
+    needs: generateVersionInfo
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+    - name: Download version info file
+      uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+        path: ./
+    - name: Inject version info into environment
+      run: export $(cat gitversion.properties | xargs) && echo $GitVersion_SemVer
+    - name: Build solution
+      run: dotnet build -c Release
+    - name: Create NuGet packages
+      run: dotnet pack -c Release --no-build -o nupkg 
+    - name: Upload nuget packages
+      uses: actions/upload-artifact@v1
+      with:
+        name: nupkg
+        path: nupkg
+
+  test:
+    name: Test
+    needs: [build, generateVersionInfo]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Setup dotnet environment
+      uses: actions/setup-dotnet@master
+      with:
+        dotnet-version: '3.1.100'
+    - name: Download version info file
+      uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+        path: ./
+    - name: Inject version info into environment
+      run: export $(cat gitversion.properties | xargs) && echo $GitVersion_SemVer
+    - name: Run tests
+      run: dotnet test -c Release
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 510fa0b0..69510eb7 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -32,9 +32,6 @@ EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Server.Test", "tests\GraphQL.Server.Test\GraphQL.Server.Test.csproj", "{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{C42106CF-F685-4F29-BC18-A70616BD68A0}"
-	ProjectSection(SolutionItems) = preProject
-		.github\FUNDING.yml = .github\FUNDING.yml
-	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{05CAF9B2-981E-40C0-AE31-5FA56E351F12}"
 	ProjectSection(SolutionItems) = preProject
@@ -68,7 +65,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.T
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Tests.Common", "tests\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj", "{0D307BAD-27AE-4A5D-8764-4AA2620B01E9}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Serializer.SystemTextJson", "src\GraphQL.Client.Serializer.SystemTextJson\GraphQL.Client.Serializer.SystemTextJson.csproj", "{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.SystemTextJson", "src\GraphQL.Client.Serializer.SystemTextJson\GraphQL.Client.Serializer.SystemTextJson.csproj", "{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -138,6 +135,7 @@ Global
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{05CAF9B2-981E-40C0-AE31-5FA56E351F12} = {C42106CF-F685-4F29-BC18-A70616BD68A0}
 		{95D78D57-3232-491D-BAD6-F373D76EA34D} = {D61415CA-D822-43DD-9AE7-993B8B60E855}
 		{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{C212983F-67DB-44EB-BFB0-5DA75A86DF55} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 31fa21ab..d7e74c27 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -3,7 +3,7 @@
 	<Import Project="../src.props" />
 
     <PropertyGroup>
-		<TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	    <RootNamespace>GraphQL.Client.Http</RootNamespace>
     </PropertyGroup>
 

From bac49776025d22c6b7e8747e5203972e3c2a4d7f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 11:01:08 +0100
Subject: [PATCH 168/455] inject environment using ::set-env

---
 .github/workflows/branches-ubuntu.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index f9b89c25..668067db 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -23,12 +23,12 @@ jobs:
     - name: Fetch complete repository 
       run: git fetch
     - name: Generate version info from git history
-      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' > gitversion.properties
+      run: dotnet gitversion /output json > gitversion.json
     - name: Upload version info file
       uses: actions/upload-artifact@v1
       with:
         name: gitversion
-        path: gitversion.properties
+        path: gitversion.json
 
   build:
     name: Build
@@ -47,7 +47,7 @@ jobs:
         name: gitversion
         path: ./
     - name: Inject version info into environment
-      run: export $(cat gitversion.properties | xargs) && echo $GitVersion_SemVer
+      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
     - name: Build solution
       run: dotnet build -c Release
     - name: Create NuGet packages
@@ -75,6 +75,6 @@ jobs:
         name: gitversion
         path: ./
     - name: Inject version info into environment
-      run: export $(cat gitversion.properties | xargs) && echo $GitVersion_SemVer
+      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
     - name: Run tests
       run: dotnet test -c Release

From 5dae880228a9df6ab51d0a00ab6770d4cc106418 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 11:07:28 +0100
Subject: [PATCH 169/455] output current version before build

---
 .github/workflows/branches-ubuntu.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 668067db..7f066282 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -49,7 +49,7 @@ jobs:
     - name: Inject version info into environment
       run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
     - name: Build solution
-      run: dotnet build -c Release
+      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
     - name: Create NuGet packages
       run: dotnet pack -c Release --no-build -o nupkg 
     - name: Upload nuget packages
@@ -77,4 +77,4 @@ jobs:
     - name: Inject version info into environment
       run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
     - name: Run tests
-      run: dotnet test -c Release
+      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release

From b9710b3bfaccd2a7578d7f84393dd2e2e67a6df6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 11:34:15 +0100
Subject: [PATCH 170/455] should run on ubuntu without installing dotnet first

---
 .github/workflows/branches-ubuntu.yml | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 7f066282..4fde52ff 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -14,10 +14,10 @@ jobs:
       uses: actions/checkout@v2
       with:
         fetch-depth: 0
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
+    # - name: Setup dotnet environment
+    #   uses: actions/setup-dotnet@master
+    #   with:
+    #     dotnet-version: '3.1.100'
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository 
@@ -37,10 +37,10 @@ jobs:
     steps:
     - name: Checkout
       uses: actions/checkout@v2
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
+    # - name: Setup dotnet environment
+    #   uses: actions/setup-dotnet@master
+    #   with:
+    #     dotnet-version: '3.1.100'
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:
@@ -65,10 +65,10 @@ jobs:
     steps:
     - name: Checkout
       uses: actions/checkout@v2
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
+    # - name: Setup dotnet environment
+    #   uses: actions/setup-dotnet@master
+    #   with:
+    #     dotnet-version: '3.1.100'
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:

From fcde0a4c0c35fe3b6bc9f73891f2aa848f2aaf9a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 11:36:10 +0100
Subject: [PATCH 171/455] disable dotnet telemetry

---
 .github/workflows/branches-ubuntu.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 4fde52ff..086c7605 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -5,6 +5,8 @@ on:
       - develop
       - 'release/**'
       - 'releases/**'
+env:
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From 30d372b85b6e57b3d3dc898e8fe8ec1d728e8d46 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 11:41:55 +0100
Subject: [PATCH 172/455] remove commented dotnet setup steps

---
 .github/workflows/branches-ubuntu.yml | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 086c7605..488f6596 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -16,10 +16,6 @@ jobs:
       uses: actions/checkout@v2
       with:
         fetch-depth: 0
-    # - name: Setup dotnet environment
-    #   uses: actions/setup-dotnet@master
-    #   with:
-    #     dotnet-version: '3.1.100'
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository 
@@ -39,10 +35,6 @@ jobs:
     steps:
     - name: Checkout
       uses: actions/checkout@v2
-    # - name: Setup dotnet environment
-    #   uses: actions/setup-dotnet@master
-    #   with:
-    #     dotnet-version: '3.1.100'
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:
@@ -67,10 +59,6 @@ jobs:
     steps:
     - name: Checkout
       uses: actions/checkout@v2
-    # - name: Setup dotnet environment
-    #   uses: actions/setup-dotnet@master
-    #   with:
-    #     dotnet-version: '3.1.100'
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:

From c2991b5104ff09e373cc3cd75e7a83841239288f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 12:19:51 +0100
Subject: [PATCH 173/455] add ReferenceAssemblies package to allow net461 build
 on ubuntu vm

---
 src/GraphQL.Client/GraphQL.Client.csproj | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index d7e74c27..3b11e942 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -3,7 +3,7 @@
 	<Import Project="../src.props" />
 
     <PropertyGroup>
-		<TargetFrameworks>netstandard2.0</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
 	    <RootNamespace>GraphQL.Client.Http</RootNamespace>
     </PropertyGroup>
 
@@ -26,6 +26,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+		<PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
@@ -38,4 +39,7 @@
 	  <ProjectReference Include="..\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
 	</ItemGroup>
 
+	
+
+
 </Project>

From cde1924d7ff824b876ae34bc3e227e3425cefe46 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 12:26:23 +0100
Subject: [PATCH 174/455] rename type param to eliminate build warning

---
 .../Helpers/ObservableTester.cs                        | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 1b8d8030..43bcbe18 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -7,7 +7,7 @@
 using FluentAssertions.Primitives;
 
 namespace GraphQL.Client.Tests.Common.Helpers {
-	public class ObservableTester<TPayload> : IDisposable {
+	public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		private readonly IDisposable subscription;
 		private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
@@ -25,7 +25,7 @@ public class ObservableTester<TPayload> : IDisposable {
 		/// <summary>
 		/// The last payload which was received.
 		/// </summary>
-		public TPayload LastPayload { get; private set; }
+		public TSubscriptionPayload LastPayload { get; private set; }
 
 		public Exception Error { get; private set; }
 
@@ -33,7 +33,7 @@ public class ObservableTester<TPayload> : IDisposable {
 		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
-		public ObservableTester(IObservable<TPayload> observable) {
+		public ObservableTester(IObservable<TSubscriptionPayload> observable) {
 			subscription = observable.ObserveOn(TaskPoolScheduler.Default).Subscribe(
 				obj => {
 					LastPayload = obj;
@@ -59,8 +59,8 @@ public void Dispose() {
 			subscription?.Dispose();
 		}
 
-		public SubscriptionAssertions<TPayload> Should() {
-			return new SubscriptionAssertions<TPayload>(this);
+		public SubscriptionAssertions<TSubscriptionPayload> Should() {
+			return new SubscriptionAssertions<TSubscriptionPayload>(this);
 		}
 
 		public class SubscriptionAssertions<TPayload> : ReferenceTypeAssertions<ObservableTester<TPayload>, SubscriptionAssertions<TPayload>> {

From 5a987990fb34e8068eab009bc659d4aed514ad2c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 14:32:36 +0100
Subject: [PATCH 175/455] disable branch workflow on windows

---
 .github/workflows/branches.yml | 7 +------
 GraphQL.Client.sln             | 1 +
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index a896d523..d88c4a2b 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -1,10 +1,5 @@
 name: Branch workflow
-on: 
-  push:
-    branches-ignore:
-      - develop
-      - 'release/**'
-      - 'releases/**'
+on: []
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 69510eb7..e1943dde 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -35,6 +35,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{C421
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{05CAF9B2-981E-40C0-AE31-5FA56E351F12}"
 	ProjectSection(SolutionItems) = preProject
+		.github\workflows\branches-ubuntu.yml = .github\workflows\branches-ubuntu.yml
 		.github\workflows\branches.yml = .github\workflows\branches.yml
 		.github\workflows\main.yml = .github\workflows\main.yml
 	EndProjectSection

From 61b8adc7e5be81ae006fe16db2becaea42d50644 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 14:35:10 +0100
Subject: [PATCH 176/455] ignore all branches

---
 .github/workflows/branches.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index d88c4a2b..dbda74a2 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -1,5 +1,8 @@
 name: Branch workflow
-on: []
+on:
+  push:
+    branches-ignore:
+      - **
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From fc167577510855aa1c1514d96ee0e80c529ce007 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 14:36:02 +0100
Subject: [PATCH 177/455] put colons around wildcard

---
 .github/workflows/branches.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index dbda74a2..430b2121 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -2,7 +2,7 @@ name: Branch workflow
 on:
   push:
     branches-ignore:
-      - **
+      - '**'
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From cd41f4b93ac07e2ae87d46a9919cb79a534b188a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 15:01:53 +0100
Subject: [PATCH 178/455] fix connection status test

---
 .../WebsocketTests/Base.cs                    | 94 ++++++++++---------
 1 file changed, 50 insertions(+), 44 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index b17ba3c0..6112a00c 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -1,8 +1,8 @@
 using System;
+using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
-using System.Threading.Tasks;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
@@ -247,49 +247,55 @@ public async void CanHandleConnectionTimeout() {
 				return TimeSpan.Zero;
 			};
 
-			var statusMonitor = client.WebsocketConnectionState.Monitor();
-			statusMonitor.Should().HaveReceivedPayload().Which.Should()
-				.Be(GraphQLWebsocketConnectionState.Disconnected);
-
-			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, errorMonitor.Invoke);
-
-			Debug.WriteLine("subscribing...");
-			var tester = observable.Monitor();
-			statusMonitor.Should().HaveReceivedPayload().Which.Should()
-				.Be(GraphQLWebsocketConnectionState.Connecting);
-			statusMonitor.Should().HaveReceivedPayload().Which.Should()
-				.Be(GraphQLWebsocketConnectionState.Connected);
-			callbackMonitor.Should().HaveBeenInvokedWithPayload();
-			const string message1 = "Hello World";
-
-			var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-			response.Data.AddMessage.Content.Should().Be(message1);
-			tester.Should().HaveReceivedPayload()
-				.Which.Data.MessageAdded.Content.Should().Be(message1);
-
-			Debug.WriteLine("stopping web host...");
-			await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
-			server.Dispose();
-			Debug.WriteLine("web host stopped...");
-
-			errorMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10))
-				.Which.Should().BeOfType<WebSocketException>();
-			statusMonitor.Should().HaveReceivedPayload().Which.Should()
-				.Be(GraphQLWebsocketConnectionState.Disconnected);
-
-			server = CreateServer(port);
-			reconnectBlocker.Set();
-			statusMonitor.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10)).Which.Should()
-				.Be(GraphQLWebsocketConnectionState.Connecting);
-			statusMonitor.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10)).Which.Should()
-				.Be(GraphQLWebsocketConnectionState.Connected);
-			callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-			// disposing the client should complete the subscription
-			client.Dispose();
-			tester.Should().HaveCompleted(TimeSpan.FromSeconds(5));
-			server.Dispose();
+			var websocketStates = new ConcurrentQueue<GraphQLWebsocketConnectionState>();
+
+			using (client.WebsocketConnectionState.Subscribe(websocketStates.Enqueue)) {
+				websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable =
+					client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest,
+						errorMonitor.Invoke);
+
+				Debug.WriteLine("subscribing...");
+				var tester = observable.Monitor();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+				websocketStates.Should().ContainInOrder(
+					GraphQLWebsocketConnectionState.Disconnected,
+					GraphQLWebsocketConnectionState.Connecting,
+					GraphQLWebsocketConnectionState.Connected);
+				// clear the collection so the next tests on the collection work as expected
+				websocketStates.Clear();
+
+				const string message1 = "Hello World";
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				response.Data.AddMessage.Content.Should().Be(message1);
+				tester.Should().HaveReceivedPayload()
+					.Which.Data.MessageAdded.Content.Should().Be(message1);
+
+				Debug.WriteLine("stopping web host...");
+				await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
+				server.Dispose();
+				Debug.WriteLine("web host stopped...");
+
+				errorMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10))
+					.Which.Should().BeOfType<WebSocketException>();
+				websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
+
+				server = CreateServer(port);
+				reconnectBlocker.Set();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload();
+				websocketStates.Should().ContainInOrder(
+					GraphQLWebsocketConnectionState.Disconnected,
+					GraphQLWebsocketConnectionState.Connecting,
+					GraphQLWebsocketConnectionState.Connected);
+
+				// disposing the client should complete the subscription
+				client.Dispose();
+				tester.Should().HaveCompleted(TimeSpan.FromSeconds(5));
+				server.Dispose();
+			}
 		}
 
 

From 34b7d03ba2419186060176fe93fd14d130493bb9 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 15:23:56 +0100
Subject: [PATCH 179/455] test publish job on branch workflow

---
 .github/workflows/branches-ubuntu.yml | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 488f6596..1f420844 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -68,3 +68,22 @@ jobs:
       run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
     - name: Run tests
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release
+
+  publish:
+    name: Publish
+    needs: [test]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Download nuget packages
+      uses: actions/download-artifact@v1
+      with:
+        name: nupkg
+    - uses: actions/setup-dotnet@v1
+      with:
+        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+    - name: Publish the package to GPR
+      run: dotnet nuget push ./nupkg/*.nupkg -k ${{secrets.GITHUB_TOKEN}}

From 76c1be9459caccc3d79163b82de14f3926c09d3d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 15:43:28 +0100
Subject: [PATCH 180/455] fix publish job to publish all packages

---
 .github/workflows/branches-ubuntu.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 1f420844..931976da 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -80,10 +80,11 @@ jobs:
       uses: actions/download-artifact@v1
       with:
         name: nupkg
+        path: ./
     - uses: actions/setup-dotnet@v1
       with:
         source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: Publish the package to GPR
-      run: dotnet nuget push ./nupkg/*.nupkg -k ${{secrets.GITHUB_TOKEN}}
+      run: dotnet nuget push *.nupkg -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate

From 33b99e97541b0c26034fc2e49cbb513c893c68e8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 16:05:48 +0100
Subject: [PATCH 181/455] use for loop to publish packages

---
 .github/workflows/branches-ubuntu.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 931976da..31b1d511 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -80,11 +80,10 @@ jobs:
       uses: actions/download-artifact@v1
       with:
         name: nupkg
-        path: ./
     - uses: actions/setup-dotnet@v1
       with:
         source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: Publish the package to GPR
-      run: dotnet nuget push *.nupkg -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate
+      run: for pkg in ./nupkg/*.nupkg; do dotnet nuget push *.nupkg -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate; done

From 00a4875ed4db8d62458fa06efc35f585e40bbd97 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 16:06:33 +0100
Subject: [PATCH 182/455] fix for loop

---
 .github/workflows/branches-ubuntu.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 31b1d511..c5c79ee1 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -86,4 +86,4 @@ jobs:
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: Publish the package to GPR
-      run: for pkg in ./nupkg/*.nupkg; do dotnet nuget push *.nupkg -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate; done
+      run: for p in ./nupkg/*.nupkg; do dotnet nuget push $p -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate; done

From cb59c7476f6235cbbe53ecacf1f4d6b5a55a18bc Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 16:18:03 +0100
Subject: [PATCH 183/455] enable continuous deployment mode for all branches

---
 GitVersion.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/GitVersion.yml b/GitVersion.yml
index 4b1b821f..2210324b 100644
--- a/GitVersion.yml
+++ b/GitVersion.yml
@@ -1,3 +1 @@
-branches:   
-  release:
-    mode: ContinuousDeployment
+mode: ContinuousDeployment

From d5e313cf26b0a25e957de158f479b90402aa1b5e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 16:38:40 +0100
Subject: [PATCH 184/455] create main workflow for ubuntu

---
 .../{branches.yml => branches-windows.yml}    |  0
 .github/workflows/main-ubuntu.yml             | 92 +++++++++++++++++++
 .../workflows/{main.yml => main-windows.yml}  | 11 +--
 3 files changed, 95 insertions(+), 8 deletions(-)
 rename .github/workflows/{branches.yml => branches-windows.yml} (100%)
 create mode 100644 .github/workflows/main-ubuntu.yml
 rename .github/workflows/{main.yml => main-windows.yml} (96%)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches-windows.yml
similarity index 100%
rename from .github/workflows/branches.yml
rename to .github/workflows/branches-windows.yml
diff --git a/.github/workflows/main-ubuntu.yml b/.github/workflows/main-ubuntu.yml
new file mode 100644
index 00000000..2cbffd4e
--- /dev/null
+++ b/.github/workflows/main-ubuntu.yml
@@ -0,0 +1,92 @@
+name: Main workflow (Ubuntu)
+on: 
+  push:
+    branches:
+      - develop
+      - 'release/**'
+      - 'releases/**'
+    tags:        
+      - v*
+      - V*
+env:
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+jobs:
+  generateVersionInfo:  
+    name: GenerateVersionInfo
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - name: Restore dotnet tools
+      run: dotnet tool restore
+    - name: Fetch complete repository 
+      run: git fetch
+    - name: Generate version info from git history
+      run: dotnet gitversion /output json > gitversion.json
+    - name: Upload version info file
+      uses: actions/upload-artifact@v1
+      with:
+        name: gitversion
+        path: gitversion.json
+
+  build:
+    name: Build
+    needs: generateVersionInfo
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Download version info file
+      uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+        path: ./
+    - name: Inject version info into environment
+      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
+    - name: Build solution
+      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
+    - name: Create NuGet packages
+      run: dotnet pack -c Release --no-build -o nupkg 
+    - name: Upload nuget packages
+      uses: actions/upload-artifact@v1
+      with:
+        name: nupkg
+        path: nupkg
+
+  test:
+    name: Test
+    needs: [build, generateVersionInfo]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Download version info file
+      uses: actions/download-artifact@v1
+      with:
+        name: gitversion
+        path: ./
+    - name: Inject version info into environment
+      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
+    - name: Run tests
+      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release
+
+  publish:
+    name: Publish
+    needs: [test]
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Download nuget packages
+      uses: actions/download-artifact@v1
+      with:
+        name: nupkg
+    - uses: actions/setup-dotnet@v1
+      with:
+        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+    - name: Publish the package to GPR
+      run: for p in ./nupkg/*.nupkg; do dotnet nuget push $p -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate; done
diff --git a/.github/workflows/main.yml b/.github/workflows/main-windows.yml
similarity index 96%
rename from .github/workflows/main.yml
rename to .github/workflows/main-windows.yml
index 2ed05127..8ab30600 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main-windows.yml
@@ -1,13 +1,8 @@
 name: Main workflow
-on: 
+on:
   push:
-    branches:
-      - develop
-      - 'release/**'
-      - 'releases/**'
-    tags:        
-      - v*
-      - V*
+    branches-ignore:
+      - '**'
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From 35052f60d9be25146290e9c82ea78a1862d1da96 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 19 Feb 2020 16:56:22 +0100
Subject: [PATCH 185/455] cd into nupkg dir

---
 .github/workflows/branches-ubuntu.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index c5c79ee1..9ec4e076 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -86,4 +86,4 @@ jobs:
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: Publish the package to GPR
-      run: for p in ./nupkg/*.nupkg; do dotnet nuget push $p -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate; done
+      run: cd ./nupkg && dotnet nuget push *.nupkg -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate

From 3ac99ef0bae0580be59665258a41207bd4d8efc0 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 20 Feb 2020 09:46:26 +0100
Subject: [PATCH 186/455] try package upload workaround

---
 .github/workflows/branches-ubuntu.yml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 9ec4e076..747b0e35 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -86,4 +86,8 @@ jobs:
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: Publish the package to GPR
-      run: cd ./nupkg && dotnet nuget push *.nupkg -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate
+      run: |
+           for f in ./nupkg/*.nupkg
+           do
+             curl -vX PUT -u "graphql-dotnet:${{ secrets.GHPackagesToken }}" -F package=@$f https://nuget.pkg.github.com/graphql-dotnet/
+           done

From 94f9cb7a151aca5ff9226cc7ae9eb70b9a09bd06 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 20 Feb 2020 09:47:14 +0100
Subject: [PATCH 187/455] fix secret

---
 .github/workflows/branches-ubuntu.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 747b0e35..059ca0c9 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -89,5 +89,5 @@ jobs:
       run: |
            for f in ./nupkg/*.nupkg
            do
-             curl -vX PUT -u "graphql-dotnet:${{ secrets.GHPackagesToken }}" -F package=@$f https://nuget.pkg.github.com/graphql-dotnet/
+             curl -vX PUT -u "graphql-dotnet:${{secrets.GITHUB_TOKEN}}" -F package=@$f https://nuget.pkg.github.com/graphql-dotnet/
            done

From 43e8201ee3a1c17ed157ace229980eda89664b1f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 20 Feb 2020 09:54:06 +0100
Subject: [PATCH 188/455] move publish step to main workflow

---
 .github/workflows/branches-ubuntu.yml | 23 -----------------------
 .github/workflows/main-ubuntu.yml     | 14 +++++++-------
 2 files changed, 7 insertions(+), 30 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 059ca0c9..488f6596 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -68,26 +68,3 @@ jobs:
       run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
     - name: Run tests
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release
-
-  publish:
-    name: Publish
-    needs: [test]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Download nuget packages
-      uses: actions/download-artifact@v1
-      with:
-        name: nupkg
-    - uses: actions/setup-dotnet@v1
-      with:
-        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-    - name: Publish the package to GPR
-      run: |
-           for f in ./nupkg/*.nupkg
-           do
-             curl -vX PUT -u "graphql-dotnet:${{secrets.GITHUB_TOKEN}}" -F package=@$f https://nuget.pkg.github.com/graphql-dotnet/
-           done
diff --git a/.github/workflows/main-ubuntu.yml b/.github/workflows/main-ubuntu.yml
index 2cbffd4e..bb58dcff 100644
--- a/.github/workflows/main-ubuntu.yml
+++ b/.github/workflows/main-ubuntu.yml
@@ -83,10 +83,10 @@ jobs:
       uses: actions/download-artifact@v1
       with:
         name: nupkg
-    - uses: actions/setup-dotnet@v1
-      with:
-        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
-      env:
-        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-    - name: Publish the package to GPR
-      run: for p in ./nupkg/*.nupkg; do dotnet nuget push $p -k ${{secrets.GITHUB_TOKEN}} --skip-duplicate; done
+    - name: Publish the package to GPR    
+    # using workaround with CURL because of non-functioning upload via dotnet nuget (https://stackoverflow.com/a/58943251)
+      run: |
+           for f in ./nupkg/*.nupkg
+           do
+             curl -vX PUT -u "graphql-dotnet:${{secrets.GITHUB_TOKEN}}" -F package=@$f https://nuget.pkg.github.com/graphql-dotnet/
+           done

From 292e7c6edecb9032c6ceb3f00345ed84fc6051e9 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Feb 2020 08:56:12 +0100
Subject: [PATCH 189/455] make README example consistent with example project,
 fix default serializer

---
 GraphQL.Client.sln                            | 21 ++---
 README.md                                     | 92 ++++++++++---------
 .../GraphQL.Client.Example.csproj}            |  5 -
 .../PersonAndFilmsResponse.cs                 | 21 +++++
 examples/GraphQL.Client.Example/Program.cs    | 49 ++++++++++
 .../GraphQL.Client.Http.Examples/Program.cs   | 41 ---------
 src/GraphQL.Client/GraphQLHttpClient.cs       |  8 +-
 7 files changed, 132 insertions(+), 105 deletions(-)
 rename examples/{GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj => GraphQL.Client.Example/GraphQL.Client.Example.csproj} (60%)
 create mode 100644 examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
 create mode 100644 examples/GraphQL.Client.Example/Program.cs
 delete mode 100644 examples/GraphQL.Client.Http.Examples/Program.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index e1943dde..24ea23a4 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -31,8 +31,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "assets", "assets", "{6326E0
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Server.Test", "tests\GraphQL.Server.Test\GraphQL.Server.Test.csproj", "{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{C42106CF-F685-4F29-BC18-A70616BD68A0}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{05CAF9B2-981E-40C0-AE31-5FA56E351F12}"
 	ProjectSection(SolutionItems) = preProject
 		.github\workflows\branches-ubuntu.yml = .github\workflows\branches-ubuntu.yml
@@ -40,10 +38,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{
 		.github\workflows\main.yml = .github\workflows\main.yml
 	EndProjectSection
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{D61415CA-D822-43DD-9AE7-993B8B60E855}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Http.Examples", "examples\GraphQL.Client.Http.Examples\GraphQL.Client.Http.Examples.csproj", "{95D78D57-3232-491D-BAD6-F373D76EA34D}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Primitives", "src\GraphQL.Primitives\GraphQL.Primitives.csproj", "{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Primitives.Tests", "tests\GraphQL.Primitives.Tests\GraphQL.Primitives.Tests.csproj", "{C212983F-67DB-44EB-BFB0-5DA75A86DF55}"
@@ -68,6 +62,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Tests.Common
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.SystemTextJson", "src\GraphQL.Client.Serializer.SystemTextJson\GraphQL.Client.Serializer.SystemTextJson.csproj", "{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{89AD33AB-64F6-4F82-822F-21DF7A10CEC0}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Example", "examples\GraphQL.Client.Example\GraphQL.Client.Example.csproj", "{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -78,10 +76,6 @@ Global
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3}.Release|Any CPU.Build.0 = Release|Any CPU
-		{95D78D57-3232-491D-BAD6-F373D76EA34D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{95D78D57-3232-491D-BAD6-F373D76EA34D}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{95D78D57-3232-491D-BAD6-F373D76EA34D}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{95D78D57-3232-491D-BAD6-F373D76EA34D}.Release|Any CPU.Build.0 = Release|Any CPU
 		{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -130,14 +124,16 @@ Global
 		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
-		{05CAF9B2-981E-40C0-AE31-5FA56E351F12} = {C42106CF-F685-4F29-BC18-A70616BD68A0}
-		{95D78D57-3232-491D-BAD6-F373D76EA34D} = {D61415CA-D822-43DD-9AE7-993B8B60E855}
 		{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{C212983F-67DB-44EB-BFB0-5DA75A86DF55} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{92107DF5-73DF-4371-8EB1-6734FED704AD} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
@@ -150,6 +146,7 @@ Global
 		{CA842D18-FC4A-4281-B1FF-080FA91887B8} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
+		{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD} = {89AD33AB-64F6-4F82-822F-21DF7A10CEC0}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/README.md b/README.md
index 95d46939..02f6dee7 100644
--- a/README.md
+++ b/README.md
@@ -16,66 +16,76 @@ The Library will try to follow the following standards and documents:
 ```csharp
 var heroRequest = new GraphQLRequest {
     Query = @"
-	{
-		hero {
-			name
-		}
-	}"
+    {
+        hero {
+            name
+        }
+    }"
 };
 ```
 
 #### OperationName and Variables Request:
+
 ```csharp
-var heroAndFriendsRequest = new GraphQLRequest {
+var personAndFilmsRequest = new GraphQLRequest {
     Query =@"
-	query HeroNameAndFriends($episode: Episode) {
-		hero(episode: $episode) {
-			name
-			friends {
-				name
-			}
-		}
-	}",
-	OperationName = "HeroNameAndFriends",
-	Variables = new {
-		episode = "JEDI"
-	}
+    query PersonAndFilms($id: ID) {
+        person(id: $id) {
+            name
+            filmConnection {
+                films {
+                    title
+                }
+            }
+        }
+    }",
+    OperationName = "PersonAndFilms",
+    Variables = new {
+        id = "cGVvcGxlOjE="
+    }
 };
 ```
 
 Be careful when using `byte[]` in your variables object, as most JSON serializers will treat that as binary data! If you really need to send a *list of bytes* with a `byte[]` as a source, then convert it to a `List<byte>` first, which will tell the serializer to output a list of numbers instead of a base64-encoded string.
 
 ### Execute Query/Mutation:
+
 ```csharp
 var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
 
-public class HeroAndFriendsResponse {
-    public Hero Hero {get; set;}
+public class PersonAndFilmsResponse {
+    public PersonContent Person { get; set; }
 
-    public class Hero {
-        public string Name {get; set;}
+    public class PersonContent {
+        public string Name { get; set; }
+        public FilmConnectionContent FilmConnection { get; set; }
 
-        public List<Hero> Friends {get; set;}
+        public class FilmConnectionContent {
+            public List<FilmContent> Films { get; set; }
+
+            public class FilmContent {
+                public string Title { get; set; }
+            }
+        }
     }
 }
 
-var graphQLResponse = await graphQLClient.SendQueryAsync<HeroAndFriendsResponse>(heroAndFriendsRequest);
+var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
 
-var heroName = graphQLResponse.Data.Hero.Name;
+var personName = graphQLResponse.Data.Person.Name;
 ```
 
 
-
 ### Use Subscriptions
 
 ```csharp
 public class UserJoinedSubscriptionResult {
-	public ChatUser UserJoined { get; set; }
+    public ChatUser UserJoined { get; set; }
 
-	public class ChatUser {
-		public string DisplayName { get; set; }
-		public string Id { get; set; }
-	}
+    public class ChatUser {
+        public string DisplayName { get; set; }
+        public string Id { get; set; }
+    }
 }
 ```
 
@@ -84,21 +94,21 @@ public class UserJoinedSubscriptionResult {
 ```csharp
 var userJoinedRequest = new GraphQLRequest {
     Query = @"
-	subscription {
-		userJoined{
-			displayName
-			id
-		}
-	}"
+    subscription {
+        userJoined{
+            displayName
+            id
+        }
+    }"
 };
 
 IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> subscriptionStream 
-	= client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(userJoinedRequest);
+    = client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(userJoinedRequest);
 
 var subscription = subscriptionStream.Subscribe(response => 
-	{
-		Console.WriteLine($"user '{response.Data.UserJoined.DisplayName}' joined")
-	});
+    {
+        Console.WriteLine($"user '{response.Data.UserJoined.DisplayName}' joined")
+    });
 ```
 
 #### End Subscription
diff --git a/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
similarity index 60%
rename from examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
rename to examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index 2f2dea3c..d9680f86 100644
--- a/examples/GraphQL.Client.Http.Examples/GraphQL.Client.Http.Examples.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -6,13 +6,8 @@
 		<IsPackable>false</IsPackable>
 	</PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="Microsoft.AspNetCore.TestHost" Version="3.1.0" />
-	</ItemGroup>
-
 	<ItemGroup>
 		<ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
-		<ProjectReference Include="..\..\tests\GraphQL.Server.Test\GraphQL.Server.Test.csproj" />
 	</ItemGroup>
 
 </Project>
diff --git a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
new file mode 100644
index 00000000..a9ef5a9b
--- /dev/null
+++ b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace GraphQL.Client.Http.Examples
+{
+	public class PersonAndFilmsResponse {
+		public PersonContent Person { get; set; }
+
+		public class PersonContent {
+			public string Name { get; set; }
+			public FilmConnectionContent FilmConnection { get; set; }
+
+			public class FilmConnectionContent {
+				public List<FilmContent> Films { get; set; }
+
+				public class FilmContent {
+					public string Title { get; set; }
+				}
+			}
+		}
+	}
+}
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
new file mode 100644
index 00000000..41443afd
--- /dev/null
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using GraphQL.Client.Serializer.Newtonsoft;
+
+namespace GraphQL.Client.Http.Examples {
+
+	public class Program {
+
+		public static async Task Main(string[] args) {
+
+			var serializer = new NewtonsoftJsonSerializer();
+			using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
+
+			var personAndFilmsRequest = new GraphQLRequest {
+				Query = @"
+			    query PersonAndFilms($id: ID) {
+			        person(id: $id) {
+			            name
+			            filmConnection {
+			                films {
+			                    title
+			                }
+			            }
+			        }
+			    }",
+				OperationName = "PersonAndFilms",
+				Variables = new {
+					id = "cGVvcGxlOjE="
+				}
+			};
+
+			var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
+			Console.WriteLine("raw response:");
+			Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
+
+			Console.WriteLine();
+			Console.WriteLine($"Name: {graphQLResponse.Data.Person.Name}" );
+			var films = string.Join(", ", graphQLResponse.Data.Person.FilmConnection.Films.Select(f => f.Title));
+			Console.WriteLine($"Films: {films}");
+
+			Console.WriteLine();
+			Console.WriteLine("Press any key to quit...");
+			Console.ReadKey();
+		}
+
+	}
+}
diff --git a/examples/GraphQL.Client.Http.Examples/Program.cs b/examples/GraphQL.Client.Http.Examples/Program.cs
deleted file mode 100644
index 0cce0283..00000000
--- a/examples/GraphQL.Client.Http.Examples/Program.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using System;
-using System.Text.Json;
-using System.Threading.Tasks;
-using GraphQL.Server.Test.GraphQL.Models;
-using Microsoft.AspNetCore.TestHost;
-
-namespace GraphQL.Client.Http.Examples {
-
-	public class Program {
-
-		private static readonly TestServer testServer = new TestServer(Server.Test.Program.CreateHostBuilder()) {
-			AllowSynchronousIO = true
-		};
-
-		public static async Task Main(string[] args) {
-			using var httpClient = testServer.CreateClient();
-			using var graphqlClient = httpClient.AsGraphQLClient($"{testServer.BaseAddress}graphql");
-			var graphQLRequest = new GraphQLRequest(
-				@"
-					{
-						repository(owner: ""graphql-dotnet"", name: ""graphql-client"") {
-							databaseId,
-						    id,
-						    name,
-						    url
-						}
-					}"
-			);
-			var graphQLResponse = await graphqlClient.SendQueryAsync<Schema>(graphQLRequest);
-			Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
-		}
-
-		private class Schema {
-
-			public Repository Repository { get; set; }
-
-		}
-
-	}
-
-}
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index dbf4bcb7..eb25ebc0 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -7,6 +7,7 @@
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
+using GraphQL.Client.Serializer.Newtonsoft;
 
 namespace GraphQL.Client.Http {
 
@@ -48,12 +49,7 @@ public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) : this(conf
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options) : this(options, new HttpClient(options.HttpMessageHandler)) { }
 
-		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) {
-			Options = options;
-			this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
-			Options.JsonSerializer = JsonSerializer.EnsureAssigned();
-		}
+		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) : this(options, httpClient, new NewtonsoftJsonSerializer()) { }
 
 		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer) {
 			Options = options ?? throw new ArgumentNullException(nameof(options));

From fec61b3d53366b5148b14036bdfaa1141f3b2b8a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Feb 2020 10:24:48 +0100
Subject: [PATCH 190/455] remove unnecessary code in example

---
 examples/GraphQL.Client.Example/Program.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index 41443afd..a7cc00fe 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -10,7 +10,6 @@ public class Program {
 
 		public static async Task Main(string[] args) {
 
-			var serializer = new NewtonsoftJsonSerializer();
 			using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
 
 			var personAndFilmsRequest = new GraphQLRequest {

From 049ed1a856ddc307f353e85a53297b0d45f588b1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Feb 2020 11:09:20 +0100
Subject: [PATCH 191/455] create tests to cover request cancellation ( #140)

---
 .../Chat/Schema/ChatQuery.cs                  |  9 ++++++++
 .../QueryAndMutationTests/Base.cs             | 21 +++++++++++++++++++
 .../WebsocketTests/Base.cs                    | 19 ++++++++++++++++-
 3 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 32357338..641ca262 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -1,5 +1,7 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using GraphQL.Types;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema {
@@ -21,6 +23,13 @@ public ChatQuery(IChat chat) {
 					context.Errors.Add(new ExecutionError("this error contains extension fields", TestExtensions));
 					return null;
 				});
+
+			Field<StringGraphType>()
+				.Name("longRunning")
+				.ResolveAsync(async context => {
+					await Task.Delay(TimeSpan.FromSeconds(5));
+					return "finally returned";
+				});
 		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 16e73c92..39380ea4 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -1,4 +1,8 @@
+using System;
 using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
@@ -155,5 +159,22 @@ public async void PreprocessHttpRequestMessageIsCalled() {
 				Assert.Equal("Luke", response.Data.Human.Name);
 			}
 		}
+
+		[Fact]
+		public void PostRequestCanBeCancelled() {
+			var graphQLRequest = new GraphQLRequest(@"
+				query Long {
+					longRunning
+				}");
+
+			using (var setup = WebHostHelpers.SetupTest<StartupChat>(false, serializer)) {
+				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+
+				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new {longRunning = string.Empty}, cts.Token);
+				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();
+
+				timeMeasurement.ExecutionTime().Should().BeCloseTo(TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(200));
+			}
+		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 6112a00c..1e4d0903 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using System.Net.WebSockets;
 using System.Threading;
+using System.Threading.Tasks;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
@@ -38,7 +39,6 @@ public async void AssertTestingHarness() {
 			}
 		}
 
-
 		[Fact]
 		public async void CanSendRequestViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
@@ -51,6 +51,23 @@ public async void CanSendRequestViaWebsocket() {
 			}
 		}
 
+		[Fact]
+		public void PostRequestCanBeCancelled() {
+			var graphQLRequest = new GraphQLRequest(@"
+				query Long {
+					longRunning
+				}");
+
+			using (var setup = WebHostHelpers.SetupTest<StartupChat>(true, Serializer)) {
+				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+
+				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token);
+				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();
+
+				timeMeasurement.ExecutionTime().Should().BeCloseTo(TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(200));
+			}
+		}
+
 		[Fact]
 		public async void CanHandleRequestErrorViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();

From af1024720889f293c8a45c32b35e3c6aaea81555 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Feb 2020 11:28:52 +0100
Subject: [PATCH 192/455] speed up cancellation tests

---
 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs | 2 +-
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs        | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 39380ea4..18a0e43f 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -168,7 +168,7 @@ query Long {
 				}");
 
 			using (var setup = WebHostHelpers.SetupTest<StartupChat>(false, serializer)) {
-				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
 
 				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new {longRunning = string.Empty}, cts.Token);
 				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 1e4d0903..b3aaf95f 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -52,14 +52,14 @@ public async void CanSendRequestViaWebsocket() {
 		}
 
 		[Fact]
-		public void PostRequestCanBeCancelled() {
+		public void WebsocketRequestCanBeCancelled() {
 			var graphQLRequest = new GraphQLRequest(@"
 				query Long {
 					longRunning
 				}");
 
 			using (var setup = WebHostHelpers.SetupTest<StartupChat>(true, Serializer)) {
-				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
 
 				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token);
 				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();

From a0e9a16fdb7b1513ccb69e80b74289338e8a053c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Feb 2020 12:21:40 +0100
Subject: [PATCH 193/455] fix expected execution time

---
 .../QueryAndMutationTests/Base.cs                          | 5 +++--
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs     | 7 ++++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 18a0e43f..304e2982 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -168,12 +168,13 @@ query Long {
 				}");
 
 			using (var setup = WebHostHelpers.SetupTest<StartupChat>(false, serializer)) {
-				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
+				var cancellationTimeout = TimeSpan.FromSeconds(1);
+				var cts = new CancellationTokenSource(cancellationTimeout);
 
 				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new {longRunning = string.Empty}, cts.Token);
 				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();
 
-				timeMeasurement.ExecutionTime().Should().BeCloseTo(TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(200));
+				timeMeasurement.ExecutionTime().Should().BeCloseTo(cancellationTimeout, TimeSpan.FromMilliseconds(50));
 			}
 		}
 	}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index b3aaf95f..77045a92 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -59,12 +59,13 @@ query Long {
 				}");
 
 			using (var setup = WebHostHelpers.SetupTest<StartupChat>(true, Serializer)) {
-				var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
+				var cancellationTimeout = TimeSpan.FromSeconds(1);
+				var cts = new CancellationTokenSource(cancellationTimeout);
 
-				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token);
+				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new {longRunning = string.Empty}, cts.Token);
 				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();
 
-				timeMeasurement.ExecutionTime().Should().BeCloseTo(TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(200));
+				timeMeasurement.ExecutionTime().Should().BeCloseTo(cancellationTimeout, TimeSpan.FromMilliseconds(50));
 			}
 		}
 

From 62afa73705e49f2c5bc55e27691f1ae010024ea4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 25 Feb 2020 15:41:26 +0100
Subject: [PATCH 194/455] fix cancellation test

---
 .../Chat/Schema/ChatQuery.cs                  | 14 +++--
 .../Helpers/ConcurrentTaskWrapper.cs          | 54 +++++++++++++++++++
 .../GraphQL.Integration.Tests.csproj          |  1 +
 .../WebsocketTests/Base.cs                    | 48 +++++++++++++----
 4 files changed, 105 insertions(+), 12 deletions(-)
 create mode 100644 tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs

diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 641ca262..0816fd8c 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
+using System.Threading;
 using GraphQL.Types;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema {
@@ -12,6 +12,12 @@ public class ChatQuery : ObjectGraphType {
 			{"another extension", 4711}
 		};
 
+		// properties for unit testing
+
+		public readonly ManualResetEventSlim LongRunningQueryBlocker = new ManualResetEventSlim();
+		public readonly ManualResetEventSlim WaitingOnQueryBlocker = new ManualResetEventSlim();
+
+
 		public ChatQuery(IChat chat) {
 			Name = "ChatQuery";
 
@@ -26,8 +32,10 @@ public ChatQuery(IChat chat) {
 
 			Field<StringGraphType>()
 				.Name("longRunning")
-				.ResolveAsync(async context => {
-					await Task.Delay(TimeSpan.FromSeconds(5));
+				.Resolve(context => {
+					WaitingOnQueryBlocker.Set();
+					LongRunningQueryBlocker.Wait();
+					WaitingOnQueryBlocker.Reset();
 					return "finally returned";
 				});
 		}
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
new file mode 100644
index 00000000..64ea0554
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Threading.Tasks;
+
+namespace GraphQL.Client.Tests.Common.Helpers {
+
+	public class ConcurrentTaskWrapper {
+		public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) {
+			return  new ConcurrentTaskWrapper<TResult>(createTask);
+		}
+
+		private readonly Func<Task> createTask;
+		private Task internalTask = null;
+
+		public ConcurrentTaskWrapper(Func<Task> createTask) {
+			this.createTask = createTask;
+		}
+
+		public Task Invoke() {
+			if (internalTask != null)
+				return internalTask;
+
+			return internalTask = createTask();
+		}
+	}
+
+	public class ConcurrentTaskWrapper<TResult> {
+		private readonly Func<Task<TResult>> createTask;
+		private Task<TResult> internalTask = null;
+
+		public ConcurrentTaskWrapper(Func<Task<TResult>> createTask) {
+			this.createTask = createTask;
+		}
+
+		public Task<TResult> Invoke() {
+			if (internalTask != null)
+				return internalTask;
+
+			return internalTask = createTask();
+		}
+
+		public void Start() {
+			if (internalTask == null)
+				internalTask = createTask();
+		}
+
+		public Func<Task<TResult>> Invoking() {
+			return Invoke;
+		}
+
+		public void Clear() {
+			internalTask = null;
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 3273adae..e2e2d726 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -10,6 +10,7 @@
     <PackageReference Include="FluentAssertions" Version="5.10.0" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="Microsoft.Reactive.Testing" Version="4.3.2" />
     <PackageReference Include="NETStandard.Library" Version="2.0.3" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 77045a92..0e1cfa6b 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -2,16 +2,22 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Net.WebSockets;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
+using FluentAssertions.Extensions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Tests.Common.Chat;
+using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
 using IntegrationTestServer;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Reactive.Testing;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -52,23 +58,47 @@ public async void CanSendRequestViaWebsocket() {
 		}
 
 		[Fact]
-		public void WebsocketRequestCanBeCancelled() {
+		public async void WebsocketRequestCanBeCancelled() {
 			var graphQLRequest = new GraphQLRequest(@"
 				query Long {
 					longRunning
 				}");
 
 			using (var setup = WebHostHelpers.SetupTest<StartupChat>(true, Serializer)) {
-				var cancellationTimeout = TimeSpan.FromSeconds(1);
-				var cts = new CancellationTokenSource(cancellationTimeout);
-
-				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new {longRunning = string.Empty}, cts.Token);
-				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();
-
-				timeMeasurement.ExecutionTime().Should().BeCloseTo(cancellationTimeout, TimeSpan.FromMilliseconds(50));
+				await setup.Client.InitializeWebsocketConnection();
+				var chatQuery = setup.Server.Services.GetService<ChatQuery>();
+				var cts = new CancellationTokenSource();
+
+				var request =
+					ConcurrentTaskWrapper.New(() => setup.Client.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
+
+				// Test regular request
+				// start request
+				request.Start();
+				// wait until the query has reached the server
+				chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+				// unblock the query
+				chatQuery.LongRunningQueryBlocker.Set();
+				// check execution time
+				request.Invoking().ExecutionTime().Should().BeLessThan(100.Milliseconds());
+				request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+
+				// reset stuff
+				chatQuery.LongRunningQueryBlocker.Reset();
+				request.Clear();
+
+				// cancellation test
+				request.Start();
+				chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+				cts.Cancel();
+				FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
+					.ExecutionTime().Should().BeLessThan(100.Milliseconds());
+
+				// let the server finish its query
+				chatQuery.LongRunningQueryBlocker.Set();
 			}
 		}
-
+		
 		[Fact]
 		public async void CanHandleRequestErrorViaWebsocket() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();

From 53761b1fee8f03e64240373ce277f10d9090e45b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 25 Feb 2020 19:03:09 +0100
Subject: [PATCH 195/455] use class fixtures, fix disposal of
 GraphQLHttpWebSocket

---
 src/GraphQL.Client/GraphQLHttpClient.cs       |   4 +-
 .../Websocket/GraphQLHttpWebSocket.cs         |  30 +-
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  |  10 +-
 .../Chat/Schema/IChat.cs                      |  50 +-
 tests/GraphQL.Client.Tests.Common/Common.cs   |  12 +-
 .../Helpers/IntegrationServerTestFixture.cs   |  58 +++
 .../Helpers/WebHostHelpers.cs                 |  44 +-
 .../QueryAndMutationTests/Base.cs             | 158 +++---
 .../QueryAndMutationTests/Newtonsoft.cs       |   6 +-
 .../QueryAndMutationTests/SystemTextJson.cs   |   6 +-
 .../WebsocketTests/Base.cs                    | 448 ++++++++----------
 .../WebsocketTests/Newtonsoft.cs              |   9 +-
 .../WebsocketTests/SystemTextJson.cs          |   7 +-
 tests/IntegrationTestServer/Program.cs        |   2 +-
 tests/IntegrationTestServer/Startup.cs        |  35 +-
 tests/IntegrationTestServer/StartupChat.cs    |  22 -
 .../IntegrationTestServer/StartupStarWars.cs  |  22 -
 17 files changed, 496 insertions(+), 427 deletions(-)
 create mode 100644 tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
 delete mode 100644 tests/IntegrationTestServer/StartupChat.cs
 delete mode 100644 tests/IntegrationTestServer/StartupStarWars.cs

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index eb25ebc0..a4da13c6 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Net.Http;
 using System.Text;
 using System.Threading;
@@ -164,9 +165,10 @@ public void Dispose() {
 
 		private void _dispose() {
 			disposed = true;
+			Debug.WriteLine($"disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
+			cancellationTokenSource.Cancel();
 			this.HttpClient.Dispose();
 			this.graphQlHttpWebSocket.Dispose();
-			cancellationTokenSource.Cancel();
 			cancellationTokenSource.Dispose();
 		}
 
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 832fb4cf..1f824c8e 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -17,6 +17,7 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly GraphQLHttpClient client;
 		private readonly ArraySegment<byte> buffer;
 		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+		private readonly CancellationToken cancellationToken;
 		private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
 		private readonly BehaviorSubject<GraphQLWebsocketConnectionState> stateSubject =
@@ -41,6 +42,7 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		public IObservable<WebsocketResponseWrapper> ResponseStream { get; }
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
+			cancellationToken = cancellationTokenSource.Token;
 			this.webSocketUri = webSocketUri;
 			this.client = client;
 			buffer = new ArraySegment<byte>(new byte[8192]);
@@ -59,7 +61,7 @@ public Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
 
 		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request) {
 			try {
-				if (cancellationTokenSource.Token.IsCancellationRequested) {
+				if (cancellationToken.IsCancellationRequested) {
 					request.SendCanceled();
 					return;
 				}
@@ -70,7 +72,7 @@ await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
 					true,
-					cancellationTokenSource.Token).ConfigureAwait(false);
+					cancellationToken).ConfigureAwait(false);
 				request.SendCompleted();
 			}
 			catch (Exception e) {
@@ -126,7 +128,7 @@ public Task InitializeWebSocket() {
 				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
 				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 #endif
-				return initializeWebSocketTask = _connectAsync(cancellationTokenSource.Token);
+				return initializeWebSocketTask = _connectAsync(cancellationToken);
 			}
 		}
 
@@ -172,6 +174,8 @@ private IObservable<WebsocketResponseWrapper> _createResponseStream() {
 		}
 
 		private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseWrapper> observer, CancellationToken token) {
+			cancellationToken.ThrowIfCancellationRequested();
+
 			if (responseSubject == null || responseSubject.IsDisposed) {
 				// create new response subject
 				responseSubject = new Subject<WebsocketResponseWrapper>();
@@ -200,7 +204,7 @@ private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseW
 			(
 				responseSubject.Subscribe(observer),
 				Disposable.Create(() => {
-					Debug.WriteLine("response stream disposed");
+					Debug.WriteLine($"response stream {responseSubject.GetHashCode()} disposed");
 				})
 			);
 		}
@@ -213,6 +217,7 @@ private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseW
 		/// <returns></returns>
 		private Task<WebsocketResponseWrapper> _getReceiveTask() {
 			lock (receiveTaskLocker) {
+				cancellationToken.ThrowIfCancellationRequested();
 				if (receiveAsyncTask == null ||
 					receiveAsyncTask.IsFaulted ||
 					receiveAsyncTask.IsCompleted)
@@ -233,13 +238,13 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 				using (var ms = new MemoryStream()) {
 					WebSocketReceiveResult webSocketReceiveResult = null;
 					do {
-						cancellationTokenSource.Token.ThrowIfCancellationRequested();
+						cancellationToken.ThrowIfCancellationRequested();
 						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
 						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
 					}
 					while (!webSocketReceiveResult.EndOfMessage);
 
-					cancellationTokenSource.Token.ThrowIfCancellationRequested();
+					cancellationToken.ThrowIfCancellationRequested();
 					ms.Seek(0, SeekOrigin.Begin);
 
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
@@ -258,7 +263,7 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 			}
 		}
 
-		private async Task _closeAsync(CancellationToken cancellationToken = default) {
+		private async Task _closeAsync() {
 			if (clientWebSocket == null)
 				return;
 
@@ -271,7 +276,7 @@ private async Task _closeAsync(CancellationToken cancellationToken = default) {
 			}
 
 			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false);
 			stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 		}
 
@@ -301,6 +306,15 @@ private async Task CompleteAsync() {
 			await _closeAsync().ConfigureAwait(false);
 			requestSubscription?.Dispose();
 			clientWebSocket?.Dispose();
+
+			responseSubject?.OnCompleted();
+			responseSubject?.Dispose();
+
+			stateSubject?.OnCompleted();
+			stateSubject?.Dispose();
+
+			exceptionSubject?.OnCompleted();
+			exceptionSubject?.Dispose();
 			cancellationTokenSource.Dispose();
 			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
 		}
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
index 9148a727..f4eeebd5 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -58,8 +58,14 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 										o.OnCompleted();
 									}
 								},
-								o.OnError,
-								o.OnCompleted)
+								e => {
+									Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
+									o.OnError(e);
+								},
+								() => {
+									Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+									o.OnCompleted();
+								})
 					);
 
 					try {
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index 2e31e8b4..6d53e42b 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -18,20 +18,25 @@ public interface IChat {
 	}
 
 	public class Chat : IChat {
-		private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+		private readonly RollingReplaySubject<Message> _messageStream = new RollingReplaySubject<Message>();
 		private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
 		public Chat() {
+			Reset();
+		}
+
+		public void Reset() {
 			AllMessages = new ConcurrentStack<Message>();
 			Users = new ConcurrentDictionary<string, string> {
 				["1"] = "developer",
 				["2"] = "tester"
 			};
+			_messageStream.Clear();
 		}
 
-		public ConcurrentDictionary<string, string> Users { get; set; }
+		public ConcurrentDictionary<string, string> Users { get; private set; }
 
-		public ConcurrentStack<Message> AllMessages { get; }
+		public ConcurrentStack<Message> AllMessages { get; private set; }
 
 		public Message AddMessage(ReceivedMessage message) {
 			if (!Users.TryGetValue(message.FromId, out var displayName)) {
@@ -90,4 +95,43 @@ public class User {
 		public string Id { get; set; }
 		public string Name { get; set; }
 	}
+
+	public class RollingReplaySubject<T> : ISubject<T> {
+		private readonly ReplaySubject<IObservable<T>> _subjects;
+		private readonly IObservable<T> _concatenatedSubjects;
+		private ISubject<T> _currentSubject;
+
+		public RollingReplaySubject() {
+			_subjects = new ReplaySubject<IObservable<T>>(1);
+			_concatenatedSubjects = _subjects.Concat();
+			_currentSubject = new ReplaySubject<T>();
+			_subjects.OnNext(_currentSubject);
+		}
+
+		public void Clear() {
+			_currentSubject.OnCompleted();
+			_currentSubject = new ReplaySubject<T>();
+			_subjects.OnNext(_currentSubject);
+		}
+
+		public void OnNext(T value) {
+			_currentSubject.OnNext(value);
+		}
+
+		public void OnError(Exception error) {
+			_currentSubject.OnError(error);
+		}
+
+		public void OnCompleted() {
+			_currentSubject.OnCompleted();
+			_subjects.OnCompleted();
+			// a quick way to make the current ReplaySubject unreachable
+			// except to in-flight observers, and not hold up collection
+			_currentSubject = new Subject<T>();
+		}
+
+		public IDisposable Subscribe(IObserver<T> observer) {
+			return _concatenatedSubjects.Subscribe(observer);
+		}
+	}
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
index e912d907..05673f23 100644
--- a/tests/GraphQL.Client.Tests.Common/Common.cs
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -5,9 +5,11 @@
 
 namespace GraphQL.Client.Tests.Common
 {
-    public static class Common
-    {
-	    public static StarWarsSchema GetStarWarsSchema() {
+    public static class Common {
+	    public const string StarWarsEndpoint = "/graphql/starwars";
+	    public const string ChatEndpoint = "/graphql/chat";
+
+		public static StarWarsSchema GetStarWarsSchema() {
 			var services = new ServiceCollection();
 			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
 			services.AddStarWarsSchema();
@@ -33,7 +35,9 @@ public static void AddStarWarsSchema(this IServiceCollection services) {
 		}
 		
 	    public static void AddChatSchema(this IServiceCollection services) {
-		    services.AddSingleton<IChat, Chat.Schema.Chat>();
+		    var chat = new Chat.Schema.Chat();
+		    services.AddSingleton(chat);
+		    services.AddSingleton<IChat>(chat);
 			services.AddSingleton<ChatSchema>();
 		    services.AddSingleton<ChatQuery>();
 		    services.AddSingleton<ChatMutation>();
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
new file mode 100644
index 00000000..3b20ccbe
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Threading.Tasks;
+using GraphQL.Client.Abstractions.Websocket;
+using GraphQL.Client.Http;
+using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Client.Serializer.SystemTextJson;
+using GraphQL.Client.Tests.Common;
+using GraphQL.Client.Tests.Common.Helpers;
+using Microsoft.AspNetCore.Hosting;
+
+namespace GraphQL.Integration.Tests.Helpers {
+	public abstract class IntegrationServerTestFixture {
+		public int Port { get; private set; }
+		public IWebHost Server { get; private set; }
+		public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
+
+		public IntegrationServerTestFixture()
+		{
+			Port = NetworkHelpers.GetFreeTcpPortNumber();
+			CreateServer();
+		}
+
+		public void CreateServer() {
+			if(Server != null)
+				throw new InvalidOperationException("server is already created");
+			Server = WebHostHelpers.CreateServer(Port);
+		}
+
+		public async Task ShutdownServer() {
+			if (Server == null)
+				return;
+
+			await Server.StopAsync();
+			Server.Dispose();
+			Server = null;
+		}
+
+		public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
+			=> GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
+
+		public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
+			=> GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
+
+		private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) {
+			if(Serializer == null)
+				throw new InvalidOperationException("JSON serializer not configured");
+			return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer);
+		}
+	}
+
+	public class NewtonsoftIntegrationServerTestFixture: IntegrationServerTestFixture {
+		public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new NewtonsoftJsonSerializer();
+	}
+
+	public class SystemTextJsonIntegrationServerTestFixture : IntegrationServerTestFixture {
+		public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 0ee54a08..59084c6f 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,9 +1,12 @@
 using System;
+using System.Reactive.Disposables;
 using GraphQL.Client;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Helpers;
+using IntegrationTestServer;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
@@ -12,7 +15,7 @@ namespace GraphQL.Integration.Tests.Helpers
 {
 	public static class WebHostHelpers
 	{
-		public static IWebHost CreateServer<TStartup>(int port) where TStartup : class
+		public static IWebHost CreateServer(int port)
 		{
 			var configBuilder = new ConfigurationBuilder();
 			configBuilder.AddInMemoryCollection();
@@ -25,41 +28,46 @@ public static IWebHost CreateServer<TStartup>(int port) where TStartup : class
 				})
 				.UseConfiguration(config)
 				.UseKestrel()
-				.UseStartup<TStartup>()
+				.UseStartup<Startup>()
 				.Build();
 
 			host.Start();
 
 			return host;
 		}
-
-
-		public static GraphQLHttpClient GetGraphQLClient(int port, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
+		
+		public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions {
-				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+				EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
 				UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
 				JsonSerializer = serializer ?? new NewtonsoftJsonSerializer()
 			});
-		
-		public static TestServerSetup SetupTest<TStartup>(bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
-			where TStartup : class
-		{
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			return new TestServerSetup {
-				Server = CreateServer<TStartup>(port),
-				Client = GetGraphQLClient(port, requestsViaWebsocket, serializer)
-			};
-		}
 	}
 
 	public class TestServerSetup : IDisposable
 	{
+		public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer) {
+			this.serializer = serializer;
+			Port = NetworkHelpers.GetFreeTcpPortNumber();
+		}
+
+		public int Port { get; }
 		public IWebHost Server { get; set; }
-		public GraphQLHttpClient Client { get; set; }
+		public IGraphQLWebsocketJsonSerializer serializer { get; set; }
+
+		public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
+			=> GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
+
+		public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
+			=> GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
+
+		private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) {
+			return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
+		}
+
 		public void Dispose()
 		{
 			Server?.Dispose();
-			Client?.Dispose();
 		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 304e2982..ea103901 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -1,41 +1,41 @@
-using System;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
+using FluentAssertions.Extensions;
 using GraphQL.Client.Abstractions;
-using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
+using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Client.Tests.Common.StarWars;
 using GraphQL.Integration.Tests.Helpers;
-using IntegrationTestServer;
+using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests {
 
 	public abstract class Base {
 
-		protected IGraphQLWebsocketJsonSerializer serializer;
+		protected IntegrationServerTestFixture Fixture;
+		protected GraphQLHttpClient StarWarsClient;
+		protected GraphQLHttpClient ChatClient;
 
-		private TestServerSetup SetupTest(bool requestsViaWebsocket = false) => WebHostHelpers.SetupTest<StartupStarWars>(requestsViaWebsocket, serializer);
-
-		protected Base(IGraphQLWebsocketJsonSerializer serializer) {
-			this.serializer = serializer;
+		protected Base(IntegrationServerTestFixture fixture) {
+			Fixture = fixture;
+			StarWarsClient = Fixture.GetStarWarsClient();
+			ChatClient = Fixture.GetChatClient();
 		}
-
+		
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
 		public async void QueryTheory(int id, string name) {
 			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
 
-			using (var setup = SetupTest()) {
-				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty }})
-					.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty }})
+				.ConfigureAwait(false);
 
-				Assert.Null(response.Errors);
-				Assert.Equal(name, response.Data.Human.Name);
-			}
+			Assert.Null(response.Errors);
+			Assert.Equal(name, response.Data.Human.Name);
 		}
 
 		[Theory]
@@ -43,13 +43,11 @@ public async void QueryTheory(int id, string name) {
 		public async void QueryWithDynamicReturnTypeTheory(int id, string name) {
 			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
 
-			using (var setup = SetupTest()) {
-				var response = await setup.Client.SendQueryAsync<dynamic>(graphQLRequest)
-					.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync<dynamic>(graphQLRequest)
+				.ConfigureAwait(false);
 
-				Assert.Null(response.Errors);
-				Assert.Equal(name, response.Data.human.name.ToString());
-			}
+			Assert.Null(response.Errors);
+			Assert.Equal(name, response.Data.human.name.ToString());
 		}
 
 		[Theory]
@@ -63,13 +61,11 @@ query Human($id: String!){
 				}",
 				new {id = id.ToString()});
 
-			using (var setup = SetupTest()) {
-				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-					.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
+				.ConfigureAwait(false);
 
-				Assert.Null(response.Errors);
-				Assert.Equal(name, response.Data.Human.Name);
-			}
+			Assert.Null(response.Errors);
+			Assert.Equal(name, response.Data.Human.Name);
 		}
 
 		[Theory]
@@ -90,13 +86,11 @@ query Droid($id: String!) {
 				new { id = id.ToString() },
 				"Human");
 
-			using (var setup = SetupTest()) {
-				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-					.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
+				.ConfigureAwait(false);
 
-				Assert.Null(response.Errors);
-				Assert.Equal(name, response.Data.Human.Name);
-			}
+			Assert.Null(response.Errors);
+			Assert.Equal(name, response.Data.Human.Name);
 		}
 
 		[Fact]
@@ -118,27 +112,25 @@ query Human($id: String!){
 					}
 				}");
 
-			using (var setup = SetupTest()) {
-				var mutationResponse = await setup.Client.SendMutationAsync(mutationRequest, () => new {
-						createHuman = new {
-							Id = "",
-							Name = "",
-							HomePlanet = ""
-						}
-					})
-					.ConfigureAwait(false);
-
-				Assert.Null(mutationResponse.Errors);
-				Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
-				Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
-
-				queryRequest.Variables = new {id = mutationResponse.Data.createHuman.Id};
-				var queryResponse = await setup.Client.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } })
-					.ConfigureAwait(false);
-				
-				Assert.Null(queryResponse.Errors);
-				Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
-			}
+			var mutationResponse = await StarWarsClient.SendMutationAsync(mutationRequest, () => new {
+					createHuman = new {
+						Id = "",
+						Name = "",
+						HomePlanet = ""
+					}
+				})
+				.ConfigureAwait(false);
+
+			Assert.Null(mutationResponse.Errors);
+			Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
+			Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
+
+			queryRequest.Variables = new {id = mutationResponse.Data.createHuman.Id};
+			var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } })
+				.ConfigureAwait(false);
+			
+			Assert.Null(queryResponse.Errors);
+			Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
 		}
 
 		[Fact]
@@ -148,16 +140,14 @@ public async void PreprocessHttpRequestMessageIsCalled() {
 				PreprocessHttpRequestMessage = callbackTester.Invoke
 			};
 
-			using (var setup = SetupTest()) {
-				var defaultHeaders = setup.Client.HttpClient.DefaultRequestHeaders;
-				var response = await setup.Client.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-					.ConfigureAwait(false);
-				callbackTester.CallbackShouldHaveBeenInvoked(message => {
-					Assert.Equal(defaultHeaders, message.Headers);
-				});
-				Assert.Null(response.Errors);
-				Assert.Equal("Luke", response.Data.Human.Name);
-			}
+			var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
+				.ConfigureAwait(false);
+			callbackTester.CallbackShouldHaveBeenInvoked(message => {
+				Assert.Equal(defaultHeaders, message.Headers);
+			});
+			Assert.Null(response.Errors);
+			Assert.Equal("Luke", response.Data.Human.Name);
 		}
 
 		[Fact]
@@ -167,15 +157,37 @@ query Long {
 					longRunning
 				}");
 
-			using (var setup = WebHostHelpers.SetupTest<StartupChat>(false, serializer)) {
-				var cancellationTimeout = TimeSpan.FromSeconds(1);
-				var cts = new CancellationTokenSource(cancellationTimeout);
-
-				Func<Task> requestTask = () => setup.Client.SendQueryAsync(graphQLRequest, () => new {longRunning = string.Empty}, cts.Token);
-				Action timeMeasurement = () => requestTask.Should().Throw<TaskCanceledException>();
-
-				timeMeasurement.ExecutionTime().Should().BeCloseTo(cancellationTimeout, TimeSpan.FromMilliseconds(50));
-			}
+			var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
+			var cts = new CancellationTokenSource();
+
+			var request =
+				ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
+
+			// Test regular request
+			// start request
+			request.Start();
+			// wait until the query has reached the server
+			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			// unblock the query
+			chatQuery.LongRunningQueryBlocker.Set();
+			// check execution time
+			request.Invoking().ExecutionTime().Should().BeLessThan(100.Milliseconds());
+			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+
+			// reset stuff
+			chatQuery.LongRunningQueryBlocker.Reset();
+			request.Clear();
+
+			// cancellation test
+			request.Start();
+			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			cts.Cancel();
+			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
+				.ExecutionTime().Should().BeLessThan(100.Milliseconds());
+
+			// let the server finish its query
+			chatQuery.LongRunningQueryBlocker.Set();
 		}
+
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
index 1046ed6d..57f86f64 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
@@ -1,8 +1,10 @@
 using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests {
-	public class Newtonsoft: Base {
-		public Newtonsoft() : base(new NewtonsoftJsonSerializer())
+	public class Newtonsoft: Base, IClassFixture<NewtonsoftIntegrationServerTestFixture> {
+		public Newtonsoft(NewtonsoftIntegrationServerTestFixture fixture) : base(fixture)
 		{
 		}
 	}
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
index dd725b4d..e74d5012 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
@@ -1,8 +1,10 @@
 using GraphQL.Client.Serializer.SystemTextJson;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests {
-	public class SystemTextJson: Base {
-		public SystemTextJson() : base(new SystemTextJsonSerializer())
+	public class SystemTextJson: Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture> {
+		public SystemTextJson(SystemTextJsonIntegrationServerTestFixture fixture) : base(fixture)
 		{
 		}
 	}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 0e1cfa6b..e4bd5010 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -2,59 +2,49 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Net.WebSockets;
-using System.Reactive.Concurrency;
-using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Extensions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
+using GraphQL.Client.Http;
 using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
-using IntegrationTestServer;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Reactive.Testing;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace GraphQL.Integration.Tests.WebsocketTests {
-	public abstract class Base {
+	public abstract class Base: IAsyncLifetime {
 		protected readonly ITestOutputHelper Output;
-		protected readonly IGraphQLWebsocketJsonSerializer Serializer;
-		protected IWebHost CreateServer(int port) => WebHostHelpers.CreateServer<StartupChat>(port);
-
-		protected Base(ITestOutputHelper output, IGraphQLWebsocketJsonSerializer serializer) {
+		protected readonly IntegrationServerTestFixture Fixture;
+		protected GraphQLHttpClient ChatClient;
+		
+		protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture) {
 			this.Output = output;
-			this.Serializer = serializer;
+			this.Fixture = fixture;
 		}
-		
-		[Fact]
-		public async void AssertTestingHarness() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
 
-				const string message = "some random testing message";
-				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
+		public async Task InitializeAsync() {
+			Fixture.Server.Services.GetService<Chat>().Reset();
+			ChatClient = Fixture.GetChatClient(true);
+			Output.WriteLine($"ChatClient: {ChatClient.GetHashCode()}");
+		}
 
-				Assert.Equal(message, response.Data.AddMessage.Content);
-			}
+		public Task DisposeAsync() {
+			ChatClient?.Dispose();
+			return Task.CompletedTask;
 		}
 
 		[Fact]
 		public async void CanSendRequestViaWebsocket() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, true, Serializer);
-				const string message = "some random testing message";
-				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
-
-				Assert.Equal(message, response.Data.AddMessage.Content);
-			}
+			await ChatClient.InitializeWebsocketConnection();
+			const string message = "some random testing message";
+			var response = await ChatClient.AddMessageAsync(message).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message);
 		}
 
 		[Fact]
@@ -64,50 +54,44 @@ query Long {
 					longRunning
 				}");
 
-			using (var setup = WebHostHelpers.SetupTest<StartupChat>(true, Serializer)) {
-				await setup.Client.InitializeWebsocketConnection();
-				var chatQuery = setup.Server.Services.GetService<ChatQuery>();
-				var cts = new CancellationTokenSource();
-
-				var request =
-					ConcurrentTaskWrapper.New(() => setup.Client.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
-
-				// Test regular request
-				// start request
-				request.Start();
-				// wait until the query has reached the server
-				chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
-				// unblock the query
-				chatQuery.LongRunningQueryBlocker.Set();
-				// check execution time
-				request.Invoking().ExecutionTime().Should().BeLessThan(100.Milliseconds());
-				request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
-
-				// reset stuff
-				chatQuery.LongRunningQueryBlocker.Reset();
-				request.Clear();
-
-				// cancellation test
-				request.Start();
-				chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
-				cts.Cancel();
-				FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
-					.ExecutionTime().Should().BeLessThan(100.Milliseconds());
-
-				// let the server finish its query
-				chatQuery.LongRunningQueryBlocker.Set();
-			}
+			var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
+			var cts = new CancellationTokenSource();
+
+			await ChatClient.InitializeWebsocketConnection();
+			var request =
+				ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
+
+			// Test regular request
+			// start request
+			request.Start();
+			// wait until the query has reached the server
+			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			// unblock the query
+			chatQuery.LongRunningQueryBlocker.Set();
+			// check execution time
+			request.Invoking().ExecutionTime().Should().BeLessThan(100.Milliseconds());
+			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+
+			// reset stuff
+			chatQuery.LongRunningQueryBlocker.Reset();
+			request.Clear();
+
+			// cancellation test
+			request.Start();
+			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			cts.Cancel();
+			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
+				.ExecutionTime().Should().BeLessThan(100.Milliseconds());
+
+			// let the server finish its query
+			chatQuery.LongRunningQueryBlocker.Set();
 		}
 		
 		[Fact]
 		public async void CanHandleRequestErrorViaWebsocket() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, true, Serializer);
-				var response = await client.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
-
-				Assert.Single(response.Errors);
-			}
+			await ChatClient.InitializeWebsocketConnection();
+			var response = await ChatClient.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
+			response.Errors.Should().ContainSingle("because the query is invalid");
 		}
 
 		private const string SubscriptionQuery = @"
@@ -122,36 +106,31 @@ public async void CanHandleRequestErrorViaWebsocket() {
 
 		[Fact]
 		public async void CanCreateObservableSubscription() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)){
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
-				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
-				await client.InitializeWebsocketConnection();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
-
-				Debug.WriteLine("subscribing...");
-				using (var tester = observable.Monitor()) {
-					const string message1 = "Hello World";
-
-					var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-					response.Data.AddMessage.Content.Should().Be(message1);
-					tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
-						.Which.Data.MessageAdded.Content.Should().Be(message1);
-
-					const string message2 = "lorem ipsum dolor si amet";
-					response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-					response.Data.AddMessage.Content.Should().Be(message2);
-					tester.Should().HaveReceivedPayload()
-						.Which.Data.MessageAdded.Content.Should().Be(message2);
-
-					// disposing the client should throw a TaskCanceledException on the subscription
-					client.Dispose();
-					tester.Should().HaveCompleted();
-				}
-			}
+			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+			await ChatClient.InitializeWebsocketConnection();
+			callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+			Debug.WriteLine("creating subscription stream");
+			var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+
+			Debug.WriteLine("subscribing...");
+			using var tester = observable.Monitor();
+			const string message1 = "Hello World";
+
+			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message1);
+			tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
+				.Which.Data.MessageAdded.Content.Should().Be(message1);
+
+			const string message2 = "lorem ipsum dolor si amet";
+			response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message2);
+			tester.Should().HaveReceivedPayload()
+				.Which.Data.MessageAdded.Content.Should().Be(message2);
+
+			// disposing the client should throw a TaskCanceledException on the subscription
+			ChatClient.Dispose();
+			tester.Should().HaveCompleted();
 		}
 
 		public class MessageAddedSubscriptionResult {
@@ -165,48 +144,45 @@ public class MessageAddedContent {
 
 		[Fact]
 		public async void CanReconnectWithSameObservable() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
-				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
-
-				Debug.WriteLine("creating subscription stream");
-				var observable = client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
-
-				Debug.WriteLine("subscribing...");
-				var tester = observable.Monitor();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-				const string message1 = "Hello World";
-				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				response.Data.AddMessage.Content.Should().Be(message1);
-				tester.Should().HaveReceivedPayload()
-					.Which.Data.MessageAdded.Content.Should().Be(message1);
-
-				const string message2 = "How are you?";
-				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-				response.Data.AddMessage.Content.Should().Be(message2);
-				tester.Should().HaveReceivedPayload()
-					.Which.Data.MessageAdded.Content.Should().Be(message2);
-
-				Debug.WriteLine("disposing subscription...");
-				tester.Dispose(); // does not close the websocket connection
-
-				Debug.WriteLine("creating new subscription...");
-				tester = observable.Monitor();
-				tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10))
-					.Which.Data.MessageAdded.Content.Should().Be(message2);
-
-				const string message3 = "lorem ipsum dolor si amet";
-				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
-				response.Data.AddMessage.Content.Should().Be(message3);
-				tester.Should().HaveReceivedPayload()
-					.Which.Data.MessageAdded.Content.Should().Be(message3);
-
-				// disposing the client should complete the subscription
-				client.Dispose();
-				tester.Should().HaveCompleted();
-			}
+			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+
+			Debug.WriteLine("creating subscription stream");
+			var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+
+			Debug.WriteLine("subscribing...");
+			var tester = observable.Monitor();
+			callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+			const string message1 = "Hello World";
+			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message1);
+			tester.Should().HaveReceivedPayload(3.Seconds())
+				.Which.Data.MessageAdded.Content.Should().Be(message1);
+
+			const string message2 = "How are you?";
+			response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message2);
+			tester.Should().HaveReceivedPayload()
+				.Which.Data.MessageAdded.Content.Should().Be(message2);
+
+			Debug.WriteLine("disposing subscription...");
+			tester.Dispose(); // does not close the websocket connection
+
+			Debug.WriteLine("creating new subscription...");
+			var tester2 = observable.Monitor();
+			tester2.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10))
+				.Which.Data.MessageAdded.Content.Should().Be(message2);
+
+			const string message3 = "lorem ipsum dolor si amet";
+			response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message3);
+			tester2.Should().HaveReceivedPayload()
+				.Which.Data.MessageAdded.Content.Should().Be(message3);
+
+			// disposing the client should complete the subscription
+			ChatClient.Dispose();
+			tester2.Should().HaveCompleted();
+			tester2.Dispose();
 		}
 
 		private const string SubscriptionQuery2 = @"
@@ -235,75 +211,66 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var port = NetworkHelpers.GetFreeTcpPortNumber();
 			var callbackTester = new CallbackMonitor<Exception>();
 			var callbackTester2 = new CallbackMonitor<Exception>();
-			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
-				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
-				await client.InitializeWebsocketConnection();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable1 =
-					client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Invoke);
-				IObservable<GraphQLResponse<UserJoinedSubscriptionResult>> observable2 =
-					client.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
-
-				Debug.WriteLine("subscribing...");
-				var tester = observable1.Monitor();
-				var tester2 = observable2.Monitor();
-
-				const string message1 = "Hello World";
-				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-				response.Data.AddMessage.Content.Should().Be(message1);
-				tester.Should().HaveReceivedPayload()
-					.Which.Data.MessageAdded.Content.Should().Be(message1);
-				
-				var joinResponse = await client.JoinDeveloperUser().ConfigureAwait(false);
-				joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
-
-				var payload = tester2.Should().HaveReceivedPayload().Subject;
-				payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
-				payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
-				Debug.WriteLine("disposing subscription...");
-				tester2.Dispose();
-
-				const string message3 = "lorem ipsum dolor si amet";
-				response = await client.AddMessageAsync(message3).ConfigureAwait(false);
-				response.Data.AddMessage.Content.Should().Be(message3);
-				tester.Should().HaveReceivedPayload()
-					.Which.Data.MessageAdded.Content.Should().Be(message3);
-
-				// disposing the client should complete the subscription
-				client.Dispose();
-				tester.Should().HaveCompleted();
-			}
+			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+			await ChatClient.InitializeWebsocketConnection();
+			callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+			Debug.WriteLine("creating subscription stream");
+			var observable1 = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Invoke);
+			var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
+
+			Debug.WriteLine("subscribing...");
+			var tester = observable1.Monitor();
+			var tester2 = observable2.Monitor();
+
+			const string message1 = "Hello World";
+			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message1);
+			tester.Should().HaveReceivedPayload()
+				.Which.Data.MessageAdded.Content.Should().Be(message1);
+			
+			var joinResponse = await ChatClient.JoinDeveloperUser().ConfigureAwait(false);
+			joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+
+			var payload = tester2.Should().HaveReceivedPayload().Subject;
+			payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
+			payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+
+			Debug.WriteLine("disposing subscription...");
+			tester2.Dispose();
+
+			const string message3 = "lorem ipsum dolor si amet";
+			response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(false);
+			response.Data.AddMessage.Content.Should().Be(message3);
+			tester.Should().HaveReceivedPayload()
+				.Which.Data.MessageAdded.Content.Should().Be(message3);
+
+			// disposing the client should complete the subscription
+			ChatClient.Dispose();
+			tester.Should().HaveCompleted();
 		}
 
 
 		[Fact]
 		public async void CanHandleConnectionTimeout() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			var server = CreateServer(port);
 			var errorMonitor = new CallbackMonitor<Exception>();
 			var reconnectBlocker = new ManualResetEventSlim(false);
 
-			var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
-			var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
+			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
 			// configure back-off strategy to allow it to be controlled from within the unit test
-			client.Options.BackOffStrategy = i => {
+			ChatClient.Options.BackOffStrategy = i => {
 				reconnectBlocker.Wait();
 				return TimeSpan.Zero;
 			};
 
 			var websocketStates = new ConcurrentQueue<GraphQLWebsocketConnectionState>();
 
-			using (client.WebsocketConnectionState.Subscribe(websocketStates.Enqueue)) {
+			using (ChatClient.WebsocketConnectionState.Subscribe(websocketStates.Enqueue)) {
 				websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
 
 				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<MessageAddedSubscriptionResult>> observable =
-					client.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest,
-						errorMonitor.Invoke);
+				var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, errorMonitor.Invoke);
 
 				Debug.WriteLine("subscribing...");
 				var tester = observable.Monitor();
@@ -317,21 +284,20 @@ public async void CanHandleConnectionTimeout() {
 				websocketStates.Clear();
 
 				const string message1 = "Hello World";
-				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
 				response.Data.AddMessage.Content.Should().Be(message1);
 				tester.Should().HaveReceivedPayload()
 					.Which.Data.MessageAdded.Content.Should().Be(message1);
 
 				Debug.WriteLine("stopping web host...");
-				await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
-				server.Dispose();
+				await Fixture.ShutdownServer();
 				Debug.WriteLine("web host stopped...");
 
 				errorMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10))
 					.Which.Should().BeOfType<WebSocketException>();
 				websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
 
-				server = CreateServer(port);
+				Fixture.CreateServer();
 				reconnectBlocker.Set();
 				callbackMonitor.Should().HaveBeenInvokedWithPayload();
 				websocketStates.Should().ContainInOrder(
@@ -340,71 +306,63 @@ public async void CanHandleConnectionTimeout() {
 					GraphQLWebsocketConnectionState.Connected);
 
 				// disposing the client should complete the subscription
-				client.Dispose();
+				ChatClient.Dispose();
 				tester.Should().HaveCompleted(TimeSpan.FromSeconds(5));
-				server.Dispose();
 			}
 		}
 
 
 		[Fact]
 		public async void CanHandleSubscriptionError() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)) {
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
-				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
-				await client.InitializeWebsocketConnection();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload();
-				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
-					new GraphQLRequest(@"
-						subscription {
-						  failImmediately {
-						    content
-						  }
-						}")
-					);
+			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+			await ChatClient.InitializeWebsocketConnection();
+			callbackMonitor.Should().HaveBeenInvokedWithPayload();
+			Debug.WriteLine("creating subscription stream");
+			IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
+				new GraphQLRequest(@"
+					subscription {
+					  failImmediately {
+					    content
+					  }
+					}")
+				);
 
-				Debug.WriteLine("subscribing...");
-				using (var tester = observable.Monitor()) {
-					tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
-						.Which.Errors.Should().ContainSingle();
-					tester.Should().HaveCompleted();
-					client.Dispose();
-				}
+			Debug.WriteLine("subscribing...");
+			using (var tester = observable.Monitor()) {
+				tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
+					.Which.Errors.Should().ContainSingle();
+				tester.Should().HaveCompleted();
+				ChatClient.Dispose();
 			}
+			
 		}
 
 
 		[Fact]
 		public async void CanHandleQueryErrorInSubscription() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			using (CreateServer(port)) {
-
-				var test = new GraphQLRequest("tset", new { test = "blaa" });
-
-				var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
-				var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
-				await client.InitializeWebsocketConnection();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload();
-				Debug.WriteLine("creating subscription stream");
-				IObservable<GraphQLResponse<object>> observable = client.CreateSubscriptionStream<object>(
-					new GraphQLRequest(@"
-						subscription {
-						  fieldDoesNotExist {
-						    content
-						  }
-						}")
-				);
-
-				Debug.WriteLine("subscribing...");
-				using (var tester = observable.Monitor()) {
-					tester.Should().HaveReceivedPayload()
-						.Which.Errors.Should().ContainSingle();
-					tester.Should().HaveCompleted();
-					client.Dispose();
-				}
+			var test = new GraphQLRequest("tset", new { test = "blaa" });
+
+			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+			await ChatClient.InitializeWebsocketConnection();
+			callbackMonitor.Should().HaveBeenInvokedWithPayload();
+			Debug.WriteLine("creating subscription stream");
+			IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
+				new GraphQLRequest(@"
+					subscription {
+					  fieldDoesNotExist {
+					    content
+					  }
+					}")
+			);
+
+			Debug.WriteLine("subscribing...");
+			using (var tester = observable.Monitor()) {
+				tester.Should().HaveReceivedPayload()
+					.Which.Errors.Should().ContainSingle();
+				tester.Should().HaveCompleted();
+				ChatClient.Dispose();
 			}
 		}
+
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
index 02a0b030..76169663 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
@@ -1,10 +1,11 @@
 using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
 using Xunit.Abstractions;
 
 namespace GraphQL.Integration.Tests.WebsocketTests {
-	public class Newtonsoft: Base {
-		public Newtonsoft(ITestOutputHelper output) : base(output, new NewtonsoftJsonSerializer())
-		{
-		}
+	public class Newtonsoft: Base, IClassFixture<NewtonsoftIntegrationServerTestFixture> {
+		public Newtonsoft(ITestOutputHelper output, NewtonsoftIntegrationServerTestFixture fixture) : base(output, fixture)
+		{ }
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
index 3a7882e4..fc7698ed 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
@@ -1,9 +1,10 @@
-using GraphQL.Client.Serializer.SystemTextJson;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
 using Xunit.Abstractions;
 
 namespace GraphQL.Integration.Tests.WebsocketTests {
-	public class SystemTextJson: Base {
-		public SystemTextJson(ITestOutputHelper output) : base(output, new SystemTextJsonSerializer())
+	public class SystemTextJson: Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture> {
+		public SystemTextJson(ITestOutputHelper output, SystemTextJsonIntegrationServerTestFixture fixture) : base(output, fixture)
 		{
 		}
 	}
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index 67cbd96b..ec3530e1 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -10,7 +10,7 @@ public static void Main(string[] args) {
 
 		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
 			WebHost.CreateDefaultBuilder(args)
-				.UseStartup<StartupStarWars>()
+				.UseStartup<Startup>()
 				.ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 	}
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 0ae7280e..2f25f733 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,8 +1,11 @@
 using GraphQL;
+using GraphQL.Client.Tests.Common;
+using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Server;
 using GraphQL.Server.Ui.GraphiQL;
-using GraphQL.Server.Ui.Voyager;
 using GraphQL.Server.Ui.Playground;
+using GraphQL.StarWars;
+using GraphQL.Types;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
@@ -11,8 +14,8 @@
 using Microsoft.Extensions.Hosting;
 
 namespace IntegrationTestServer {
-	public abstract class Startup {
-		protected Startup(IConfiguration configuration, IWebHostEnvironment environment) {
+	public class Startup {
+		public Startup(IConfiguration configuration, IWebHostEnvironment environment) {
 			Configuration = configuration;
 			Environment = environment;
 		}
@@ -29,9 +32,8 @@ public void ConfigureServices(IServiceCollection services) {
 			});
 
 			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
-
-			ConfigureGraphQLSchemaServices(services);
-			
+			services.AddChatSchema();
+			services.AddStarWarsSchema();
 			services.AddGraphQL(options => {
 				options.EnableMetrics = true;
 				options.ExposeExceptions = Environment.IsDevelopment();
@@ -39,9 +41,6 @@ public void ConfigureServices(IServiceCollection services) {
 				.AddWebSockets();
 		}
 
-		public abstract void ConfigureGraphQLSchemaServices(IServiceCollection services);
-
-
 		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
 		public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
 			if (env.IsDevelopment()) {
@@ -50,21 +49,23 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
 
 			app.UseWebSockets();
 
-			ConfigureGraphQLSchema(app);
+			ConfigureGraphQLSchema<ChatSchema>(app, Common.ChatEndpoint);
+			ConfigureGraphQLSchema<StarWarsSchema>(app, Common.StarWarsEndpoint);
 
 			app.UseGraphiQLServer(new GraphiQLOptions {
 				GraphiQLPath = "/ui/graphiql",
-				GraphQLEndPoint = "/graphql"
-			});
-			app.UseGraphQLVoyager(new GraphQLVoyagerOptions() {
-				GraphQLEndPoint = "/graphql",
-				Path = "/ui/voyager"
+				GraphQLEndPoint = Common.StarWarsEndpoint
 			});
 			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions {
-				Path = "/ui/playground"
+				Path = "/ui/playground",
+				GraphQLEndPoint = Common.ChatEndpoint
 			});
 		}
 
-		public abstract void ConfigureGraphQLSchema(IApplicationBuilder app);
+		private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema: Schema
+		{
+			app.UseGraphQLWebSockets<TSchema>(endpoint);
+			app.UseGraphQL<TSchema>(endpoint);
+		}
 	}
 }
diff --git a/tests/IntegrationTestServer/StartupChat.cs b/tests/IntegrationTestServer/StartupChat.cs
deleted file mode 100644
index 2a782991..00000000
--- a/tests/IntegrationTestServer/StartupChat.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using GraphQL.Client.Tests.Common;
-using GraphQL.Client.Tests.Common.Chat.Schema;
-using GraphQL.Server;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace IntegrationTestServer {
-	public class StartupChat: Startup {
-		public StartupChat(IConfiguration configuration, IWebHostEnvironment environment): base(configuration, environment) { }
-
-		public override void ConfigureGraphQLSchemaServices(IServiceCollection services) {
-			services.AddChatSchema();
-		}
-
-		public override void ConfigureGraphQLSchema(IApplicationBuilder app) {
-			app.UseGraphQLWebSockets<ChatSchema>("/graphql");
-			app.UseGraphQL<ChatSchema>("/graphql");
-		}
-	}
-}
diff --git a/tests/IntegrationTestServer/StartupStarWars.cs b/tests/IntegrationTestServer/StartupStarWars.cs
deleted file mode 100644
index 15609515..00000000
--- a/tests/IntegrationTestServer/StartupStarWars.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using GraphQL.Client.Tests.Common;
-using GraphQL.Server;
-using GraphQL.StarWars;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace IntegrationTestServer {
-	public class StartupStarWars: Startup {
-		public StartupStarWars(IConfiguration configuration, IWebHostEnvironment environment): base(configuration, environment) { }
-
-		public override void ConfigureGraphQLSchemaServices(IServiceCollection services) {
-			services.AddStarWarsSchema();
-		}
-
-		public override void ConfigureGraphQLSchema(IApplicationBuilder app) {
-			app.UseGraphQLWebSockets<StarWarsSchema>("/graphql");
-			app.UseGraphQL<StarWarsSchema>("/graphql");
-		}
-	}
-}

From da094ae55a0f0546282f3919336d32a83bf44814 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 26 Feb 2020 14:19:22 +0100
Subject: [PATCH 196/455] remove configure await

---
 .gitignore                                    |  1 +
 .../Helpers/IntegrationServerTestFixture.cs   |  8 ++--
 .../Helpers/WebHostHelpers.cs                 | 12 ++++--
 .../QueryAndMutationTests/Base.cs             | 36 +++++++++--------
 .../WebsocketTests/Base.cs                    | 39 +++++++++++--------
 5 files changed, 53 insertions(+), 43 deletions(-)

diff --git a/.gitignore b/.gitignore
index f173174b..be040ad5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 .idea/
 .vs/
+.vscode/
 bin/
 obj/
 *.user
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index 3b20ccbe..e8344a13 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -17,13 +17,11 @@ public abstract class IntegrationServerTestFixture {
 		public IntegrationServerTestFixture()
 		{
 			Port = NetworkHelpers.GetFreeTcpPortNumber();
-			CreateServer();
 		}
 
-		public void CreateServer() {
-			if(Server != null)
-				throw new InvalidOperationException("server is already created");
-			Server = WebHostHelpers.CreateServer(Port);
+		public async Task CreateServer() {
+			if (Server != null) return;
+			Server = await WebHostHelpers.CreateServer(Port);
 		}
 
 		public async Task ShutdownServer() {
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 59084c6f..923c11d1 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Reactive.Disposables;
-using GraphQL.Client;
+using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
@@ -9,13 +9,15 @@
 using IntegrationTestServer;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 
 namespace GraphQL.Integration.Tests.Helpers
 {
 	public static class WebHostHelpers
 	{
-		public static IWebHost CreateServer(int port)
+		public static async Task<IWebHost> CreateServer(int port)
 		{
 			var configBuilder = new ConfigurationBuilder();
 			configBuilder.AddInMemoryCollection();
@@ -31,8 +33,10 @@ public static IWebHost CreateServer(int port)
 				.UseStartup<Startup>()
 				.Build();
 
-			host.Start();
-
+			var tcs = new TaskCompletionSource<bool>();
+			host.Services.GetService<IHostApplicationLifetime>().ApplicationStarted.Register(() => tcs.TrySetResult(true));
+			await host.StartAsync();
+			await tcs.Task;
 			return host;
 		}
 		
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index ea103901..92e61f8d 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -14,7 +14,7 @@
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests {
 
-	public abstract class Base {
+	public abstract class Base: IAsyncLifetime {
 
 		protected IntegrationServerTestFixture Fixture;
 		protected GraphQLHttpClient StarWarsClient;
@@ -22,17 +22,25 @@ public abstract class Base {
 
 		protected Base(IntegrationServerTestFixture fixture) {
 			Fixture = fixture;
+		}
+
+		public async Task InitializeAsync() {
+			await Fixture.CreateServer();
 			StarWarsClient = Fixture.GetStarWarsClient();
 			ChatClient = Fixture.GetChatClient();
 		}
-		
+
+		public Task DisposeAsync() {
+			ChatClient?.Dispose();
+			StarWarsClient?.Dispose();
+			return Task.CompletedTask;
+		}
+
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
 		public async void QueryTheory(int id, string name) {
 			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
-
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty }})
-				.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty }});
 
 			Assert.Null(response.Errors);
 			Assert.Equal(name, response.Data.Human.Name);
@@ -43,8 +51,7 @@ public async void QueryTheory(int id, string name) {
 		public async void QueryWithDynamicReturnTypeTheory(int id, string name) {
 			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
 
-			var response = await StarWarsClient.SendQueryAsync<dynamic>(graphQLRequest)
-				.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync<dynamic>(graphQLRequest);
 
 			Assert.Null(response.Errors);
 			Assert.Equal(name, response.Data.human.name.ToString());
@@ -61,8 +68,7 @@ query Human($id: String!){
 				}",
 				new {id = id.ToString()});
 
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-				.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
 			Assert.Null(response.Errors);
 			Assert.Equal(name, response.Data.Human.Name);
@@ -86,8 +92,7 @@ query Droid($id: String!) {
 				new { id = id.ToString() },
 				"Human");
 
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-				.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
 			Assert.Null(response.Errors);
 			Assert.Equal(name, response.Data.Human.Name);
@@ -118,16 +123,14 @@ query Human($id: String!){
 						Name = "",
 						HomePlanet = ""
 					}
-				})
-				.ConfigureAwait(false);
+				});
 
 			Assert.Null(mutationResponse.Errors);
 			Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
 			Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
 
 			queryRequest.Variables = new {id = mutationResponse.Data.createHuman.Id};
-			var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } })
-				.ConfigureAwait(false);
+			var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } });
 			
 			Assert.Null(queryResponse.Errors);
 			Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
@@ -141,8 +144,7 @@ public async void PreprocessHttpRequestMessageIsCalled() {
 			};
 
 			var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-				.ConfigureAwait(false);
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 			callbackTester.CallbackShouldHaveBeenInvoked(message => {
 				Assert.Equal(defaultHeaders, message.Headers);
 			});
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index e4bd5010..d4c6ade2 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Net.WebSockets;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
@@ -14,6 +15,7 @@
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -29,9 +31,12 @@ protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture) {
 		}
 
 		public async Task InitializeAsync() {
+			await Fixture.CreateServer();
 			Fixture.Server.Services.GetService<Chat>().Reset();
-			ChatClient = Fixture.GetChatClient(true);
-			Output.WriteLine($"ChatClient: {ChatClient.GetHashCode()}");
+			if (ChatClient == null) {
+				ChatClient = Fixture.GetChatClient(true);
+				Output.WriteLine($"ChatClient: {ChatClient.GetHashCode()}");
+			}
 		}
 
 		public Task DisposeAsync() {
@@ -43,7 +48,7 @@ public Task DisposeAsync() {
 		public async void CanSendRequestViaWebsocket() {
 			await ChatClient.InitializeWebsocketConnection();
 			const string message = "some random testing message";
-			var response = await ChatClient.AddMessageAsync(message).ConfigureAwait(false);
+			var response = await ChatClient.AddMessageAsync(message);
 			response.Data.AddMessage.Content.Should().Be(message);
 		}
 
@@ -90,7 +95,7 @@ query Long {
 		[Fact]
 		public async void CanHandleRequestErrorViaWebsocket() {
 			await ChatClient.InitializeWebsocketConnection();
-			var response = await ChatClient.SendQueryAsync<object>("this query is formatted quite badly").ConfigureAwait(false);
+			var response = await ChatClient.SendQueryAsync<object>("this query is formatted quite badly");
 			response.Errors.Should().ContainSingle("because the query is invalid");
 		}
 
@@ -117,13 +122,13 @@ public async void CanCreateObservableSubscription() {
 			using var tester = observable.Monitor();
 			const string message1 = "Hello World";
 
-			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
+			var response = await ChatClient.AddMessageAsync(message1);
 			response.Data.AddMessage.Content.Should().Be(message1);
 			tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
 				.Which.Data.MessageAdded.Content.Should().Be(message1);
 
 			const string message2 = "lorem ipsum dolor si amet";
-			response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(false);
+			response = await ChatClient.AddMessageAsync(message2);
 			response.Data.AddMessage.Content.Should().Be(message2);
 			tester.Should().HaveReceivedPayload()
 				.Which.Data.MessageAdded.Content.Should().Be(message2);
@@ -154,13 +159,13 @@ public async void CanReconnectWithSameObservable() {
 			callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
 			const string message1 = "Hello World";
-			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
+			var response = await ChatClient.AddMessageAsync(message1);
 			response.Data.AddMessage.Content.Should().Be(message1);
-			tester.Should().HaveReceivedPayload(3.Seconds())
+			tester.Should().HaveReceivedPayload(10.Seconds())
 				.Which.Data.MessageAdded.Content.Should().Be(message1);
 
 			const string message2 = "How are you?";
-			response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(false);
+			response = await ChatClient.AddMessageAsync(message2);
 			response.Data.AddMessage.Content.Should().Be(message2);
 			tester.Should().HaveReceivedPayload()
 				.Which.Data.MessageAdded.Content.Should().Be(message2);
@@ -174,7 +179,7 @@ public async void CanReconnectWithSameObservable() {
 				.Which.Data.MessageAdded.Content.Should().Be(message2);
 
 			const string message3 = "lorem ipsum dolor si amet";
-			response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(false);
+			response = await ChatClient.AddMessageAsync(message3);
 			response.Data.AddMessage.Content.Should().Be(message3);
 			tester2.Should().HaveReceivedPayload()
 				.Which.Data.MessageAdded.Content.Should().Be(message3);
@@ -225,12 +230,12 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var tester2 = observable2.Monitor();
 
 			const string message1 = "Hello World";
-			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
+			var response = await ChatClient.AddMessageAsync(message1);
 			response.Data.AddMessage.Content.Should().Be(message1);
 			tester.Should().HaveReceivedPayload()
 				.Which.Data.MessageAdded.Content.Should().Be(message1);
 			
-			var joinResponse = await ChatClient.JoinDeveloperUser().ConfigureAwait(false);
+			var joinResponse = await ChatClient.JoinDeveloperUser();
 			joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
 			var payload = tester2.Should().HaveReceivedPayload().Subject;
@@ -241,7 +246,7 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			tester2.Dispose();
 
 			const string message3 = "lorem ipsum dolor si amet";
-			response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(false);
+			response = await ChatClient.AddMessageAsync(message3);
 			response.Data.AddMessage.Content.Should().Be(message3);
 			tester.Should().HaveReceivedPayload()
 				.Which.Data.MessageAdded.Content.Should().Be(message3);
@@ -284,9 +289,9 @@ public async void CanHandleConnectionTimeout() {
 				websocketStates.Clear();
 
 				const string message1 = "Hello World";
-				var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(false);
+				var response = await ChatClient.AddMessageAsync(message1);
 				response.Data.AddMessage.Content.Should().Be(message1);
-				tester.Should().HaveReceivedPayload()
+				tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10))
 					.Which.Data.MessageAdded.Content.Should().Be(message1);
 
 				Debug.WriteLine("stopping web host...");
@@ -297,9 +302,9 @@ public async void CanHandleConnectionTimeout() {
 					.Which.Should().BeOfType<WebSocketException>();
 				websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
 
-				Fixture.CreateServer();
+				await InitializeAsync();
 				reconnectBlocker.Set();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload();
+				callbackMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10));
 				websocketStates.Should().ContainInOrder(
 					GraphQLWebsocketConnectionState.Disconnected,
 					GraphQLWebsocketConnectionState.Connecting,

From b218496d3854b47e588c0316cf1128dc3ec3be46 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 2 Mar 2020 15:51:32 +0100
Subject: [PATCH 197/455] fix reconnect test

---
 .../Chat/Schema/IChat.cs                      | 60 +++---------------
 .../Helpers/ObservableTester.cs               |  8 ++-
 .../WebsocketTests/Base.cs                    | 61 ++++++++++++-------
 3 files changed, 53 insertions(+), 76 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index 6d53e42b..9ebfbd1a 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -16,22 +16,17 @@ public interface IChat {
 
 		Message AddMessage(ReceivedMessage message);
 	}
-
+	
 	public class Chat : IChat {
-		private readonly RollingReplaySubject<Message> _messageStream = new RollingReplaySubject<Message>();
-		private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
+		private readonly ISubject<Message> messageStream = new ReplaySubject<Message>(1);
+		private readonly ISubject<MessageFrom> userJoined = new Subject<MessageFrom>();
 
 		public Chat() {
-			Reset();
-		}
-
-		public void Reset() {
 			AllMessages = new ConcurrentStack<Message>();
 			Users = new ConcurrentDictionary<string, string> {
 				["1"] = "developer",
 				["2"] = "tester"
 			};
-			_messageStream.Clear();
 		}
 
 		public ConcurrentDictionary<string, string> Users { get; private set; }
@@ -55,7 +50,7 @@ public Message AddMessage(ReceivedMessage message) {
 
 		public Message AddMessage(Message message) {
 			AllMessages.Push(message);
-			_messageStream.OnNext(message);
+			messageStream.OnNext(message);
 			return message;
 		}
 
@@ -69,12 +64,12 @@ public MessageFrom Join(string userId) {
 				DisplayName = displayName
 			};
 
-			_userJoined.OnNext(joinedUser);
+			userJoined.OnNext(joinedUser);
 			return joinedUser;
 		}
 
 		public IObservable<Message> Messages(string user) {
-			return _messageStream
+			return messageStream
 				.Select(message => {
 					message.Sub = user;
 					return message;
@@ -83,11 +78,11 @@ public IObservable<Message> Messages(string user) {
 		}
 
 		public void AddError(Exception exception) {
-			_messageStream.OnError(exception);
+			messageStream.OnError(exception);
 		}
 
 		public IObservable<MessageFrom> UserJoined() {
-			return _userJoined.AsObservable();
+			return userJoined.AsObservable();
 		}
 	}
 
@@ -95,43 +90,4 @@ public class User {
 		public string Id { get; set; }
 		public string Name { get; set; }
 	}
-
-	public class RollingReplaySubject<T> : ISubject<T> {
-		private readonly ReplaySubject<IObservable<T>> _subjects;
-		private readonly IObservable<T> _concatenatedSubjects;
-		private ISubject<T> _currentSubject;
-
-		public RollingReplaySubject() {
-			_subjects = new ReplaySubject<IObservable<T>>(1);
-			_concatenatedSubjects = _subjects.Concat();
-			_currentSubject = new ReplaySubject<T>();
-			_subjects.OnNext(_currentSubject);
-		}
-
-		public void Clear() {
-			_currentSubject.OnCompleted();
-			_currentSubject = new ReplaySubject<T>();
-			_subjects.OnNext(_currentSubject);
-		}
-
-		public void OnNext(T value) {
-			_currentSubject.OnNext(value);
-		}
-
-		public void OnError(Exception error) {
-			_currentSubject.OnError(error);
-		}
-
-		public void OnCompleted() {
-			_currentSubject.OnCompleted();
-			_subjects.OnCompleted();
-			// a quick way to make the current ReplaySubject unreachable
-			// except to in-flight observers, and not hold up collection
-			_currentSubject = new Subject<T>();
-		}
-
-		public IDisposable Subscribe(IObserver<T> observer) {
-			return _concatenatedSubjects.Subscribe(observer);
-		}
-	}
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 43bcbe18..ec850d38 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.Reactive.Concurrency;
 using System.Reactive.Linq;
 using System.Threading;
@@ -9,6 +10,7 @@
 namespace GraphQL.Client.Tests.Common.Helpers {
 	public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		private readonly IDisposable subscription;
+		private readonly EventLoopScheduler scheduler;
 		private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim error = new ManualResetEventSlim();
@@ -34,12 +36,15 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
 		public ObservableTester(IObservable<TSubscriptionPayload> observable) {
-			subscription = observable.ObserveOn(TaskPoolScheduler.Default).Subscribe(
+			scheduler = new EventLoopScheduler();
+			subscription = observable.SubscribeOn(Scheduler.CurrentThread).ObserveOn(scheduler).Subscribe(
 				obj => {
+					Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
 					LastPayload = obj;
 					updateReceived.Set();
 				},
 				ex => {
+					Debug.WriteLine($"observable tester {GetHashCode()} error received: {ex}");
 					Error = ex;
 					error.Set();
 				},
@@ -57,6 +62,7 @@ private void Reset() {
 		/// <inheritdoc />
 		public void Dispose() {
 			subscription?.Dispose();
+			scheduler?.Dispose();
 		}
 
 		public SubscriptionAssertions<TSubscriptionPayload> Should() {
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index d4c6ade2..bcfedb98 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -15,7 +15,6 @@
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -30,12 +29,20 @@ protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture) {
 			this.Fixture = fixture;
 		}
 
+		protected static ReceivedMessage InitialMessage = new ReceivedMessage {
+			Content = "initial message",
+			SentAt = DateTime.Now,
+			FromId = "1"
+		};
+
 		public async Task InitializeAsync() {
 			await Fixture.CreateServer();
-			Fixture.Server.Services.GetService<Chat>().Reset();
+			// make sure the buffer always contains the same message
+			Fixture.Server.Services.GetService<Chat>().AddMessage(InitialMessage);
+
 			if (ChatClient == null) {
+				// then create the chat client
 				ChatClient = Fixture.GetChatClient(true);
-				Output.WriteLine($"ChatClient: {ChatClient.GetHashCode()}");
 			}
 		}
 
@@ -120,18 +127,17 @@ public async void CanCreateObservableSubscription() {
 
 			Debug.WriteLine("subscribing...");
 			using var tester = observable.Monitor();
-			const string message1 = "Hello World";
+			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
+			const string message1 = "Hello World";
 			var response = await ChatClient.AddMessageAsync(message1);
 			response.Data.AddMessage.Content.Should().Be(message1);
-			tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
-				.Which.Data.MessageAdded.Content.Should().Be(message1);
+			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
 
 			const string message2 = "lorem ipsum dolor si amet";
 			response = await ChatClient.AddMessageAsync(message2);
 			response.Data.AddMessage.Content.Should().Be(message2);
-			tester.Should().HaveReceivedPayload()
-				.Which.Data.MessageAdded.Content.Should().Be(message2);
+			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
 
 			// disposing the client should throw a TaskCanceledException on the subscription
 			ChatClient.Dispose();
@@ -157,32 +163,32 @@ public async void CanReconnectWithSameObservable() {
 			Debug.WriteLine("subscribing...");
 			var tester = observable.Monitor();
 			callbackMonitor.Should().HaveBeenInvokedWithPayload();
+			await ChatClient.InitializeWebsocketConnection();
+			Debug.WriteLine("websocket connection initialized");
+			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
 			const string message1 = "Hello World";
+			Debug.WriteLine($"adding message {message1}");
 			var response = await ChatClient.AddMessageAsync(message1);
 			response.Data.AddMessage.Content.Should().Be(message1);
-			tester.Should().HaveReceivedPayload(10.Seconds())
-				.Which.Data.MessageAdded.Content.Should().Be(message1);
+			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
 
 			const string message2 = "How are you?";
 			response = await ChatClient.AddMessageAsync(message2);
 			response.Data.AddMessage.Content.Should().Be(message2);
-			tester.Should().HaveReceivedPayload()
-				.Which.Data.MessageAdded.Content.Should().Be(message2);
+			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
 
 			Debug.WriteLine("disposing subscription...");
 			tester.Dispose(); // does not close the websocket connection
 
 			Debug.WriteLine("creating new subscription...");
 			var tester2 = observable.Monitor();
-			tester2.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10))
-				.Which.Data.MessageAdded.Content.Should().Be(message2);
+			tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
 
 			const string message3 = "lorem ipsum dolor si amet";
 			response = await ChatClient.AddMessageAsync(message3);
 			response.Data.AddMessage.Content.Should().Be(message3);
-			tester2.Should().HaveReceivedPayload()
-				.Which.Data.MessageAdded.Content.Should().Be(message3);
+			tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message3);
 
 			// disposing the client should complete the subscription
 			ChatClient.Dispose();
@@ -229,6 +235,8 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var tester = observable1.Monitor();
 			var tester2 = observable2.Monitor();
 
+			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
 			const string message1 = "Hello World";
 			var response = await ChatClient.AddMessageAsync(message1);
 			response.Data.AddMessage.Content.Should().Be(message1);
@@ -265,7 +273,9 @@ public async void CanHandleConnectionTimeout() {
 			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
 			// configure back-off strategy to allow it to be controlled from within the unit test
 			ChatClient.Options.BackOffStrategy = i => {
+				Debug.WriteLine("back-off strategy: waiting on reconnect blocker");
 				reconnectBlocker.Wait();
+				Debug.WriteLine("back-off strategy: reconnecting...");
 				return TimeSpan.Zero;
 			};
 
@@ -288,23 +298,28 @@ public async void CanHandleConnectionTimeout() {
 				// clear the collection so the next tests on the collection work as expected
 				websocketStates.Clear();
 
+				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
 				const string message1 = "Hello World";
 				var response = await ChatClient.AddMessageAsync(message1);
 				response.Data.AddMessage.Content.Should().Be(message1);
-				tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10))
-					.Which.Data.MessageAdded.Content.Should().Be(message1);
+				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
 
 				Debug.WriteLine("stopping web host...");
 				await Fixture.ShutdownServer();
-				Debug.WriteLine("web host stopped...");
+				Debug.WriteLine("web host stopped");
 
-				errorMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10))
+				errorMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds())
 					.Which.Should().BeOfType<WebSocketException>();
 				websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
-
+				
+				Debug.WriteLine("restarting web host...");
 				await InitializeAsync();
+				Debug.WriteLine("web host started");
 				reconnectBlocker.Set();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10));
+				callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
+				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
 				websocketStates.Should().ContainInOrder(
 					GraphQLWebsocketConnectionState.Disconnected,
 					GraphQLWebsocketConnectionState.Connecting,
@@ -312,7 +327,7 @@ public async void CanHandleConnectionTimeout() {
 
 				// disposing the client should complete the subscription
 				ChatClient.Dispose();
-				tester.Should().HaveCompleted(TimeSpan.FromSeconds(5));
+				tester.Should().HaveCompleted(5.Seconds());
 			}
 		}
 

From 5e83a24551d5e231de8f5f78c8031964421125d3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 3 Mar 2020 12:15:04 +0100
Subject: [PATCH 198/455] add debug output

---
 .../Websocket/GraphQLHttpWebSocket.cs         |  1 +
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  |  7 ++---
 .../Helpers/ObservableTester.cs               | 26 +++++++++++++------
 .../WebsocketTests/Base.cs                    |  8 +++---
 4 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 1f824c8e..ce1d2ff5 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -179,6 +179,7 @@ private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseW
 			if (responseSubject == null || responseSubject.IsDisposed) {
 				// create new response subject
 				responseSubject = new Subject<WebsocketResponseWrapper>();
+				Debug.WriteLine($"creating new response stream {responseSubject.GetHashCode()}");
 
 				// initialize and connect websocket
 				await InitializeWebSocket().ConfigureAwait(false);
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
index f4eeebd5..b74f373b 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -133,9 +133,10 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 						}
 
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-						return cancellationToken.IsCancellationRequested
-							? Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>()
-							: Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
+						if (cancellationToken.IsCancellationRequested)
+							return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
+						else
+							return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
 					}
 					catch (Exception exception) {
 						// wrap all other exceptions to be propagated behind retry
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index ec850d38..00580f14 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Diagnostics;
-using System.Reactive.Concurrency;
-using System.Reactive.Linq;
 using System.Threading;
 using FluentAssertions;
 using FluentAssertions.Execution;
@@ -10,7 +8,6 @@
 namespace GraphQL.Client.Tests.Common.Helpers {
 	public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		private readonly IDisposable subscription;
-		private readonly EventLoopScheduler scheduler;
 		private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim error = new ManualResetEventSlim();
@@ -36,8 +33,7 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
 		public ObservableTester(IObservable<TSubscriptionPayload> observable) {
-			scheduler = new EventLoopScheduler();
-			subscription = observable.SubscribeOn(Scheduler.CurrentThread).ObserveOn(scheduler).Subscribe(
+			subscription = observable.Subscribe(
 				obj => {
 					Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
 					LastPayload = obj;
@@ -48,8 +44,10 @@ public ObservableTester(IObservable<TSubscriptionPayload> observable) {
 					Error = ex;
 					error.Set();
 				},
-				() => completed.Set()
-			);
+				() => {
+					Debug.WriteLine($"observable tester {GetHashCode()}: completed");
+					completed.Set();
+				});
 		}
 
 		/// <summary>
@@ -62,7 +60,6 @@ private void Reset() {
 		/// <inheritdoc />
 		public void Dispose() {
 			subscription?.Dispose();
-			scheduler?.Dispose();
 		}
 
 		public SubscriptionAssertions<TSubscriptionPayload> Should() {
@@ -130,6 +127,19 @@ public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(TimeSpan ti
 			}
 			public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(string because = "", params object[] becauseArgs)
 				=> HaveCompleted(Subject.Timeout, because, becauseArgs);
+
+			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(TimeSpan timeout,
+				string because = "", params object[] becauseArgs) {
+				Execute.Assertion
+					.BecauseOf(because, becauseArgs)
+					.Given(() => Subject.completed.Wait(timeout))
+					.ForCondition(isSet => !isSet)
+					.FailWith("Expected {context:Subscription} not to complete within {0}{reason}, but it did!", timeout);
+
+				return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
+			}
+			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(string because = "", params object[] becauseArgs)
+				=> NotHaveCompleted(Subject.Timeout, because, becauseArgs);
 		}
 	}
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index bcfedb98..062a3071 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -81,7 +81,7 @@ query Long {
 			// unblock the query
 			chatQuery.LongRunningQueryBlocker.Set();
 			// check execution time
-			request.Invoking().ExecutionTime().Should().BeLessThan(100.Milliseconds());
+			request.Invoking().ExecutionTime().Should().BeLessThan(500.Milliseconds());
 			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
 
 			// reset stuff
@@ -93,7 +93,7 @@ query Long {
 			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
 			cts.Cancel();
 			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
-				.ExecutionTime().Should().BeLessThan(100.Milliseconds());
+				.ExecutionTime().Should().BeLessThan(500.Milliseconds());
 
 			// let the server finish its query
 			chatQuery.LongRunningQueryBlocker.Set();
@@ -312,12 +312,12 @@ public async void CanHandleConnectionTimeout() {
 				errorMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds())
 					.Which.Should().BeOfType<WebSocketException>();
 				websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
-				
+
 				Debug.WriteLine("restarting web host...");
 				await InitializeAsync();
 				Debug.WriteLine("web host started");
 				reconnectBlocker.Set();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
+				callbackMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds());
 				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
 				websocketStates.Should().ContainInOrder(

From ce40801cb3c8a77651e09d3641093d8c637ff628 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 4 Mar 2020 14:52:26 +0100
Subject: [PATCH 199/455] consolidate naming, optimize threading in websocket

---
 .../IGraphQLWebsocketJsonSerializer.cs        |  2 +-
 ...eWrapper.cs => WebsocketMessageWrapper.cs} |  2 +-
 .../NewtonsoftJsonSerializer.cs               |  4 +-
 .../SystemTextJsonSerializer.cs               |  4 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 91 +++++++++++--------
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  | 11 ++-
 .../Helpers/ObservableTester.cs               |  4 +-
 .../WebsocketTests/Base.cs                    |  2 +-
 8 files changed, 68 insertions(+), 52 deletions(-)
 rename src/GraphQL.Client.Abstractions.Websocket/{WebsocketResponseWrapper.cs => WebsocketMessageWrapper.cs} (69%)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index e2f445f5..376f45b6 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -10,7 +10,7 @@ namespace GraphQL.Client.Abstractions.Websocket
     public interface IGraphQLWebsocketJsonSerializer: IGraphQLJsonSerializer {
 	    byte[] SerializeToBytes(GraphQLWebSocketRequest request);
 
-	    Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
+	    Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
 	    GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
 
 	}
diff --git a/src/GraphQL.Client.Abstractions.Websocket/WebsocketResponseWrapper.cs b/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
similarity index 69%
rename from src/GraphQL.Client.Abstractions.Websocket/WebsocketResponseWrapper.cs
rename to src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
index 5e90a38f..2a27677e 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/WebsocketResponseWrapper.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
@@ -1,7 +1,7 @@
 using System.Runtime.Serialization;
 
 namespace GraphQL.Client.Abstractions.Websocket {
-	public class WebsocketResponseWrapper : GraphQLWebSocketResponse {
+	public class WebsocketMessageWrapper : GraphQLWebSocketResponse {
 
 		[IgnoreDataMember]
 		public byte[] MessageBytes { get; set; }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index a40ad456..7194a547 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -42,8 +42,8 @@ public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest re
 			return Encoding.UTF8.GetBytes(json);
 		}
 
-		public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
-			return DeserializeFromUtf8Stream<WebsocketResponseWrapper>(stream);
+		public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
+			return DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
 		}
 
 		public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 420a8522..62be2e37 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -45,8 +45,8 @@ public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest re
 		    return JsonSerializer.SerializeToUtf8Bytes(new GraphQLWebSocketRequest(request), Options);
 	    }
 
-	    public Task<WebsocketResponseWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
-		    return JsonSerializer.DeserializeAsync<WebsocketResponseWrapper>(stream, Options).AsTask();
+	    public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
+		    return JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
 		}
 
 	    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index ce1d2ff5..fec8b75d 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -3,6 +3,7 @@
 using System.IO;
 using System.Net.Http;
 using System.Net.WebSockets;
+using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
@@ -23,9 +24,11 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly BehaviorSubject<GraphQLWebsocketConnectionState> stateSubject =
 			new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
 		private readonly IDisposable requestSubscription;
+		private readonly EventLoopScheduler receiveLoopScheduler = new EventLoopScheduler();
+		private readonly EventLoopScheduler sendLoopScheduler = new EventLoopScheduler();
 
 		private int connectionAttempt = 0;
-		private Subject<WebsocketResponseWrapper> responseSubject;
+		private Subject<WebsocketMessageWrapper> incomingMessagesSubject;
 		private GraphQLHttpClientOptions Options => client.Options;
 
 #if NETFRAMEWORK
@@ -39,27 +42,28 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
 		public IObservable<GraphQLWebsocketConnectionState> ConnectionState => stateSubject.DistinctUntilChanged();
 
-		public IObservable<WebsocketResponseWrapper> ResponseStream { get; }
+		public IObservable<WebsocketMessageWrapper> ResponseStream { get; }
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
 			cancellationToken = cancellationTokenSource.Token;
 			this.webSocketUri = webSocketUri;
 			this.client = client;
 			buffer = new ArraySegment<byte>(new byte[8192]);
-			ResponseStream = _createResponseStream();
+			ResponseStream = GetMessageStream();
 
-			requestSubscription = requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
+			requestSubscription = requestSubject
+				.ObserveOn(sendLoopScheduler)
+				.Subscribe(async request => await SendWebSocketRequest(request));
 		}
-
-
+		
 		#region Send requests
 
-		public Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
+		public Task QueueWebSocketRequest(GraphQLWebSocketRequest request) {
 			requestSubject.OnNext(request);
 			return request.SendTask();
 		}
 
-		private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request) {
+		private async Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
 			try {
 				if (cancellationToken.IsCancellationRequested) {
 					request.SendCanceled();
@@ -128,13 +132,13 @@ public Task InitializeWebSocket() {
 				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
 				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 #endif
-				return initializeWebSocketTask = _connectAsync(cancellationToken);
+				return initializeWebSocketTask = ConnectAsync(cancellationToken);
 			}
 		}
 
-		private async Task _connectAsync(CancellationToken token) {
+		private async Task ConnectAsync(CancellationToken token) {
 			try {
-				await _backOff().ConfigureAwait(false);
+				await BackOff().ConfigureAwait(false);
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
 				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
@@ -155,74 +159,79 @@ private async Task _connectAsync(CancellationToken token) {
 		/// delay the next connection attempt using <see cref="GraphQLHttpClientOptions.BackOffStrategy"/>
 		/// </summary>
 		/// <returns></returns>
-		private Task _backOff() {
+		private Task BackOff() {
 			connectionAttempt++;
 
 			if (connectionAttempt == 1) return Task.CompletedTask;
 
 			var delay = Options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
 			Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
-			return Task.Delay(delay);
+			return Task.Delay(delay, cancellationToken);
 		}
 
 
-		private IObservable<WebsocketResponseWrapper> _createResponseStream() {
-			return Observable.Create<WebsocketResponseWrapper>(_createResultStream)
+		private IObservable<WebsocketMessageWrapper> GetMessageStream() {
+			return Observable.Create<WebsocketMessageWrapper>(CreateMessageStream)
 				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
-				.Catch<WebsocketResponseWrapper, OperationCanceledException>(exception =>
-					Observable.Empty<WebsocketResponseWrapper>());
+				.Catch<WebsocketMessageWrapper, OperationCanceledException>(exception =>
+					Observable.Empty<WebsocketMessageWrapper>());
 		}
 
-		private async Task<IDisposable> _createResultStream(IObserver<WebsocketResponseWrapper> observer, CancellationToken token) {
-			cancellationToken.ThrowIfCancellationRequested();
+		private async Task<IDisposable> CreateMessageStream(IObserver<WebsocketMessageWrapper> observer, CancellationToken token) {
+			var cts = CancellationTokenSource.CreateLinkedTokenSource(token, cancellationToken);
+			cts.Token.ThrowIfCancellationRequested();
 
-			if (responseSubject == null || responseSubject.IsDisposed) {
+			if (incomingMessagesSubject == null || incomingMessagesSubject.IsDisposed) {
 				// create new response subject
-				responseSubject = new Subject<WebsocketResponseWrapper>();
-				Debug.WriteLine($"creating new response stream {responseSubject.GetHashCode()}");
+				incomingMessagesSubject = new Subject<WebsocketMessageWrapper>();
+				Debug.WriteLine($"creating new incoming message stream {incomingMessagesSubject.GetHashCode()}");
 
 				// initialize and connect websocket
 				await InitializeWebSocket().ConfigureAwait(false);
 
 				// loop the receive task and subscribe the created subject to the results 
-				Observable.Defer(() => _getReceiveTask().ToObservable()).Repeat().Subscribe(responseSubject);
+				Observable
+					.Defer(() => GetReceiveTask().ToObservable())
+					.Repeat()
+					.SubscribeOn(receiveLoopScheduler)
+					.Subscribe(incomingMessagesSubject);
 
 				// dispose the subject on any error or completion (will be recreated) 
-				responseSubject.Subscribe(_ => { }, ex => {
+				incomingMessagesSubject.Subscribe(_ => { }, ex => {
 					exceptionSubject.OnNext(ex);
-					responseSubject?.Dispose();
-					responseSubject = null;
+					incomingMessagesSubject?.Dispose();
+					incomingMessagesSubject = null;
 					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 				},
 				() => {
-					responseSubject?.Dispose();
-					responseSubject = null;
+					incomingMessagesSubject?.Dispose();
+					incomingMessagesSubject = null;
 					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 				});
 			}
 
 			return new CompositeDisposable
 			(
-				responseSubject.Subscribe(observer),
+				incomingMessagesSubject.Subscribe(observer),
 				Disposable.Create(() => {
-					Debug.WriteLine($"response stream {responseSubject.GetHashCode()} disposed");
+					Debug.WriteLine($"incoming message stream {incomingMessagesSubject.GetHashCode()} disposed");
 				})
 			);
 		}
 
-		private Task<WebsocketResponseWrapper> receiveAsyncTask = null;
+		private Task<WebsocketMessageWrapper> receiveAsyncTask = null;
 		private readonly object receiveTaskLocker = new object();
 		/// <summary>
 		/// wrapper method to pick up the existing request task if already running
 		/// </summary>
 		/// <returns></returns>
-		private Task<WebsocketResponseWrapper> _getReceiveTask() {
+		private Task<WebsocketMessageWrapper> GetReceiveTask() {
 			lock (receiveTaskLocker) {
 				cancellationToken.ThrowIfCancellationRequested();
 				if (receiveAsyncTask == null ||
 					receiveAsyncTask.IsFaulted ||
 					receiveAsyncTask.IsCompleted)
-					receiveAsyncTask = _receiveResultAsync();
+					receiveAsyncTask = ReceiveWebsocketMessagesAsync();
 			}
 
 			return receiveAsyncTask;
@@ -232,9 +241,9 @@ private Task<WebsocketResponseWrapper> _getReceiveTask() {
 		/// read a single message from the websocket
 		/// </summary>
 		/// <returns></returns>
-		private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
+		private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync() {
 			try {
-				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
+				Debug.WriteLine($"waiting for data on websocket {clientWebSocket.GetHashCode()} ...");
 
 				using (var ms = new MemoryStream()) {
 					WebSocketReceiveResult webSocketReceiveResult = null;
@@ -251,6 +260,7 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
 						var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
 						response.MessageBytes = ms.ToArray();
+						Debug.WriteLine($"{response.MessageBytes.Length} bytes received on websocket {clientWebSocket.GetHashCode()} ...");
 						return response;
 					}
 					else {
@@ -264,7 +274,7 @@ private async Task<WebsocketResponseWrapper> _receiveResultAsync() {
 			}
 		}
 
-		private async Task _closeAsync() {
+		private async Task CloseAsync() {
 			if (clientWebSocket == null)
 				return;
 
@@ -304,12 +314,15 @@ private async Task CompleteAsync() {
 			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
 			if (!cancellationTokenSource.IsCancellationRequested)
 				cancellationTokenSource.Cancel();
-			await _closeAsync().ConfigureAwait(false);
+			await CloseAsync().ConfigureAwait(false);
 			requestSubscription?.Dispose();
 			clientWebSocket?.Dispose();
 
-			responseSubject?.OnCompleted();
-			responseSubject?.Dispose();
+			incomingMessagesSubject?.OnCompleted();
+			incomingMessagesSubject?.Dispose();
+
+			sendLoopScheduler?.Dispose();
+			receiveLoopScheduler?.Dispose();
 
 			stateSubject?.OnCompleted();
 			stateSubject?.Dispose();
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
index b74f373b..11f29bfc 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -4,6 +4,7 @@
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
@@ -85,7 +86,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 
 							try {
 								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-								await graphQlHttpWebSocket.SendWebSocketRequest(closeRequest).ConfigureAwait(false);
+								await graphQlHttpWebSocket.QueueWebSocketRequest(closeRequest).ConfigureAwait(false);
 							}
 							// do not break on disposing
 							catch (OperationCanceledException) { }
@@ -95,7 +96,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 					// send connection init
 					Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
 					try {
-						await graphQlHttpWebSocket.SendWebSocketRequest(initRequest).ConfigureAwait(false);
+						await graphQlHttpWebSocket.QueueWebSocketRequest(initRequest).ConfigureAwait(false);
 					}
 					catch (Exception e) {
 						Console.WriteLine(e);
@@ -105,7 +106,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
 					// send subscription request
 					try {
-						await graphQlHttpWebSocket.SendWebSocketRequest(startRequest).ConfigureAwait(false);
+						await graphQlHttpWebSocket.QueueWebSocketRequest(startRequest).ConfigureAwait(false);
 					}
 					catch (Exception e) {
 						Console.WriteLine(e);
@@ -198,7 +199,7 @@ internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 					Debug.WriteLine($"submitting request {websocketRequest.Id}");
 					// send request
 					try {
-						await graphQlHttpWebSocket.SendWebSocketRequest(websocketRequest).ConfigureAwait(false);
+						await graphQlHttpWebSocket.QueueWebSocketRequest(websocketRequest).ConfigureAwait(false);
 					}
 					catch (Exception e) {
 						Console.WriteLine(e);
@@ -210,7 +211,7 @@ internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
 			.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
 				Observable.Empty<GraphQLResponse<TResponse>>())
-			.FirstOrDefaultAsync()
+			.FirstAsync()
 			.ToTask(cancellationToken);
 		}
 	}
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 00580f14..4d070e71 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Diagnostics;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
 using System.Threading;
 using FluentAssertions;
 using FluentAssertions.Execution;
@@ -33,7 +35,7 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
 		public ObservableTester(IObservable<TSubscriptionPayload> observable) {
-			subscription = observable.Subscribe(
+			subscription = observable.SubscribeOn(Scheduler.Default).Subscribe(
 				obj => {
 					Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
 					LastPayload = obj;
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 062a3071..662ca85b 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -317,7 +317,7 @@ public async void CanHandleConnectionTimeout() {
 				await InitializeAsync();
 				Debug.WriteLine("web host started");
 				reconnectBlocker.Set();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds());
+				callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
 				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
 				websocketStates.Should().ContainInOrder(

From a6dbfb9732515653bd3d65e3ed5522f555ff0108 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 4 Mar 2020 15:02:47 +0100
Subject: [PATCH 200/455] allow 500ms for cancellation

---
 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 92e61f8d..773e4feb 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -173,7 +173,7 @@ query Long {
 			// unblock the query
 			chatQuery.LongRunningQueryBlocker.Set();
 			// check execution time
-			request.Invoking().ExecutionTime().Should().BeLessThan(100.Milliseconds());
+			request.Invoking().ExecutionTime().Should().BeLessThan(500.Milliseconds());
 			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
 
 			// reset stuff
@@ -185,7 +185,7 @@ query Long {
 			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
 			cts.Cancel();
 			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
-				.ExecutionTime().Should().BeLessThan(100.Milliseconds());
+				.ExecutionTime().Should().BeLessThan(500.Milliseconds());
 
 			// let the server finish its query
 			chatQuery.LongRunningQueryBlocker.Set();

From b501c04e51471cbfd339464a284bf72e38ca107a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 4 Mar 2020 15:09:01 +0100
Subject: [PATCH 201/455] extend default timeout

---
 tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs | 2 +-
 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 4d070e71..1d468deb 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -17,7 +17,7 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		/// <summary>
 		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
 		/// </summary>
-		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
 
 		/// <summary>
 		/// Indicates that an update has been received since the last <see cref="_reset"/>
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 773e4feb..415c7f32 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -169,7 +169,7 @@ query Long {
 			// start request
 			request.Start();
 			// wait until the query has reached the server
-			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
 			// unblock the query
 			chatQuery.LongRunningQueryBlocker.Set();
 			// check execution time
@@ -182,7 +182,7 @@ query Long {
 
 			// cancellation test
 			request.Start();
-			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
 			cts.Cancel();
 			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
 				.ExecutionTime().Should().BeLessThan(500.Milliseconds());

From 7837eddd97a8a11fcc14573c6aeb5efb83cf6cb8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 09:28:13 +0100
Subject: [PATCH 202/455] remove ConfigureAwait

---
 .../GraphQLLocalExecutionClient.cs            |  8 +--
 .../Websocket/GraphQLHttpWebSocket.cs         | 66 +++++++++++--------
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  | 21 +++---
 .../BaseSerializerTest.cs                     |  6 +-
 .../Helpers/CallbackMonitor.cs                | 43 +++---------
 .../Helpers/ObservableTester.cs               | 12 +++-
 .../QueryAndMutationTests/Base.cs             |  4 +-
 .../WebsocketTests/Base.cs                    |  1 +
 8 files changed, 81 insertions(+), 80 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index d73e2cc6..6624020c 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -76,11 +76,11 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 	    #region Private Methods
 
 	    private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken) {
-		    var executionResult = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
-		    return await ExecutionResultToGraphQLResponse<TResponse>(executionResult, cancellationToken).ConfigureAwait(false);
+		    var executionResult = await ExecuteAsync(request, cancellationToken);
+		    return await ExecutionResultToGraphQLResponse<TResponse>(executionResult, cancellationToken);
 	    }
 	    private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-		    var result = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+		    var result = await ExecuteAsync(request, cancellationToken);
 		    return ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault()?
 			    .SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
 	    }
@@ -100,7 +100,7 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
 			    options.Query = request.Query;
 			    options.Inputs = inputs;
 			    options.CancellationToken = cancellationToken;
-		    }).ConfigureAwait(false);
+		    });
 
 		    return result;
 	    }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index fec8b75d..fccf7894 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -14,6 +14,9 @@
 
 namespace GraphQL.Client.Http.Websocket {
 	internal class GraphQLHttpWebSocket : IDisposable {
+
+		#region Private fields
+
 		private readonly Uri webSocketUri;
 		private readonly GraphQLHttpClient client;
 		private readonly ArraySegment<byte> buffer;
@@ -29,6 +32,7 @@ internal class GraphQLHttpWebSocket : IDisposable {
 
 		private int connectionAttempt = 0;
 		private Subject<WebsocketMessageWrapper> incomingMessagesSubject;
+		private IDisposable incomingMessagesDisposable;
 		private GraphQLHttpClientOptions Options => client.Options;
 
 #if NETFRAMEWORK
@@ -37,11 +41,11 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private ClientWebSocket clientWebSocket = null;
 #endif
 
-
+		#endregion
+		
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
 		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
 		public IObservable<GraphQLWebsocketConnectionState> ConnectionState => stateSubject.DistinctUntilChanged();
-
 		public IObservable<WebsocketMessageWrapper> ResponseStream { get; }
 
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
@@ -50,6 +54,8 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
 			this.client = client;
 			buffer = new ArraySegment<byte>(new byte[8192]);
 			ResponseStream = GetMessageStream();
+			receiveLoopScheduler.Schedule(() =>
+				Debug.WriteLine($"receive loop scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
 			requestSubscription = requestSubject
 				.ObserveOn(sendLoopScheduler)
@@ -70,13 +76,13 @@ private async Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
 					return;
 				}
 
-				await InitializeWebSocket().ConfigureAwait(false);
+				await InitializeWebSocket();
 				var requestBytes = Options.JsonSerializer.SerializeToBytes(request);
 				await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
 					true,
-					cancellationToken).ConfigureAwait(false);
+					cancellationToken);
 				request.SendCompleted();
 			}
 			catch (Exception e) {
@@ -138,10 +144,10 @@ public Task InitializeWebSocket() {
 
 		private async Task ConnectAsync(CancellationToken token) {
 			try {
-				await BackOff().ConfigureAwait(false);
+				await BackOff();
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
 				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
-				await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+				await clientWebSocket.ConnectAsync(webSocketUri, token);
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
 				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
 				await (Options.OnWebsocketConnected?.Invoke(client) ?? Task.CompletedTask);
@@ -181,42 +187,49 @@ private async Task<IDisposable> CreateMessageStream(IObserver<WebsocketMessageWr
 			var cts = CancellationTokenSource.CreateLinkedTokenSource(token, cancellationToken);
 			cts.Token.ThrowIfCancellationRequested();
 
+
 			if (incomingMessagesSubject == null || incomingMessagesSubject.IsDisposed) {
 				// create new response subject
 				incomingMessagesSubject = new Subject<WebsocketMessageWrapper>();
 				Debug.WriteLine($"creating new incoming message stream {incomingMessagesSubject.GetHashCode()}");
 
 				// initialize and connect websocket
-				await InitializeWebSocket().ConfigureAwait(false);
+				await InitializeWebSocket();
 
 				// loop the receive task and subscribe the created subject to the results 
-				Observable
+				var receiveLoopSubscription = Observable
 					.Defer(() => GetReceiveTask().ToObservable())
 					.Repeat()
-					.SubscribeOn(receiveLoopScheduler)
 					.Subscribe(incomingMessagesSubject);
+				
+				incomingMessagesDisposable = new CompositeDisposable(
+					incomingMessagesSubject,
+					receiveLoopSubscription,
+					Disposable.Create(() => {
+						Debug.WriteLine($"incoming message stream {incomingMessagesSubject.GetHashCode()} disposed");
+					}));
 
 				// dispose the subject on any error or completion (will be recreated) 
 				incomingMessagesSubject.Subscribe(_ => { }, ex => {
 					exceptionSubject.OnNext(ex);
-					incomingMessagesSubject?.Dispose();
+					incomingMessagesDisposable?.Dispose();
 					incomingMessagesSubject = null;
 					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 				},
 				() => {
-					incomingMessagesSubject?.Dispose();
+					incomingMessagesDisposable?.Dispose();
 					incomingMessagesSubject = null;
 					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 				});
 			}
 
-			return new CompositeDisposable
-			(
-				incomingMessagesSubject.Subscribe(observer),
-				Disposable.Create(() => {
-					Debug.WriteLine($"incoming message stream {incomingMessagesSubject.GetHashCode()} disposed");
-				})
-			);
+			var subscription = new CompositeDisposable(incomingMessagesSubject.Subscribe(observer));
+			var hashCode = subscription.GetHashCode();
+			subscription.Add(Disposable.Create(() => {
+				Debug.WriteLine($"incoming message subscription {hashCode} disposed");
+			}));
+			Debug.WriteLine($"new incoming message subscription {hashCode} created");
+			return subscription;
 		}
 
 		private Task<WebsocketMessageWrapper> receiveAsyncTask = null;
@@ -243,7 +256,7 @@ private Task<WebsocketMessageWrapper> GetReceiveTask() {
 		/// <returns></returns>
 		private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync() {
 			try {
-				Debug.WriteLine($"waiting for data on websocket {clientWebSocket.GetHashCode()} ...");
+				Debug.WriteLine($"waiting for data on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
 
 				using (var ms = new MemoryStream()) {
 					WebSocketReceiveResult webSocketReceiveResult = null;
@@ -260,7 +273,7 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync() {
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
 						var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
 						response.MessageBytes = ms.ToArray();
-						Debug.WriteLine($"{response.MessageBytes.Length} bytes received on websocket {clientWebSocket.GetHashCode()} ...");
+						Debug.WriteLine($"{response.MessageBytes.Length} bytes received on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
 						return response;
 					}
 					else {
@@ -287,7 +300,7 @@ private async Task CloseAsync() {
 			}
 
 			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false);
+			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
 			stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
 		}
 
@@ -314,15 +327,12 @@ private async Task CompleteAsync() {
 			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
 			if (!cancellationTokenSource.IsCancellationRequested)
 				cancellationTokenSource.Cancel();
-			await CloseAsync().ConfigureAwait(false);
+			await CloseAsync();
 			requestSubscription?.Dispose();
 			clientWebSocket?.Dispose();
 
 			incomingMessagesSubject?.OnCompleted();
-			incomingMessagesSubject?.Dispose();
-
-			sendLoopScheduler?.Dispose();
-			receiveLoopScheduler?.Dispose();
+			incomingMessagesDisposable?.Dispose();
 
 			stateSubject?.OnCompleted();
 			stateSubject?.Dispose();
@@ -330,6 +340,10 @@ private async Task CompleteAsync() {
 			exceptionSubject?.OnCompleted();
 			exceptionSubject?.Dispose();
 			cancellationTokenSource.Dispose();
+
+			sendLoopScheduler?.Dispose();
+			receiveLoopScheduler?.Dispose();
+
 			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
 		}
 #endregion
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
index 11f29bfc..82fc6f2d 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Net.WebSockets;
+using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
@@ -19,6 +20,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 			CancellationToken cancellationToken = default) {
 			return Observable.Defer(() =>
 				Observable.Create<GraphQLResponse<TResponse>>(async observer => {
+					Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
 					await client.Options.PreprocessRequest(request, client);
 					var startRequest = new GraphQLWebSocketRequest {
 						Id = Guid.NewGuid().ToString("N"),
@@ -47,7 +49,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 									}
 
 									// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-									Debug.WriteLine($"received payload on subscription {startRequest.Id}");
+									Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
 									var typedResponse =
 										client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
 											response.MessageBytes);
@@ -71,7 +73,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 
 					try {
 						// initialize websocket (completes immediately if socket is already open)
-						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+						await graphQlHttpWebSocket.InitializeWebSocket();
 					}
 					catch (Exception e) {
 						// subscribe observer to failed observable
@@ -86,7 +88,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 
 							try {
 								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-								await graphQlHttpWebSocket.QueueWebSocketRequest(closeRequest).ConfigureAwait(false);
+								await graphQlHttpWebSocket.QueueWebSocketRequest(closeRequest);
 							}
 							// do not break on disposing
 							catch (OperationCanceledException) { }
@@ -96,7 +98,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 					// send connection init
 					Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
 					try {
-						await graphQlHttpWebSocket.QueueWebSocketRequest(initRequest).ConfigureAwait(false);
+						await graphQlHttpWebSocket.QueueWebSocketRequest(initRequest);
 					}
 					catch (Exception e) {
 						Console.WriteLine(e);
@@ -106,7 +108,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
 					// send subscription request
 					try {
-						await graphQlHttpWebSocket.QueueWebSocketRequest(startRequest).ConfigureAwait(false);
+						await graphQlHttpWebSocket.QueueWebSocketRequest(startRequest);
 					}
 					catch (Exception e) {
 						Console.WriteLine(e);
@@ -136,8 +138,10 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
 						if (cancellationToken.IsCancellationRequested)
 							return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
-						else
+						else {
+							Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
 							return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
+						}
 					}
 					catch (Exception exception) {
 						// wrap all other exceptions to be propagated behind retry
@@ -148,6 +152,7 @@ internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream
 				.Retry()
 				// unwrap and push results or throw wrapped exceptions
 				.SelectMany(t => {
+					Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId}");
 					// if the result contains an exception, throw it on the observable
 					if (t.Item2 != null)
 						return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
@@ -185,7 +190,7 @@ internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 
 					try {
 						// intialize websocket (completes immediately if socket is already open)
-						await graphQlHttpWebSocket.InitializeWebSocket().ConfigureAwait(false);
+						await graphQlHttpWebSocket.InitializeWebSocket();
 					}
 					catch (Exception e) {
 						// subscribe observer to failed observable
@@ -199,7 +204,7 @@ internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
 					Debug.WriteLine($"submitting request {websocketRequest.Id}");
 					// send request
 					try {
-						await graphQlHttpWebSocket.QueueWebSocketRequest(websocketRequest).ConfigureAwait(false);
+						await graphQlHttpWebSocket.QueueWebSocketRequest(websocketRequest);
 					}
 					catch (Exception e) {
 						Console.WriteLine(e);
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index a07f38f1..579e756e 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -46,7 +46,7 @@ public async void CanDeserializeExtensions() {
 
 			var response = await ChatClient.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
 					() => new { extensionsTest = "" })
-				.ConfigureAwait(false);
+				;
 
 			response.Errors.Should().NotBeNull();
 			response.Errors.Should().ContainSingle();
@@ -76,7 +76,7 @@ query Droid($id: String!) {
 				"Human");
 
 			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-				.ConfigureAwait(false);
+				;
 
 			Assert.Null(response.Errors);
 			Assert.Equal(name, response.Data.Human.Name);
@@ -85,7 +85,7 @@ query Droid($id: String!) {
 		[Fact]
 		public async void CanDoSerializationWithPredefinedTypes() {
 				const string message = "some random testing message";
-				var response = await ChatClient.AddMessageAsync(message).ConfigureAwait(false);
+				var response = await ChatClient.AddMessageAsync(message);
 
 				Assert.Equal(message, response.Data.AddMessage.Content);
 		}
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index 4b623ac6..2a27a259 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.Threading;
 using FluentAssertions;
 using FluentAssertions.Execution;
@@ -24,40 +25,10 @@ public class CallbackMonitor<T> {
 
 		public void Invoke(T param) {
 			LastPayload = param;
+			Debug.WriteLine($"CallbackMonitor invoke handler thread id: {Thread.CurrentThread.ManagedThreadId}");
 			callbackInvoked.Set();
 		}
-
-		/// <summary>
-		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
-		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
-		/// </summary>
-		/// <param name="assertPayload">action to assert the contents of the payload</param>
-		public void CallbackShouldHaveBeenInvoked(Action<T> assertPayload = null, TimeSpan? timeout = null) {
-			try {
-				callbackInvoked.Wait(timeout ?? Timeout).Should().BeTrue("because the callback method should have been invoked (timeout: {0} s)",
-					(timeout ?? Timeout).TotalSeconds);
-
-				assertPayload?.Invoke(LastPayload);
-			}
-			finally {
-				Reset();
-			}
-		}
-
-		/// <summary>
-		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
-		/// </summary>
-		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
-		public void CallbackShouldNotHaveBeenInvoked(TimeSpan? timeout = null) {
-			if (!timeout.HasValue) timeout = TimeSpan.FromMilliseconds(100);
-			try {
-				callbackInvoked.Wait(timeout.Value).Should().BeFalse("because the callback method should not have been invoked");
-			}
-			finally {
-				Reset();
-			}
-		}
-
+		
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
@@ -65,8 +36,7 @@ public void Reset() {
 			LastPayload = default(T);
 			callbackInvoked.Reset();
 		}
-
-
+		
 		public CallbackAssertions<T> Should() {
 			return new CallbackAssertions<T>(this);
 		}
@@ -82,7 +52,10 @@ public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvoke
 				string because = "", params object[] becauseArgs) {
 				Execute.Assertion
 					.BecauseOf(because, becauseArgs)
-					.Given(() => Subject.callbackInvoked.Wait(timeout))
+					.Given(() => {
+						Debug.WriteLine($"HaveBeenInvokedWithPayload thread id: {Thread.CurrentThread.ManagedThreadId}");
+						return Subject.callbackInvoked.Wait(timeout);
+					})
 					.ForCondition(isSet => isSet)
 					.FailWith("Expected {context:callback} to be invoked{reason}, but did not receive a call within {0}", timeout);
 
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 1d468deb..86ec3a1f 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -13,6 +13,8 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim error = new ManualResetEventSlim();
+		private readonly EventLoopScheduler subscriptionScheduler = new EventLoopScheduler();
+		private readonly EventLoopScheduler observeScheduler = new EventLoopScheduler();
 
 		/// <summary>
 		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
@@ -35,7 +37,13 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
 		public ObservableTester(IObservable<TSubscriptionPayload> observable) {
-			subscription = observable.SubscribeOn(Scheduler.Default).Subscribe(
+			subscriptionScheduler.Schedule(() =>
+				Debug.WriteLine($"Subscription scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
+
+			observeScheduler.Schedule(() =>
+				Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
+
+			subscription = observable.SubscribeOn(subscriptionScheduler).ObserveOn(observeScheduler).Subscribe(
 				obj => {
 					Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
 					LastPayload = obj;
@@ -62,6 +70,8 @@ private void Reset() {
 		/// <inheritdoc />
 		public void Dispose() {
 			subscription?.Dispose();
+			subscriptionScheduler.Dispose();
+			observeScheduler.Dispose();
 		}
 
 		public SubscriptionAssertions<TSubscriptionPayload> Should() {
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 415c7f32..c25117ca 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -145,9 +145,7 @@ public async void PreprocessHttpRequestMessageIsCalled() {
 
 			var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
 			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
-			callbackTester.CallbackShouldHaveBeenInvoked(message => {
-				Assert.Equal(defaultHeaders, message.Headers);
-			});
+			callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
 			Assert.Null(response.Errors);
 			Assert.Equal("Luke", response.Data.Human.Name);
 		}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 662ca85b..47d2e5e8 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -284,6 +284,7 @@ public async void CanHandleConnectionTimeout() {
 			using (ChatClient.WebsocketConnectionState.Subscribe(websocketStates.Enqueue)) {
 				websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
 
+				Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
 				Debug.WriteLine("creating subscription stream");
 				var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, errorMonitor.Invoke);
 

From 2c4aec72b13d29ada7c6e13a2abb0aa9f3422cc0 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 10:06:56 +0100
Subject: [PATCH 203/455] eliminate helpers class

---
 src/GraphQL.Client/GraphQLHttpClient.cs       |   6 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 275 ++++++++++++++++--
 .../Websocket/GraphQLHttpWebsocketHelpers.cs  | 223 --------------
 3 files changed, 258 insertions(+), 246 deletions(-)
 delete mode 100644 src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index a4da13c6..30e85fd0 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -66,7 +66,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 		/// <inheritdoc />
 		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.SendRequest<TResponse>(request, this, cancellationToken)
+				? this.graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken)
 				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
@@ -85,7 +85,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			if (subscriptionStreams.ContainsKey(key))
 				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, this, cancellationToken: cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
 
 			subscriptionStreams.TryAdd(key, observable);
 			return observable;
@@ -101,7 +101,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 			if (subscriptionStreams.ContainsKey(key))
 				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, this, exceptionHandler, cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
 			subscriptionStreams.TryAdd(key, observable);
 			return observable;
 		}
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index fccf7894..61462a10 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -20,8 +20,8 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly Uri webSocketUri;
 		private readonly GraphQLHttpClient client;
 		private readonly ArraySegment<byte> buffer;
-		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-		private readonly CancellationToken cancellationToken;
+		private readonly CancellationTokenSource internalCancellationTokenSource = new CancellationTokenSource();
+		private readonly CancellationToken internalCancellationToken;
 		private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
 		private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
 		private readonly BehaviorSubject<GraphQLWebsocketConnectionState> stateSubject =
@@ -34,6 +34,9 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private Subject<WebsocketMessageWrapper> incomingMessagesSubject;
 		private IDisposable incomingMessagesDisposable;
 		private GraphQLHttpClientOptions Options => client.Options;
+		
+		private Task initializeWebSocketTask = Task.CompletedTask;
+		private readonly object initializeLock = new object();
 
 #if NETFRAMEWORK
 		private WebSocket clientWebSocket = null;
@@ -42,18 +45,39 @@ internal class GraphQLHttpWebSocket : IDisposable {
 #endif
 
 		#endregion
+
 		
+		#region Public properties
+
+		/// <summary>
+		/// The current websocket state
+		/// </summary>
 		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
+
+		/// <summary>
+		/// Publishes all errors which occur within the receive pipeline
+		/// </summary>
 		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
+
+		/// <summary>
+		/// Publishes the connection state of the <see cref="GraphQLHttpWebSocket"/>
+		/// </summary>
 		public IObservable<GraphQLWebsocketConnectionState> ConnectionState => stateSubject.DistinctUntilChanged();
-		public IObservable<WebsocketMessageWrapper> ResponseStream { get; }
 
+		/// <summary>
+		/// Publishes all messages which are received on the websocket
+		/// </summary>
+		public IObservable<WebsocketMessageWrapper> IncomingMessageStream { get; }
+
+		#endregion
+
+		
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
-			cancellationToken = cancellationTokenSource.Token;
+			internalCancellationToken = internalCancellationTokenSource.Token;
 			this.webSocketUri = webSocketUri;
 			this.client = client;
 			buffer = new ArraySegment<byte>(new byte[8192]);
-			ResponseStream = GetMessageStream();
+			IncomingMessageStream = GetMessageStream();
 			receiveLoopScheduler.Schedule(() =>
 				Debug.WriteLine($"receive loop scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
@@ -61,9 +85,223 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
 				.ObserveOn(sendLoopScheduler)
 				.Subscribe(async request => await SendWebSocketRequest(request));
 		}
-		
+
+
 		#region Send requests
 
+		/// <summary>
+		/// Create a new subscription stream
+		/// </summary>
+		/// <typeparam name="TResponse">the response type</typeparam>
+		/// <param name="request">the <see cref="GraphQLRequest"/> to start the subscription</param>
+		/// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
+		/// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
+		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler = null) {
+			return Observable.Defer(() =>
+				Observable.Create<GraphQLResponse<TResponse>>(async observer => {
+					Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
+					await client.Options.PreprocessRequest(request, client);
+					var startRequest = new GraphQLWebSocketRequest {
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GraphQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var closeRequest = new GraphQLWebSocketRequest {
+						Id = startRequest.Id,
+						Type = GraphQLWebSocketMessageType.GQL_STOP
+					};
+					var initRequest = new GraphQLWebSocketRequest {
+						Id = startRequest.Id,
+						Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+					};
+
+					var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
+						IncomingMessageStream
+							// ignore null values and messages for other requests
+							.Where(response => response != null && response.Id == startRequest.Id)
+							.Subscribe(response => {
+								// terminate the sequence when a 'complete' message is received
+								if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE) {
+									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+									o.OnCompleted();
+									return;
+								}
+
+								// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+								Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+								var typedResponse =
+									client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+										response.MessageBytes);
+								o.OnNext(typedResponse.Payload);
+
+								// in case of a GraphQL error, terminate the sequence after the response has been posted
+								if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR) {
+									Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+									o.OnCompleted();
+								}
+								},
+								e => {
+									Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
+									o.OnError(e);
+								},
+								() => {
+									Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+									o.OnCompleted();
+								})
+					);
+
+					try {
+						// initialize websocket (completes immediately if socket is already open)
+						await InitializeWebSocket();
+					}
+					catch (Exception e) {
+						// subscribe observer to failed observable
+						return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+					}
+
+					var disposable = new CompositeDisposable(
+						observable.Subscribe(observer),
+						Disposable.Create(async () => {
+							// only try to send close request on open websocket
+							if (WebSocketState != WebSocketState.Open) return;
+
+							try {
+								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+								await QueueWebSocketRequest(closeRequest);
+							}
+							// do not break on disposing
+							catch (OperationCanceledException) { }
+						})
+					);
+
+					// send connection init
+					Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
+					try {
+						await QueueWebSocketRequest(initRequest);
+					}
+					catch (Exception e) {
+						Console.WriteLine(e);
+						throw;
+					}
+
+					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+					// send subscription request
+					try {
+						await QueueWebSocketRequest(startRequest);
+					}
+					catch (Exception e) {
+						Console.WriteLine(e);
+						throw;
+					}
+
+					return disposable;
+				}))
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLResponse<TResponse>>())
+				// wrap results
+				.Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
+				// do exception handling
+				.Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e => {
+					try {
+						if (exceptionHandler == null) {
+							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
+							// this will ensure that the client tries to re-establish subscriptions on connection loss
+							if (!(e is WebSocketException)) throw e;
+						}
+						else {
+							// exceptions thrown by the handler will propagate to OnError()
+							exceptionHandler?.Invoke(e);
+						}
+
+						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+						if (internalCancellationToken.IsCancellationRequested)
+							return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
+						else {
+							Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
+							return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
+						}
+					}
+					catch (Exception exception) {
+						// wrap all other exceptions to be propagated behind retry
+						return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
+					}
+				})
+				// attempt to recreate the websocket for rethrown exceptions
+				.Retry()
+				// unwrap and push results or throw wrapped exceptions
+				.SelectMany(t => {
+					Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId}");
+					// if the result contains an exception, throw it on the observable
+					if (t.Item2 != null)
+						return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
+
+					return t.Item1 == null
+						? Observable.Empty<GraphQLResponse<TResponse>>()
+						: Observable.Return(t.Item1);
+				})
+				// transform to hot observable and auto-connect
+				.Publish().RefCount();
+		}
+
+		/// <summary>
+		/// Send a regular GraphQL request (query, mutation) via websocket
+		/// </summary>
+		/// <typeparam name="TResponse">the response type</typeparam>
+		/// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
+		/// <param name="cancellationToken">the token to cancel the request</param>
+		/// <returns></returns>
+		public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			return Observable.Create<GraphQLResponse<TResponse>>(async observer => {
+				await client.Options.PreprocessRequest(request, client);
+				var websocketRequest = new GraphQLWebSocketRequest {
+					Id = Guid.NewGuid().ToString("N"),
+					Type = GraphQLWebSocketMessageType.GQL_START,
+					Payload = request
+				};
+				var observable = IncomingMessageStream
+					.Where(response => response != null && response.Id == websocketRequest.Id)
+					.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+					.Select(response => {
+						Debug.WriteLine($"received response for request {websocketRequest.Id}");
+						var typedResponse =
+							client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+								response.MessageBytes);
+						return typedResponse.Payload;
+					});
+
+				try {
+					// initialize websocket (completes immediately if socket is already open)
+					await InitializeWebSocket();
+				}
+				catch (Exception e) {
+					// subscribe observer to failed observable
+					return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+				}
+
+				var disposable = new CompositeDisposable(
+					observable.Subscribe(observer)
+				);
+
+				Debug.WriteLine($"submitting request {websocketRequest.Id}");
+				// send request
+				try {
+					await QueueWebSocketRequest(websocketRequest);
+				}
+				catch (Exception e) {
+					Console.WriteLine(e);
+					throw;
+				}
+
+				return disposable;
+			})
+			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+			.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+				Observable.Empty<GraphQLResponse<TResponse>>())
+			.FirstAsync()
+			.ToTask(cancellationToken);
+		}
+
 		public Task QueueWebSocketRequest(GraphQLWebSocketRequest request) {
 			requestSubject.OnNext(request);
 			return request.SendTask();
@@ -71,7 +309,7 @@ public Task QueueWebSocketRequest(GraphQLWebSocketRequest request) {
 
 		private async Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
 			try {
-				if (cancellationToken.IsCancellationRequested) {
+				if (internalCancellationToken.IsCancellationRequested) {
 					request.SendCanceled();
 					return;
 				}
@@ -82,7 +320,7 @@ await this.clientWebSocket.SendAsync(
 					new ArraySegment<byte>(requestBytes),
 					WebSocketMessageType.Text,
 					true,
-					cancellationToken);
+					internalCancellationToken);
 				request.SendCompleted();
 			}
 			catch (Exception e) {
@@ -91,9 +329,6 @@ await this.clientWebSocket.SendAsync(
 		}
 
 		#endregion
-
-		private Task initializeWebSocketTask = Task.CompletedTask;
-		private readonly object initializeLock = new object();
 		
 		public Task InitializeWebSocket() {
 			// do not attempt to initialize if cancellation is requested
@@ -138,7 +373,7 @@ public Task InitializeWebSocket() {
 				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
 				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 #endif
-				return initializeWebSocketTask = ConnectAsync(cancellationToken);
+				return initializeWebSocketTask = ConnectAsync(internalCancellationToken);
 			}
 		}
 
@@ -172,7 +407,7 @@ private Task BackOff() {
 
 			var delay = Options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
 			Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
-			return Task.Delay(delay, cancellationToken);
+			return Task.Delay(delay, internalCancellationToken);
 		}
 
 
@@ -184,7 +419,7 @@ private IObservable<WebsocketMessageWrapper> GetMessageStream() {
 		}
 
 		private async Task<IDisposable> CreateMessageStream(IObserver<WebsocketMessageWrapper> observer, CancellationToken token) {
-			var cts = CancellationTokenSource.CreateLinkedTokenSource(token, cancellationToken);
+			var cts = CancellationTokenSource.CreateLinkedTokenSource(token, internalCancellationToken);
 			cts.Token.ThrowIfCancellationRequested();
 
 
@@ -240,7 +475,7 @@ private async Task<IDisposable> CreateMessageStream(IObserver<WebsocketMessageWr
 		/// <returns></returns>
 		private Task<WebsocketMessageWrapper> GetReceiveTask() {
 			lock (receiveTaskLocker) {
-				cancellationToken.ThrowIfCancellationRequested();
+				internalCancellationToken.ThrowIfCancellationRequested();
 				if (receiveAsyncTask == null ||
 					receiveAsyncTask.IsFaulted ||
 					receiveAsyncTask.IsCompleted)
@@ -261,13 +496,13 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync() {
 				using (var ms = new MemoryStream()) {
 					WebSocketReceiveResult webSocketReceiveResult = null;
 					do {
-						cancellationToken.ThrowIfCancellationRequested();
+						internalCancellationToken.ThrowIfCancellationRequested();
 						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
 						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
 					}
 					while (!webSocketReceiveResult.EndOfMessage);
 
-					cancellationToken.ThrowIfCancellationRequested();
+					internalCancellationToken.ThrowIfCancellationRequested();
 					ms.Seek(0, SeekOrigin.Begin);
 
 					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
@@ -325,8 +560,8 @@ public void Complete() {
 		private readonly object completedLocker = new object();
 		private async Task CompleteAsync() {
 			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
-			if (!cancellationTokenSource.IsCancellationRequested)
-				cancellationTokenSource.Cancel();
+			if (!internalCancellationTokenSource.IsCancellationRequested)
+				internalCancellationTokenSource.Cancel();
 			await CloseAsync();
 			requestSubscription?.Dispose();
 			clientWebSocket?.Dispose();
@@ -339,7 +574,7 @@ private async Task CompleteAsync() {
 
 			exceptionSubject?.OnCompleted();
 			exceptionSubject?.Dispose();
-			cancellationTokenSource.Dispose();
+			internalCancellationTokenSource.Dispose();
 
 			sendLoopScheduler?.Dispose();
 			receiveLoopScheduler?.Dispose();
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
deleted file mode 100644
index 82fc6f2d..00000000
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebsocketHelpers.cs
+++ /dev/null
@@ -1,223 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Net.WebSockets;
-using System.Reactive.Concurrency;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
-using System.Reactive.Threading.Tasks;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Client.Abstractions.Websocket;
-
-namespace GraphQL.Client.Http.Websocket {
-	public static class GraphQLHttpWebsocketHelpers {
-		internal static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-			this GraphQLHttpWebSocket graphQlHttpWebSocket,
-			GraphQLRequest request,
-			GraphQLHttpClient client,
-			Action<Exception> exceptionHandler = null,
-			CancellationToken cancellationToken = default) {
-			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse<TResponse>>(async observer => {
-					Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
-					await client.Options.PreprocessRequest(request, client);
-					var startRequest = new GraphQLWebSocketRequest {
-						Id = Guid.NewGuid().ToString("N"),
-						Type = GraphQLWebSocketMessageType.GQL_START,
-						Payload = request
-					};
-					var closeRequest = new GraphQLWebSocketRequest {
-						Id = startRequest.Id,
-						Type = GraphQLWebSocketMessageType.GQL_STOP
-					};
-					var initRequest = new GraphQLWebSocketRequest {
-						Id = startRequest.Id,
-						Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-					};
-
-					var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
-						graphQlHttpWebSocket.ResponseStream
-							// ignore null values and messages for other requests
-							.Where(response => response != null && response.Id == startRequest.Id)
-							.Subscribe(response => {
-									// terminate the sequence when a 'complete' message is received
-									if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE) {
-										Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-										o.OnCompleted();
-										return;
-									}
-
-									// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-									Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
-									var typedResponse =
-										client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-											response.MessageBytes);
-									o.OnNext(typedResponse.Payload);
-
-									// in case of a GraphQL error, terminate the sequence after the response has been posted
-									if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR) {
-										Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
-										o.OnCompleted();
-									}
-								},
-								e => {
-									Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
-									o.OnError(e);
-								},
-								() => {
-									Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
-									o.OnCompleted();
-								})
-					);
-
-					try {
-						// initialize websocket (completes immediately if socket is already open)
-						await graphQlHttpWebSocket.InitializeWebSocket();
-					}
-					catch (Exception e) {
-						// subscribe observer to failed observable
-						return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-					}
-
-					var disposable = new CompositeDisposable(
-						observable.Subscribe(observer),
-						Disposable.Create(async () => {
-							// only try to send close request on open websocket
-							if (graphQlHttpWebSocket.WebSocketState != WebSocketState.Open) return;
-
-							try {
-								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-								await graphQlHttpWebSocket.QueueWebSocketRequest(closeRequest);
-							}
-							// do not break on disposing
-							catch (OperationCanceledException) { }
-						})
-					);
-
-					// send connection init
-					Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
-					try {
-						await graphQlHttpWebSocket.QueueWebSocketRequest(initRequest);
-					}
-					catch (Exception e) {
-						Console.WriteLine(e);
-						throw;
-					}
-
-					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
-					// send subscription request
-					try {
-						await graphQlHttpWebSocket.QueueWebSocketRequest(startRequest);
-					}
-					catch (Exception e) {
-						Console.WriteLine(e);
-						throw;
-					}
-
-					return disposable;
-				}))
-				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-				.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLResponse<TResponse>>())
-				// wrap results
-				.Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
-				// do exception handling
-				.Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e => {
-					try {
-						if (exceptionHandler == null) {
-							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
-							// this will ensure that the client tries to re-establish subscriptions on connection loss
-							if (!(e is WebSocketException)) throw e;
-						}
-						else {
-							// exceptions thrown by the handler will propagate to OnError()
-							exceptionHandler?.Invoke(e);
-						}
-
-						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-						if (cancellationToken.IsCancellationRequested)
-							return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
-						else {
-							Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
-							return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
-						}
-					}
-					catch (Exception exception) {
-						// wrap all other exceptions to be propagated behind retry
-						return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
-					}
-				})
-				// attempt to recreate the websocket for rethrown exceptions
-				.Retry()
-				// unwrap and push results or throw wrapped exceptions
-				.SelectMany(t => {
-					Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId}");
-					// if the result contains an exception, throw it on the observable
-					if (t.Item2 != null)
-						return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
-
-					return t.Item1 == null
-						? Observable.Empty<GraphQLResponse<TResponse>>()
-						: Observable.Return(t.Item1);
-				})
-				// transform to hot observable and auto-connect
-				.Publish().RefCount();
-		}
-
-		internal static Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(
-			this GraphQLHttpWebSocket graphQlHttpWebSocket,
-			GraphQLRequest request,
-			GraphQLHttpClient client,
-			CancellationToken cancellationToken = default) {
-			return Observable.Create<GraphQLResponse<TResponse>>(async observer => {
-					await client.Options.PreprocessRequest(request, client);
-					var websocketRequest = new GraphQLWebSocketRequest {
-						Id = Guid.NewGuid().ToString("N"),
-						Type = GraphQLWebSocketMessageType.GQL_START,
-						Payload = request
-					};
-					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => response != null && response.Id == websocketRequest.Id)
-						.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-						.Select(response => {
-							Debug.WriteLine($"received response for request {websocketRequest.Id}");
-							var typedResponse =
-								client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-									response.MessageBytes);
-							return typedResponse.Payload;
-						});
-
-					try {
-						// intialize websocket (completes immediately if socket is already open)
-						await graphQlHttpWebSocket.InitializeWebSocket();
-					}
-					catch (Exception e) {
-						// subscribe observer to failed observable
-						return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-					}
-
-					var disposable = new CompositeDisposable(
-						observable.Subscribe(observer)
-					);
-
-					Debug.WriteLine($"submitting request {websocketRequest.Id}");
-					// send request
-					try {
-						await graphQlHttpWebSocket.QueueWebSocketRequest(websocketRequest);
-					}
-					catch (Exception e) {
-						Console.WriteLine(e);
-						throw;
-					}
-
-					return disposable;
-				})
-			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-			.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-				Observable.Empty<GraphQLResponse<TResponse>>())
-			.FirstAsync()
-			.ToTask(cancellationToken);
-		}
-	}
-}

From b1888b4931c0c964d5129e771a8b4c74ae0f7617 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 13:00:00 +0100
Subject: [PATCH 204/455] eliminate incomingMessagesSubject

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 151 +++++++++---------
 .../Helpers/ObservableTester.cs               |   7 +-
 .../WebsocketTests/Base.cs                    |   9 +-
 3 files changed, 83 insertions(+), 84 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 61462a10..a8efeaeb 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -31,8 +31,8 @@ internal class GraphQLHttpWebSocket : IDisposable {
 		private readonly EventLoopScheduler sendLoopScheduler = new EventLoopScheduler();
 
 		private int connectionAttempt = 0;
-		private Subject<WebsocketMessageWrapper> incomingMessagesSubject;
-		private IDisposable incomingMessagesDisposable;
+		private IConnectableObservable<WebsocketMessageWrapper> incomingMessages;
+		private IDisposable incomingMessagesConnection;
 		private GraphQLHttpClientOptions Options => client.Options;
 		
 		private Task initializeWebSocketTask = Task.CompletedTask;
@@ -302,7 +302,7 @@ public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest re
 			.ToTask(cancellationToken);
 		}
 
-		public Task QueueWebSocketRequest(GraphQLWebSocketRequest request) {
+		private Task QueueWebSocketRequest(GraphQLWebSocketRequest request) {
 			requestSubject.OnNext(request);
 			return request.SendTask();
 		}
@@ -381,13 +381,41 @@ private async Task ConnectAsync(CancellationToken token) {
 			try {
 				await BackOff();
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
-				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()}");
+				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
 				await clientWebSocket.ConnectAsync(webSocketUri, token);
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
 				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
 				await (Options.OnWebsocketConnected?.Invoke(client) ?? Task.CompletedTask);
 				Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {clientWebSocket.GetHashCode()}");
 				connectionAttempt = 1;
+
+				// create receiving observable
+				incomingMessages = Observable
+					.Defer(() => GetReceiveTask().ToObservable().ObserveOn(receiveLoopScheduler))
+					.Repeat()
+					// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
+					.Catch<WebsocketMessageWrapper, OperationCanceledException>(exception => Observable.Empty<WebsocketMessageWrapper>())
+					.Publish();
+
+				// subscribe maintenance
+				var maintenanceSubscription = incomingMessages.Subscribe(_ => { }, ex => {
+						Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} received an error: {ex}");
+						exceptionSubject.OnNext(ex);
+						incomingMessagesConnection?.Dispose();
+						stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+					},
+					() => {
+						Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} completed");
+						incomingMessagesConnection?.Dispose();
+						stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+					});
+
+
+				// connect observable
+				var connection = incomingMessages.Connect();
+				Debug.WriteLine($"new incoming message stream {incomingMessages.GetHashCode()} created");
+
+				incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
 			}
 			catch (Exception e) {
 				stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
@@ -410,61 +438,25 @@ private Task BackOff() {
 			return Task.Delay(delay, internalCancellationToken);
 		}
 
-
 		private IObservable<WebsocketMessageWrapper> GetMessageStream() {
-			return Observable.Create<WebsocketMessageWrapper>(CreateMessageStream)
-				// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
-				.Catch<WebsocketMessageWrapper, OperationCanceledException>(exception =>
-					Observable.Empty<WebsocketMessageWrapper>());
-		}
-
-		private async Task<IDisposable> CreateMessageStream(IObserver<WebsocketMessageWrapper> observer, CancellationToken token) {
-			var cts = CancellationTokenSource.CreateLinkedTokenSource(token, internalCancellationToken);
-			cts.Token.ThrowIfCancellationRequested();
-
-
-			if (incomingMessagesSubject == null || incomingMessagesSubject.IsDisposed) {
-				// create new response subject
-				incomingMessagesSubject = new Subject<WebsocketMessageWrapper>();
-				Debug.WriteLine($"creating new incoming message stream {incomingMessagesSubject.GetHashCode()}");
-
-				// initialize and connect websocket
-				await InitializeWebSocket();
-
-				// loop the receive task and subscribe the created subject to the results 
-				var receiveLoopSubscription = Observable
-					.Defer(() => GetReceiveTask().ToObservable())
-					.Repeat()
-					.Subscribe(incomingMessagesSubject);
-				
-				incomingMessagesDisposable = new CompositeDisposable(
-					incomingMessagesSubject,
-					receiveLoopSubscription,
-					Disposable.Create(() => {
-						Debug.WriteLine($"incoming message stream {incomingMessagesSubject.GetHashCode()} disposed");
+			return Observable.Using(() => new EventLoopScheduler(), scheduler =>
+				Observable.Create<WebsocketMessageWrapper>(async observer => {
+					// make sure the websocket ist connected
+					await InitializeWebSocket();
+					// subscribe observer to message stream
+					var subscription = new CompositeDisposable(incomingMessages.ObserveOn(scheduler).Subscribe(observer));
+					// register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
+					subscription.Add(internalCancellationTokenSource.Token.Register(observer.OnCompleted));
+
+					// add some debug output
+					var hashCode = subscription.GetHashCode();
+					subscription.Add(Disposable.Create(() => {
+						Debug.WriteLine($"incoming message subscription {hashCode} disposed");
 					}));
+					Debug.WriteLine($"new incoming message subscription {hashCode} created");
 
-				// dispose the subject on any error or completion (will be recreated) 
-				incomingMessagesSubject.Subscribe(_ => { }, ex => {
-					exceptionSubject.OnNext(ex);
-					incomingMessagesDisposable?.Dispose();
-					incomingMessagesSubject = null;
-					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-				},
-				() => {
-					incomingMessagesDisposable?.Dispose();
-					incomingMessagesSubject = null;
-					stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-				});
-			}
-
-			var subscription = new CompositeDisposable(incomingMessagesSubject.Subscribe(observer));
-			var hashCode = subscription.GetHashCode();
-			subscription.Add(Disposable.Create(() => {
-				Debug.WriteLine($"incoming message subscription {hashCode} disposed");
-			}));
-			Debug.WriteLine($"new incoming message subscription {hashCode} created");
-			return subscription;
+					return subscription;
+				}));
 		}
 
 		private Task<WebsocketMessageWrapper> receiveAsyncTask = null;
@@ -490,30 +482,31 @@ private Task<WebsocketMessageWrapper> GetReceiveTask() {
 		/// </summary>
 		/// <returns></returns>
 		private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync() {
+			internalCancellationToken.ThrowIfCancellationRequested();
+
 			try {
 				Debug.WriteLine($"waiting for data on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
 
-				using (var ms = new MemoryStream()) {
-					WebSocketReceiveResult webSocketReceiveResult = null;
-					do {
-						internalCancellationToken.ThrowIfCancellationRequested();
-						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
-						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
-					}
-					while (!webSocketReceiveResult.EndOfMessage);
+				using var ms = new MemoryStream();
+				WebSocketReceiveResult webSocketReceiveResult = null;
+				do {
+					// cancellation is done implicitly via the close method
+					webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
+					ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+				}
+				while (!webSocketReceiveResult.EndOfMessage && !internalCancellationToken.IsCancellationRequested);
 
-					internalCancellationToken.ThrowIfCancellationRequested();
-					ms.Seek(0, SeekOrigin.Begin);
+				internalCancellationToken.ThrowIfCancellationRequested();
+				ms.Seek(0, SeekOrigin.Begin);
 
-					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
-						var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
-						response.MessageBytes = ms.ToArray();
-						Debug.WriteLine($"{response.MessageBytes.Length} bytes received on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
-						return response;
-					}
-					else {
-						throw new NotSupportedException("binary websocket messages are not supported");
-					}
+				if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
+					var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+					response.MessageBytes = ms.ToArray();
+					Debug.WriteLine($"{response.MessageBytes.Length} bytes received on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+					return response;
+				}
+				else {
+					throw new NotSupportedException("binary websocket messages are not supported");
 				}
 			}
 			catch (Exception e) {
@@ -560,15 +553,15 @@ public void Complete() {
 		private readonly object completedLocker = new object();
 		private async Task CompleteAsync() {
 			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
+			incomingMessagesConnection?.Dispose();
+
 			if (!internalCancellationTokenSource.IsCancellationRequested)
 				internalCancellationTokenSource.Cancel();
+			
 			await CloseAsync();
 			requestSubscription?.Dispose();
 			clientWebSocket?.Dispose();
-
-			incomingMessagesSubject?.OnCompleted();
-			incomingMessagesDisposable?.Dispose();
-
+			
 			stateSubject?.OnCompleted();
 			stateSubject?.Dispose();
 
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 86ec3a1f..bd1ac46b 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -89,7 +89,12 @@ public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceiv
 				string because = "", params object[] becauseArgs) {
 				Execute.Assertion
 					.BecauseOf(because, becauseArgs)
-					.Given(() => Subject.updateReceived.Wait(timeout))
+					.Given(() => {
+						var isSet = Subject.updateReceived.Wait(timeout);
+						if(!isSet)
+							Debug.WriteLine($"waiting for payload on thread {Thread.CurrentThread.ManagedThreadId} timed out!");
+						return isSet;
+					})
 					.ForCondition(isSet => isSet)
 					.FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 47d2e5e8..e689dd06 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -169,24 +169,25 @@ public async void CanReconnectWithSameObservable() {
 
 			const string message1 = "Hello World";
 			Debug.WriteLine($"adding message {message1}");
-			var response = await ChatClient.AddMessageAsync(message1);
+			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(true);
 			response.Data.AddMessage.Content.Should().Be(message1);
 			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
 
 			const string message2 = "How are you?";
-			response = await ChatClient.AddMessageAsync(message2);
+			response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(true);
 			response.Data.AddMessage.Content.Should().Be(message2);
 			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
 
 			Debug.WriteLine("disposing subscription...");
 			tester.Dispose(); // does not close the websocket connection
 
-			Debug.WriteLine("creating new subscription...");
+			Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
 			var tester2 = observable.Monitor();
+			Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
 			tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
 
 			const string message3 = "lorem ipsum dolor si amet";
-			response = await ChatClient.AddMessageAsync(message3);
+			response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(true);
 			response.Data.AddMessage.Content.Should().Be(message3);
 			tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message3);
 

From c9acd489f0a565378c8a1f77d97c2178df1e0fd5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 13:33:46 +0100
Subject: [PATCH 205/455] fix tests locally

---
 .../Websocket/GraphQLHttpWebSocket.cs          |  2 +-
 .../Helpers/ObservableTester.cs                |  6 +-----
 .../WebsocketTests/Base.cs                     | 18 ++++++++++--------
 3 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index a8efeaeb..ec3d5a18 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -502,7 +502,7 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync() {
 				if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
 					var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
 					response.MessageBytes = ms.ToArray();
-					Debug.WriteLine($"{response.MessageBytes.Length} bytes received on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+					Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
 					return response;
 				}
 				else {
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index bd1ac46b..05ed7e38 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -13,7 +13,6 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
 		private readonly ManualResetEventSlim error = new ManualResetEventSlim();
-		private readonly EventLoopScheduler subscriptionScheduler = new EventLoopScheduler();
 		private readonly EventLoopScheduler observeScheduler = new EventLoopScheduler();
 
 		/// <summary>
@@ -37,13 +36,11 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable {
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
 		public ObservableTester(IObservable<TSubscriptionPayload> observable) {
-			subscriptionScheduler.Schedule(() =>
-				Debug.WriteLine($"Subscription scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
 			observeScheduler.Schedule(() =>
 				Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
-			subscription = observable.SubscribeOn(subscriptionScheduler).ObserveOn(observeScheduler).Subscribe(
+			subscription = observable.ObserveOn(observeScheduler).Subscribe(
 				obj => {
 					Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
 					LastPayload = obj;
@@ -70,7 +67,6 @@ private void Reset() {
 		/// <inheritdoc />
 		public void Dispose() {
 			subscription?.Dispose();
-			subscriptionScheduler.Dispose();
 			observeScheduler.Dispose();
 		}
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index e689dd06..3c2d63f1 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -233,36 +233,38 @@ public async void CanConnectTwoSubscriptionsSimultaneously() {
 			var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
 
 			Debug.WriteLine("subscribing...");
-			var tester = observable1.Monitor();
-			var tester2 = observable2.Monitor();
+			var messagesMonitor = observable1.Monitor();
+			var joinedMonitor = observable2.Monitor();
 
-			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+			messagesMonitor.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
 			const string message1 = "Hello World";
 			var response = await ChatClient.AddMessageAsync(message1);
 			response.Data.AddMessage.Content.Should().Be(message1);
-			tester.Should().HaveReceivedPayload()
+			messagesMonitor.Should().HaveReceivedPayload()
 				.Which.Data.MessageAdded.Content.Should().Be(message1);
+			joinedMonitor.Should().NotHaveReceivedPayload();
 			
 			var joinResponse = await ChatClient.JoinDeveloperUser();
 			joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
-			var payload = tester2.Should().HaveReceivedPayload().Subject;
+			var payload = joinedMonitor.Should().HaveReceivedPayload().Subject;
 			payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
 			payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+			messagesMonitor.Should().NotHaveReceivedPayload();
 
 			Debug.WriteLine("disposing subscription...");
-			tester2.Dispose();
+			joinedMonitor.Dispose();
 
 			const string message3 = "lorem ipsum dolor si amet";
 			response = await ChatClient.AddMessageAsync(message3);
 			response.Data.AddMessage.Content.Should().Be(message3);
-			tester.Should().HaveReceivedPayload()
+			messagesMonitor.Should().HaveReceivedPayload()
 				.Which.Data.MessageAdded.Content.Should().Be(message3);
 
 			// disposing the client should complete the subscription
 			ChatClient.Dispose();
-			tester.Should().HaveCompleted();
+			messagesMonitor.Should().HaveCompleted();
 		}
 
 

From 3a9df0ca08a1257a51e87b18677f6b1072380df5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 13:58:50 +0100
Subject: [PATCH 206/455] extend execution time in cancellation tests

---
 .../QueryAndMutationTests/Base.cs                        | 4 ++--
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs   | 9 ++++-----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index c25117ca..7b2dc79e 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -171,7 +171,7 @@ query Long {
 			// unblock the query
 			chatQuery.LongRunningQueryBlocker.Set();
 			// check execution time
-			request.Invoking().ExecutionTime().Should().BeLessThan(500.Milliseconds());
+			request.Invoking().ExecutionTime().Should().BeLessThan(1000.Milliseconds());
 			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
 
 			// reset stuff
@@ -183,7 +183,7 @@ query Long {
 			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
 			cts.Cancel();
 			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
-				.ExecutionTime().Should().BeLessThan(500.Milliseconds());
+				.ExecutionTime().Should().BeLessThan(1000.Milliseconds());
 
 			// let the server finish its query
 			chatQuery.LongRunningQueryBlocker.Set();
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 3c2d63f1..016f0dab 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -2,7 +2,6 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Net.WebSockets;
-using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
@@ -77,11 +76,11 @@ query Long {
 			// start request
 			request.Start();
 			// wait until the query has reached the server
-			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
 			// unblock the query
 			chatQuery.LongRunningQueryBlocker.Set();
 			// check execution time
-			request.Invoking().ExecutionTime().Should().BeLessThan(500.Milliseconds());
+			request.Invoking().ExecutionTime().Should().BeLessThan(1000.Milliseconds());
 			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
 
 			// reset stuff
@@ -90,10 +89,10 @@ query Long {
 
 			// cancellation test
 			request.Start();
-			chatQuery.WaitingOnQueryBlocker.Wait(500).Should().BeTrue("because the request should have reached the server by then");
+			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
 			cts.Cancel();
 			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
-				.ExecutionTime().Should().BeLessThan(500.Milliseconds());
+				.ExecutionTime().Should().BeLessThan(1000.Milliseconds());
 
 			// let the server finish its query
 			chatQuery.LongRunningQueryBlocker.Set();

From 6834eef0a4b23d53f283da1fb4012a4c6e48e8af Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 14:27:26 +0100
Subject: [PATCH 207/455] don't measure execution time in tests

---
 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs | 4 +---
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs        | 4 +---
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 7b2dc79e..e60c26f0 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -171,7 +171,6 @@ query Long {
 			// unblock the query
 			chatQuery.LongRunningQueryBlocker.Set();
 			// check execution time
-			request.Invoking().ExecutionTime().Should().BeLessThan(1000.Milliseconds());
 			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
 
 			// reset stuff
@@ -182,8 +181,7 @@ query Long {
 			request.Start();
 			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
 			cts.Cancel();
-			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
-				.ExecutionTime().Should().BeLessThan(1000.Milliseconds());
+			request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
 
 			// let the server finish its query
 			chatQuery.LongRunningQueryBlocker.Set();
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 016f0dab..59f57ceb 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -80,7 +80,6 @@ query Long {
 			// unblock the query
 			chatQuery.LongRunningQueryBlocker.Set();
 			// check execution time
-			request.Invoking().ExecutionTime().Should().BeLessThan(1000.Milliseconds());
 			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
 
 			// reset stuff
@@ -91,8 +90,7 @@ query Long {
 			request.Start();
 			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
 			cts.Cancel();
-			FluentActions.Awaiting(() => request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled"))
-				.ExecutionTime().Should().BeLessThan(1000.Milliseconds());
+			request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
 
 			// let the server finish its query
 			chatQuery.LongRunningQueryBlocker.Set();

From 80ec16795fe588e101f58e2e8764fee084e65854 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 14:35:48 +0100
Subject: [PATCH 208/455] enable windows workflow for comparison

---
 .github/workflows/branches-windows.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/branches-windows.yml b/.github/workflows/branches-windows.yml
index 430b2121..a896d523 100644
--- a/.github/workflows/branches-windows.yml
+++ b/.github/workflows/branches-windows.yml
@@ -1,8 +1,10 @@
 name: Branch workflow
-on:
+on: 
   push:
     branches-ignore:
-      - '**'
+      - develop
+      - 'release/**'
+      - 'releases/**'
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From 0a7f91d03ffeecd162e3a3177d1dacb45faf96a7 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 15:09:38 +0100
Subject: [PATCH 209/455] disable windows job again

---
 .github/workflows/branches-windows.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/branches-windows.yml b/.github/workflows/branches-windows.yml
index a896d523..fdf2b81c 100644
--- a/.github/workflows/branches-windows.yml
+++ b/.github/workflows/branches-windows.yml
@@ -2,9 +2,7 @@ name: Branch workflow
 on: 
   push:
     branches-ignore:
-      - develop
-      - 'release/**'
-      - 'releases/**'
+      - '**'
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo

From 52c8731e1f4941d94664d20f611a29ea5a8c4730 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 17:10:02 +0100
Subject: [PATCH 210/455] use a Dictionary as a base for GraphQLRequest

---
 .../GraphQLWebSocketRequest.cs                |  20 ++-
 .../GraphQLRequest.cs                         |  21 ---
 .../GraphQLWebSocketRequest.cs                |  23 ---
 .../NewtonsoftJsonSerializer.cs               |   4 +-
 .../GraphQLRequest.cs                         |  21 ---
 .../GraphQLWebSocketRequest.cs                |  23 ---
 .../ImmutableConverter.cs                     | 166 ++++++++++++++++++
 .../JsonSerializerOptionsExtensions.cs        |  22 +++
 .../SystemTextJsonSerializer.cs               |   8 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |  20 ++-
 .../BaseSerializerTest.cs                     |   3 +-
 .../NewtonsoftSerializerTest.cs               |   1 +
 .../SystemTextJsonSerializerTests.cs          |   2 +-
 .../TestData/SerializeToBytesTestData.cs      |   4 +-
 .../TestData/SerializeToStringTestData.cs     |   4 +-
 15 files changed, 227 insertions(+), 115 deletions(-)
 delete mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs
 delete mode 100644 src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
 delete mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/GraphQLRequest.cs
 delete mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index 0f486482..a44e57d6 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -8,7 +8,7 @@ namespace GraphQL.Client.Abstractions.Websocket {
 	/// <summary>
 	/// A Subscription Request
 	/// </summary>
-	public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
+	public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<GraphQLWebSocketRequest> {
 		public const string IdKey = "id";
 		public const string TypeKey = "type";
 		public const string PayloadKey = "payload";
@@ -16,20 +16,26 @@ public class GraphQLWebSocketRequest : IEquatable<GraphQLWebSocketRequest> {
 		/// <summary>
 		/// The Identifier of the Response
 		/// </summary>
-		[DataMember(Name = IdKey)]
-		public virtual string Id { get; set; }
+		public string Id {
+			get => ContainsKey(IdKey) ? (string)this[IdKey] : null;
+			set => this[IdKey] = value;
+		}
 
 		/// <summary>
 		/// The Type of the Request
 		/// </summary>
-		[DataMember(Name = TypeKey)]
-		public virtual string Type { get; set; }
+		public string Type {
+			get => ContainsKey(TypeKey) ? (string)this[TypeKey] : null;
+			set => this[TypeKey] = value;
+		}
 
 		/// <summary>
 		/// The payload of the websocket request
 		/// </summary>
-		[DataMember(Name = PayloadKey)]
-		public virtual GraphQLRequest Payload { get; set; }
+		public GraphQLRequest Payload {
+			get => ContainsKey(PayloadKey) ? (GraphQLRequest) this[PayloadKey] : null;
+			set => this[PayloadKey] = value;
+		}
 
 		private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs
deleted file mode 100644
index cf012c92..00000000
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLRequest.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using Newtonsoft.Json;
-
-namespace GraphQL.Client.Serializer.Newtonsoft {
-	public class GraphQLRequest: GraphQL.GraphQLRequest {
-		[JsonProperty(QueryKey)]
-		public override string Query { get; set; }
-		[JsonProperty(OperationNameKey)]
-		public override string? OperationName { get; set; }
-		[JsonProperty(VariablesKey)]
-		public override object? Variables { get; set; }
-
-		public GraphQLRequest() { }
-
-		public GraphQLRequest(GraphQL.GraphQLRequest other) {
-			Query = other.Query;
-			OperationName = other.OperationName;
-			Variables = other.Variables;
-		}
-
-	}
-}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
deleted file mode 100644
index c575b9d3..00000000
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLWebSocketRequest.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using Newtonsoft.Json;
-
-namespace GraphQL.Client.Serializer.Newtonsoft {
-	public class GraphQLWebSocketRequest: Abstractions.Websocket.GraphQLWebSocketRequest {
-
-		[JsonProperty(IdKey)]
-		public override string Id { get; set; }
-		[JsonProperty(TypeKey)]
-		public override string Type { get; set; }
-		[JsonProperty(PayloadKey)]
-		public override GraphQL.GraphQLRequest Payload { get; set; }
-
-		public GraphQLWebSocketRequest()
-		{
-		}
-
-		public GraphQLWebSocketRequest(Abstractions.Websocket.GraphQLWebSocketRequest other) {
-			Id = other.Id;
-			Type = other.Type;
-			Payload = other.Payload != null ? new GraphQLRequest(other.Payload) : null; // create serializer-specific type
-		}
-	}
-}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 7194a547..67679432 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -34,11 +34,11 @@ private void ConfigureMandatorySerializerOptions() {
 		}
 
 		public string SerializeToString(GraphQL.GraphQLRequest request) {
-		    return JsonConvert.SerializeObject(new GraphQLRequest(request), JsonSerializerSettings);
+		    return JsonConvert.SerializeObject(request, JsonSerializerSettings);
 		}
 
 		public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
-			var json = JsonConvert.SerializeObject(new GraphQLWebSocketRequest(request), JsonSerializerSettings);
+			var json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
 			return Encoding.UTF8.GetBytes(json);
 		}
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLRequest.cs
deleted file mode 100644
index 1f3b7908..00000000
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLRequest.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace GraphQL.Client.Serializer.SystemTextJson {
-	public class GraphQLRequest: GraphQL.GraphQLRequest {
-		[JsonPropertyName(QueryKey)]
-		public override string Query { get; set; }
-		[JsonPropertyName(OperationNameKey)]
-		public override string? OperationName { get; set; }
-		[JsonPropertyName(VariablesKey)]
-		public override object? Variables { get; set; }
-
-		public GraphQLRequest() { }
-
-		public GraphQLRequest(GraphQL.GraphQLRequest other) {
-			Query = other.Query;
-			OperationName = other.OperationName;
-			Variables = other.Variables;
-		}
-
-	}
-}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
deleted file mode 100644
index 4961e00d..00000000
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLWebSocketRequest.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace GraphQL.Client.Serializer.SystemTextJson {
-	public class GraphQLWebSocketRequest: Abstractions.Websocket.GraphQLWebSocketRequest {
-
-		[JsonPropertyName(IdKey)]
-		public override string Id { get; set; }
-		[JsonPropertyName(TypeKey)]
-		public override string Type { get; set; }
-		[JsonPropertyName(PayloadKey)]
-		public override GraphQL.GraphQLRequest Payload { get; set; }
-
-		public GraphQLWebSocketRequest()
-		{
-		}
-
-		public GraphQLWebSocketRequest(Abstractions.Websocket.GraphQLWebSocketRequest other) {
-			Id = other.Id;
-			Type = other.Type;
-			Payload = other.Payload != null ? new GraphQLRequest(other.Payload) : null; // create serializer-specific type;
-		}
-	}
-}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
new file mode 100644
index 00000000..a4f49f49
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace GraphQL.Client.Serializer.SystemTextJson {
+
+	/// <summary>
+	/// class for converting immutable objects, derived from https://github.com/manne/obviously/blob/master/src/system.text.json/Core/ImmutableConverter.cs
+	/// </summary>
+	public class ImmutableConverter : JsonConverter<object> {
+		public override bool CanConvert(Type typeToConvert) {
+			bool result;
+			var constructors = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+			if (constructors.Length != 1) {
+				result = false;
+			}
+			else {
+				var constructor = constructors[0];
+				var parameters = constructor.GetParameters();
+				var hasParameters = parameters.Length > 0;
+				if (hasParameters) {
+					var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+					result = true;
+					foreach (var parameter in parameters) {
+						var hasMatchingProperty = properties.Any(p =>
+							NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous()));
+						if (!hasMatchingProperty) {
+							result = false;
+							break;
+						}
+					}
+				}
+				else {
+					result = false;
+				}
+			}
+
+			return result;
+		}
+
+		public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
+			var valueOfProperty = new Dictionary<PropertyInfo, object>();
+			var namedPropertiesMapping = GetNamedProperties(options, GetProperties(typeToConvert));
+			reader.Read();
+			while (true) {
+				if (reader.TokenType != JsonTokenType.PropertyName && reader.TokenType != JsonTokenType.String) {
+					break;
+				}
+
+				var jsonPropName = reader.GetString();
+				var normalizedPropName = ConvertAndNormalizeName(jsonPropName, options);
+				if (!namedPropertiesMapping.TryGetValue(normalizedPropName, out var obProp)) {
+					reader.Read();
+				}
+				else {
+					var value = JsonSerializer.Deserialize(ref reader, obProp.PropertyType, options);
+					reader.Read();
+					valueOfProperty[obProp] = value;
+				}
+			}
+
+			var ctor = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First();
+			var parameters = ctor.GetParameters();
+			var parameterValues = new object[parameters.Length];
+			for (var index = 0; index < parameters.Length; index++) {
+				var parameterInfo = parameters[index];
+				var value = valueOfProperty.First(prop =>
+					NameOfPropertyAndParameter.Matches(prop.Key.Name, parameterInfo.Name, typeToConvert.IsAnonymous())).Value;
+
+				parameterValues[index] = value;
+			}
+
+			var instance = ctor.Invoke(parameterValues);
+			return instance;
+		}
+
+		public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options) {
+			var strippedOptions = new JsonSerializerOptions {
+				AllowTrailingCommas = options.AllowTrailingCommas,
+				DefaultBufferSize = options.DefaultBufferSize,
+				DictionaryKeyPolicy = options.DictionaryKeyPolicy,
+				Encoder = options.Encoder,
+				IgnoreNullValues = options.IgnoreNullValues,
+				IgnoreReadOnlyProperties = options.IgnoreReadOnlyProperties,
+				MaxDepth = options.MaxDepth,
+				PropertyNameCaseInsensitive = options.PropertyNameCaseInsensitive,
+				PropertyNamingPolicy = options.PropertyNamingPolicy,
+				ReadCommentHandling = options.ReadCommentHandling,
+				WriteIndented = options.WriteIndented
+			};
+			foreach (var converter in options.Converters) {
+				if (!(converter is ImmutableConverter))
+					strippedOptions.Converters.Add(converter);
+			}
+			JsonSerializer.Serialize(writer, value, strippedOptions);
+		}
+
+		private static PropertyInfo[] GetProperties(IReflect typeToConvert) {
+			return typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+		}
+
+		private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(JsonSerializerOptions options, IEnumerable<PropertyInfo> properties) {
+			var result = new Dictionary<string, PropertyInfo>();
+			foreach (var property in properties) {
+				string name;
+				var nameAttribute = property.GetCustomAttribute<JsonPropertyNameAttribute>();
+				if (nameAttribute != null) {
+					name = nameAttribute.Name;
+				}
+				else {
+					name = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
+				}
+
+				var normalizedName = NormalizeName(name, options);
+				result.Add(normalizedName, property);
+			}
+
+			return result;
+		}
+
+		private static string ConvertAndNormalizeName(string name, JsonSerializerOptions options) {
+			var convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;
+			return options.PropertyNameCaseInsensitive ? convertedName.ToLowerInvariant() : convertedName;
+		}
+
+		private static string NormalizeName(string name, JsonSerializerOptions options) {
+			return options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
+		}
+	}
+
+	internal static class NameOfPropertyAndParameter {
+		public static bool Matches(string propertyName, string parameterName, bool anonymousType) {
+			if (propertyName is null && parameterName is null) {
+				return true;
+			}
+
+			if (propertyName is null || parameterName is null) {
+				return false;
+			}
+
+			if (anonymousType) {
+				return propertyName.Equals(parameterName, StringComparison.Ordinal);
+			}
+			else {
+				var xRight = propertyName.AsSpan(1);
+				var yRight = parameterName.AsSpan(1);
+				return char.ToLowerInvariant(propertyName[0]).CompareTo(parameterName[0]) == 0 && xRight.Equals(yRight, StringComparison.Ordinal);
+			}
+		}
+	}
+
+	internal static class TypeExtensions {
+		// copied from https://github.com/dahomey-technologies/Dahomey.Json/blob/master/src/Dahomey.Json/Util/TypeExtensions.cs
+		public static bool IsAnonymous(this Type type) {
+			return type.Namespace == null
+			       && type.IsSealed
+			       && type.BaseType == typeof(object)
+			       && !type.IsPublic
+			       && type.IsDefined(typeof(CompilerGeneratedAttribute), false);
+		}
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
new file mode 100644
index 00000000..81547955
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Dahomey.Json;
+using Dahomey.Json.Serialization.Converters.Factories;
+
+namespace GraphQL.Client.Serializer.SystemTextJson {
+	public static class JsonSerializerOptionsExtensions {
+		public static JsonSerializerOptions SetupDahomeyExtensions(
+			this JsonSerializerOptions options) {
+			options.Converters.Add(new ImmutableConverter());
+			//options.Converters.Add((JsonConverter)new JsonSerializerOptionsState(options));
+			//options.Converters.Add((JsonConverter)new DictionaryConverterFactory());
+			//options.Converters.Add((JsonConverter)new CollectionConverterFactory());
+			//options.Converters.Add((JsonConverter)new JsonNodeConverterFactory());
+			//options.Converters.Add((JsonConverter)new ObjectConverterFactory());
+			return options;
+		}
+	}
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 62be2e37..a00c834b 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -13,8 +13,8 @@ public class SystemTextJsonSerializer: IGraphQLWebsocketJsonSerializer
     {
 	    public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions {
 		    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-	    }.SetupExtensions();
-
+	    }.SetupDahomeyExtensions();
+		
 		public JsonSerializerOptions Options { get; }
 
 	    public SystemTextJsonSerializer() : this(DefaultJsonSerializerOptions) { }
@@ -34,7 +34,7 @@ private void ConfigureMandatorySerializerOptions() {
 		}
 
 	    public string SerializeToString(GraphQL.GraphQLRequest request) {
-		    return JsonSerializer.Serialize(new GraphQLRequest(request), Options);
+		    return JsonSerializer.Serialize(request, Options);
 	    }
 
 	    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
@@ -42,7 +42,7 @@ public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse
 	    }
 
 	    public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
-		    return JsonSerializer.SerializeToUtf8Bytes(new GraphQLWebSocketRequest(request), Options);
+		    return JsonSerializer.SerializeToUtf8Bytes(request, Options);
 	    }
 
 	    public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index f7e48e24..ae174392 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -7,7 +7,7 @@ namespace GraphQL {
 	/// <summary>
 	/// A GraphQL request
 	/// </summary>
-	public class GraphQLRequest : IEquatable<GraphQLRequest?> {
+	public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequest?> {
 		public const string OperationNameKey = "operationName";
 		public const string QueryKey = "query";
 		public const string VariablesKey = "variables";
@@ -15,20 +15,26 @@ public class GraphQLRequest : IEquatable<GraphQLRequest?> {
 		/// <summary>
 		/// The Query
 		/// </summary>
-		[DataMember(Name = QueryKey)]
-		public virtual string Query { get; set; }
+		public string Query {
+			get => ContainsKey(QueryKey) ? (string) this[QueryKey] : null;
+			set => this[QueryKey] = value;
+		}
 
 		/// <summary>
 		/// The name of the Operation
 		/// </summary>
-		[DataMember(Name = OperationNameKey)]
-		public virtual string? OperationName { get; set; }
+		public string? OperationName {
+			get => ContainsKey(OperationNameKey) ? (string)this[OperationNameKey] : null;
+			set => this[OperationNameKey] = value;
+		}
 
 		/// <summary>
 		/// Represents the request variables
 		/// </summary>
-		[DataMember(Name = VariablesKey)]
-		public virtual object? Variables { get; set; }
+		public object? Variables {
+			get => ContainsKey(VariablesKey) ? this[VariablesKey] : null;
+			set => this[VariablesKey] = value;
+		}
 
 		public GraphQLRequest() { }
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 579e756e..26d44472 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -75,8 +75,7 @@ query Droid($id: String!) {
 				new { id = id.ToString() },
 				"Human");
 
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } })
-				;
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
 			Assert.Null(response.Errors);
 			Assert.Equal(name, response.Data.Human.Name);
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 84bb5e84..95c18908 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using GraphQL.Client.Serializer.Newtonsoft;
 using Newtonsoft.Json;
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index a3d393dc..212aefa6 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -9,6 +9,6 @@ public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) {
 
 	public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
 		public SystemTextJsonSerializeNoCamelCaseTest()
-			: base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupExtensions())) { }
+			: base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupDahomeyExtensions())) { }
 	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
index 41d15ce0..a506cb6d 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
@@ -7,7 +7,7 @@ namespace GraphQL.Client.Serializer.Tests.TestData {
 	public class SerializeToBytesTestData : IEnumerable<object[]> {
 		public IEnumerator<object[]> GetEnumerator() {
 			yield return new object[] {
-				"{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":null}}",
+				"{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}}",
 				new GraphQLWebSocketRequest {
 					Id = "1234567",
 					Type = GraphQLWebSocketMessageType.GQL_START,
@@ -15,7 +15,7 @@ public IEnumerator<object[]> GetEnumerator() {
 				}
 			};
 			yield return new object[] {
-				"{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"}}}",
+				"{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}}",
 				new GraphQLWebSocketRequest {
 					Id = "34476567",
 					Type = GraphQLWebSocketMessageType.GQL_START,
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 86d1ae9f..4f9d694c 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -6,11 +6,11 @@ namespace GraphQL.Client.Serializer.Tests.TestData {
 	public class SerializeToStringTestData : IEnumerable<object[]> {
 		public IEnumerator<object[]> GetEnumerator() {
 			yield return new object[] {
-				"{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":null}",
+				"{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}",
 				new GraphQLRequest("simple query string")
 			};
 			yield return new object[] {
-				"{\"query\":\"simplequerystring\",\"operationName\":null,\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"}}",
+				"{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}",
 				new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
 			};
 		}

From 86424d5c295adefc2b9f6b1e8ffaa71b269e68a8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 17:16:45 +0100
Subject: [PATCH 211/455] remove dependency on Dahomey.Json, add test with
 extension

---
 .../GraphQL.Client.Serializer.SystemTextJson.csproj |  4 ----
 .../JsonSerializerOptionsExtensions.cs              | 13 +------------
 .../SystemTextJsonSerializer.cs                     |  3 +--
 .../SystemTextJsonSerializerTests.cs                |  3 +--
 .../TestData/SerializeToStringTestData.cs           |  4 ++++
 5 files changed, 7 insertions(+), 20 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index 024b0681..8f8bc66a 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -10,10 +10,6 @@
 		<PackageReference Include="System.Text.Json" Version="4.7.0" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <PackageReference Include="Dahomey.Json" Version="1.6.0" />
-	</ItemGroup>
-
 	<ItemGroup>
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
 	</ItemGroup>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
index 81547955..b4cc2614 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
@@ -1,21 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Text.Json;
-using System.Text.Json.Serialization;
-using Dahomey.Json;
-using Dahomey.Json.Serialization.Converters.Factories;
 
 namespace GraphQL.Client.Serializer.SystemTextJson {
 	public static class JsonSerializerOptionsExtensions {
-		public static JsonSerializerOptions SetupDahomeyExtensions(
+		public static JsonSerializerOptions SetupImmutableConverter(
 			this JsonSerializerOptions options) {
 			options.Converters.Add(new ImmutableConverter());
-			//options.Converters.Add((JsonConverter)new JsonSerializerOptionsState(options));
-			//options.Converters.Add((JsonConverter)new DictionaryConverterFactory());
-			//options.Converters.Add((JsonConverter)new CollectionConverterFactory());
-			//options.Converters.Add((JsonConverter)new JsonNodeConverterFactory());
-			//options.Converters.Add((JsonConverter)new ObjectConverterFactory());
 			return options;
 		}
 	}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index a00c834b..0f3b1e2c 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -3,7 +3,6 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
-using Dahomey.Json;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 
@@ -13,7 +12,7 @@ public class SystemTextJsonSerializer: IGraphQLWebsocketJsonSerializer
     {
 	    public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions {
 		    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-	    }.SetupDahomeyExtensions();
+	    }.SetupImmutableConverter();
 		
 		public JsonSerializerOptions Options { get; }
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index 212aefa6..76f9ff78 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -1,5 +1,4 @@
 using System.Text.Json;
-using Dahomey.Json;
 using GraphQL.Client.Serializer.SystemTextJson;
 
 namespace GraphQL.Client.Serializer.Tests {
@@ -9,6 +8,6 @@ public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) {
 
 	public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
 		public SystemTextJsonSerializeNoCamelCaseTest()
-			: base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupDahomeyExtensions())) { }
+			: base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupImmutableConverter())) { }
 	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 4f9d694c..404fda64 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -13,6 +13,10 @@ public IEnumerator<object[]> GetEnumerator() {
 				"{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}",
 				new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
 			};
+			yield return new object[] {
+				"{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"authentication\":\"an-authentication-token\"}",
+				new GraphQLRequest("simple query string"){{"authentication", "an-authentication-token"}}
+			};
 		}
 
 		IEnumerator IEnumerable.GetEnumerator() {

From 68e6b1f60e5c5b808bd8ba25e49a2754c8d85b89 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 17:27:52 +0100
Subject: [PATCH 212/455] fix GraphQLRequest.Equals

---
 src/GraphQL.Primitives/GraphQLRequest.cs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index ae174392..ed351a10 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -64,9 +64,7 @@ public override bool Equals(object? obj) {
 		public virtual bool Equals(GraphQLRequest? other) {
 			if (ReferenceEquals(null, other)) return false;
 			if (ReferenceEquals(this, other)) return true;
-			return Query == other.Query
-				   && OperationName == other.OperationName
-				   && EqualityComparer<object>.Default.Equals(Variables, other.Variables);
+			return EqualityComparer<Dictionary<string,object>>.Default.Equals(this, other);
 		}
 
 		/// <summary>

From a72700006a0d5fb797bdc0d1d2bc0708556ebb09 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 9 Mar 2020 18:17:23 +0100
Subject: [PATCH 213/455] fix stack overflow in equality comparer

---
 src/GraphQL.Primitives/GraphQLRequest.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index ed351a10..c8931c90 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.Serialization;
 
 namespace GraphQL {
@@ -64,7 +65,7 @@ public override bool Equals(object? obj) {
 		public virtual bool Equals(GraphQLRequest? other) {
 			if (ReferenceEquals(null, other)) return false;
 			if (ReferenceEquals(this, other)) return true;
-			return EqualityComparer<Dictionary<string,object>>.Default.Equals(this, other);
+			return this.Count == other.Count && !this.Except(other).Any();
 		}
 
 		/// <summary>

From e856fe512d2af1175db0ca8f375eaf5e9752a97b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sun, 15 Mar 2020 11:00:15 +0100
Subject: [PATCH 214/455] fix GraphQLExtensionsConverter for Newtonsoft

---
 .../GraphQLExtensionsConverter.cs             | 59 +++++++++----------
 .../BaseSerializerTest.cs                     | 18 ++++++
 .../TestData/DeserializeResponseTestData.cs   | 46 +++++++++++++++
 3 files changed, 91 insertions(+), 32 deletions(-)
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
index 0ff13a0f..4c603f0c 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
@@ -24,43 +24,33 @@ public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectTyp
 		}
 
 		private object ReadToken(JToken? token) {
-			switch (token.Type) {
-				case JTokenType.Undefined:
-				case JTokenType.None:
-					return null;
-				case JTokenType.Object:
-					return ReadDictionary<Dictionary<string, object>>(token);
-				case JTokenType.Array:
-					return ReadArray(token);
-				case JTokenType.Integer:
-					return token.Value<int>();
-				case JTokenType.Float:
-					return token.Value<double>();
-				case JTokenType.Raw:
-				case JTokenType.String:
-				case JTokenType.Uri:
-					return token.Value<string>();
-				case JTokenType.Boolean:
-					return token.Value<bool>();
-				case JTokenType.Date:
-					return token.Value<DateTime>();
-				case JTokenType.Bytes:
-					return token.Value<byte[]>();
-				case JTokenType.Guid:
-					return token.Value<Guid>();
-				case JTokenType.TimeSpan:
-					return token.Value<TimeSpan>();
-				case JTokenType.Constructor:
-				case JTokenType.Property:
-				case JTokenType.Comment:
-				default:
-					throw new ArgumentOutOfRangeException();
-			}
+			return token.Type switch {
+				JTokenType.Undefined => null,
+				JTokenType.None => null,
+				JTokenType.Null => null,
+				JTokenType.Object => ReadDictionary<Dictionary<string, object>>(token),
+				JTokenType.Array => ReadArray(token),
+				JTokenType.Integer => token.Value<int>(),
+				JTokenType.Float => token.Value<double>(),
+				JTokenType.Raw => token.Value<string>(),
+				JTokenType.String => token.Value<string>(),
+				JTokenType.Uri => token.Value<string>(),
+				JTokenType.Boolean => token.Value<bool>(),
+				JTokenType.Date => token.Value<DateTime>(),
+				JTokenType.Bytes => token.Value<byte[]>(),
+				JTokenType.Guid => token.Value<Guid>(),
+				JTokenType.TimeSpan => token.Value<TimeSpan>(),
+				JTokenType.Constructor => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON constructor"),
+				JTokenType.Property => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON property"),
+				JTokenType.Comment => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON comment"),
+				_ => throw new ArgumentOutOfRangeException(nameof(token.Type))
+			};
 		}
 
 		private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionary : Dictionary<string, object> {
 			var result = Activator.CreateInstance<TDictionary>();
 			foreach (var property in ((JObject)element).Properties()) {
+				if (IsUnsupportedJTokenType(property.Value.Type)) continue;
 				result[property.Name] = ReadToken(property.Value);
 			}
 			return result;
@@ -68,8 +58,13 @@ private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionar
 
 		private IEnumerable<object> ReadArray(JToken element) {
 			foreach (var item in element.Values()) {
+				if (IsUnsupportedJTokenType(item.Type)) continue;
 				yield return ReadToken(item);
 			}
 		}
+
+		private bool IsUnsupportedJTokenType(JTokenType type) {
+			return type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
+		}
 	}
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 26d44472..ee818ff1 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -1,6 +1,8 @@
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
@@ -41,6 +43,22 @@ public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest re
 			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
 		}
 
+		[Theory]
+		[ClassData(typeof(DeserializeResponseTestData))]
+		public async void DeserializeFromUtf8StreamTest(string json, GraphQLResponse<object> expectedResponse) {
+			var jsonBytes = Encoding.UTF8.GetBytes(json);
+			await using var ms = new MemoryStream(jsonBytes);
+			var response = await Serializer.DeserializeFromUtf8StreamAsync<GraphQLResponse<object>>(ms, CancellationToken.None);
+			
+			response.Should().BeEquivalentTo(expectedResponse, options => {
+				options.ComparingByMembers<GraphQLExtensionsType>();
+				options.ComparingByMembers<Dictionary<string, object>>();
+				options.ComparingByMembers<KeyValuePair<string, object>>();
+				options.AllowingInfiniteRecursion();
+				return options;
+			});
+		}
+
 		[Fact]
 		public async void CanDeserializeExtensions() {
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
new file mode 100644
index 00000000..61ebb0b0
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Client.Serializer.Tests.TestData {
+	public class DeserializeResponseTestData : IEnumerable<object[]> {
+		public IEnumerator<object[]> GetEnumerator() {
+			// object array structure:
+			// [0]: input json
+			// [1]: expected deserialized response
+
+			yield return new object[] {
+				"{\"errors\":[{\"message\":\"Throttled\",\"extensions\":{\"code\":\"THROTTLED\",\"documentation\":\"https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits\"}}],\"extensions\":{\"cost\":{\"requestedQueryCost\":992,\"actualQueryCost\":null,\"throttleStatus\":{\"maximumAvailable\":1000,\"currentlyAvailable\":632,\"restoreRate\":50}}}}",
+				new GraphQLResponse<object> {
+					Data = null,
+					Errors = new[] {
+						new GraphQLError {
+							Message = "Throttled",
+							Extensions = new GraphQLExtensionsType {
+								{"code", "THROTTLED" },
+								{"documentation", "https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits" }
+							}
+						}
+					},
+					Extensions = new GraphQLExtensionsType {
+						{"cost", new Dictionary<string, object> {
+							{"requestedQueryCost", 992},
+							{"actualQueryCost", null},
+							{"throttleStatus", new Dictionary<string, object> {
+								{"maximumAvailable", 1000},
+								{"currentlyAvailable", 632},
+								{"restoreRate", 50}
+							}}
+						}}
+					}
+				}
+			};
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return GetEnumerator();
+		}
+
+	}
+}

From 093621c2b69246108ce9eb0f3ccd7b29885394df Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sun, 15 Mar 2020 11:08:21 +0100
Subject: [PATCH 215/455] fix test

---
 src/GraphQL.Primitives/GraphQLResponse.cs     | 27 ++++++++++++++-----
 .../BaseSerializerTest.cs                     | 20 ++++++++------
 2 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 088be7bd..94a6ea21 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -22,13 +22,19 @@ public bool Equals(GraphQLResponse<T>? other) {
 			if (other == null) { return false; }
 			if (ReferenceEquals(this, other)) { return true; }
 			if (!EqualityComparer<T>.Default.Equals(this.Data, other.Data)) { return false; }
-			{
-				if (this.Errors != null && other.Errors != null) {
-					if (!Enumerable.SequenceEqual(this.Errors, other.Errors)) { return false; }
-				}
-				else if (this.Errors != null && other.Errors == null) { return false; }
-				else if (this.Errors == null && other.Errors != null) { return false; }
+
+			if (this.Errors != null && other.Errors != null) {
+				if (!Enumerable.SequenceEqual(this.Errors, other.Errors)) { return false; }
+			}
+			else if (this.Errors != null && other.Errors == null) { return false; }
+			else if (this.Errors == null && other.Errors != null) { return false; }
+
+			if (this.Extensions!= null && other.Extensions != null) {
+				if (!Enumerable.SequenceEqual(this.Extensions, other.Extensions)) { return false; }
 			}
+			else if (this.Extensions != null && other.Extensions == null) { return false; }
+			else if (this.Extensions == null && other.Extensions != null) { return false; }
+
 			return true;
 		}
 
@@ -44,6 +50,15 @@ public override int GetHashCode() {
 					else {
 						hashCode = (hashCode * 397) ^ 0;
 					}
+
+					if (this.Extensions != null) {
+						foreach (var element in this.Extensions) {
+							hashCode = (hashCode * 397) ^ EqualityComparer<KeyValuePair<string,object>>.Default.GetHashCode(element);
+						}
+					}
+					else {
+						hashCode = (hashCode * 397) ^ 0;
+					}
 				}
 				return hashCode;
 			}
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index ee818ff1..1f3a19c2 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -49,14 +49,18 @@ public async void DeserializeFromUtf8StreamTest(string json, GraphQLResponse<obj
 			var jsonBytes = Encoding.UTF8.GetBytes(json);
 			await using var ms = new MemoryStream(jsonBytes);
 			var response = await Serializer.DeserializeFromUtf8StreamAsync<GraphQLResponse<object>>(ms, CancellationToken.None);
-			
-			response.Should().BeEquivalentTo(expectedResponse, options => {
-				options.ComparingByMembers<GraphQLExtensionsType>();
-				options.ComparingByMembers<Dictionary<string, object>>();
-				options.ComparingByMembers<KeyValuePair<string, object>>();
-				options.AllowingInfiniteRecursion();
-				return options;
-			});
+
+			response.Data.Should().BeEquivalentTo(expectedResponse.Data);
+			response.Errors.Should().Equal(expectedResponse.Errors);
+
+			if (expectedResponse.Extensions == null)
+				response.Extensions.Should().BeNull();
+			else {
+				foreach (var element in expectedResponse.Extensions) {
+					response.Extensions.Should().ContainKey(element.Key);
+					response.Extensions[element.Key].Should().BeEquivalentTo(element.Value);
+				}
+			}
 		}
 
 		[Fact]

From 194c152b94b2b52510e09b9f3e8241f96732624f Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sun, 15 Mar 2020 23:18:19 +0100
Subject: [PATCH 216/455] allow access to HttpResponseHeaders

---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 61 +++++++++++++++++--
 src/GraphQL.Client/GraphQLHttpResponse.cs     | 12 +++-
 .../QueryAndMutationTests/Base.cs             | 15 +++++
 3 files changed, 81 insertions(+), 7 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 30e85fd0..4e9cbf04 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -64,10 +65,12 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 		#region IGraphQLClient
 
 		/// <inheritdoc />
-		public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken)
-				: this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
+		public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			if(Options.UseWebSocketForQueriesAndMutations)
+				return await this.graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
+			
+			var response = await this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
+			return response.Response;
 		}
 
 		/// <inheritdoc />
@@ -114,18 +117,64 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 		/// <returns></returns>
 		public Task InitializeWebsocketConnection() => graphQlHttpWebSocket.InitializeWebSocket();
 
+		/// <summary>
+		/// Sends a query to the GraphQL server and deserializes the response. Provides access to the HTTP response headers. This method will never utilize the websocket connection!
+		/// </summary>
+		/// <typeparam name="TResponse"></typeparam>
+		/// <param name="request"></param>
+		/// <param name="cancellationToken"></param>
+		/// <returns></returns>
+		public Task<GraphQLHttpResponse<TResponse>> SendQueryHttpAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+			return this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
+		}
+		/// <inheritdoc cref="SendQueryHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
+		public Task<GraphQLHttpResponse<TResponse>> SendQueryHttpAsync<TResponse>(GraphQLRequest request,
+			Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+			=> SendQueryHttpAsync<TResponse>(request, cancellationToken);
+		/// <inheritdoc cref="SendQueryHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
+		public Task<GraphQLHttpResponse<TResponse>> SendQueryHttpAsync<TResponse>(string query, object? variables = null,
+			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
+			return SendQueryHttpAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
+		}
+
+		/// <summary>
+		/// Sends a mutation to the GraphQL server and deserializes the response. Provides access to the HTTP response headers. This method will never utilize the websocket connection!
+		/// </summary>
+		/// <typeparam name="TResponse"></typeparam>
+		/// <param name="request"></param>
+		/// <param name="cancellationToken"></param>
+		/// <returns></returns>
+		public Task<GraphQLHttpResponse<TResponse>> SendMutationHttpAsync<TResponse>(GraphQLRequest request,
+			CancellationToken cancellationToken = default)
+			=> SendQueryHttpAsync<TResponse>(request, cancellationToken);
+		/// <inheritdoc cref="SendMutationHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
+		public Task<GraphQLHttpResponse<TResponse>> SendMutationHttpAsync<TResponse>(GraphQLRequest request,
+			Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+			=> SendQueryHttpAsync<TResponse>(request, cancellationToken);
+		/// <inheritdoc cref="SendMutationHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
+		public Task<GraphQLHttpResponse<TResponse>> SendMutationHttpAsync<TResponse>(string query, object? variables = null,
+			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
+			return SendQueryHttpAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
+		}
+
 		#region Private Methods
 
-		private async Task<GraphQLResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
 			var preprocessedRequest = await Options.PreprocessRequest(request, this);
 			using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest);
 			using var httpResponseMessage = await this.HttpClient.SendAsync(httpRequestMessage, cancellationToken);
 			if (!httpResponseMessage.IsSuccessStatusCode) {
 				throw new GraphQLHttpException(httpResponseMessage);
 			}
+			
+			var response = new GraphQLHttpResponse<TResponse> {
+				ResponseHeaders = httpResponseMessage.Headers,
+				StatusCode = httpResponseMessage.StatusCode
+			};
 
 			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
-			return await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
+			response.Response = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
+			return response;
 		}
 
 		private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request) {
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index 1dbfea30..30282b00 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -1,5 +1,15 @@
+using System.Net;
+using System.Net.Http.Headers;
+
 namespace GraphQL.Client.Http {
 
-	public class GraphQLHttpResponse<T> : GraphQLResponse<T> {
+	public class GraphQLHttpResponse<T> {
+		public GraphQLHttpResponse()
+		{
+		}
+		
+		public GraphQLResponse<T> Response { get; set; }
+		public HttpResponseHeaders ResponseHeaders { get; set; }
+		public HttpStatusCode StatusCode { get; set; }
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index e60c26f0..51328c7b 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -1,3 +1,5 @@
+using System;
+using System.Net;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -46,6 +48,19 @@ public async void QueryTheory(int id, string name) {
 			Assert.Equal(name, response.Data.Human.Name);
 		}
 
+		[Theory]
+		[ClassData(typeof(StarWarsHumans))]
+		public async void QueryHttpTheory(int id, string name) {
+			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+			var httpResponse = await StarWarsClient.SendQueryHttpAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+
+			httpResponse.Response.Errors.Should().BeNull();
+			httpResponse.Response.Data.Human.Name.Should().Be(name);
+
+			httpResponse.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
+			httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));
+		}
+
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
 		public async void QueryWithDynamicReturnTypeTheory(int id, string name) {

From 78eac27a30a440bf27fe7806b9c6c8ac5041bffd Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 20 Mar 2020 21:01:04 +0100
Subject: [PATCH 217/455] let GraphQLHttpResponse<T> inherit from
 GraphQLResponse<T>

---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 58 ++-----------------
 src/GraphQL.Client/GraphQLHttpResponse.cs     | 31 ++++++++--
 .../QueryAndMutationTests/Base.cs             | 14 +++--
 3 files changed, 42 insertions(+), 61 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 4e9cbf04..5f000dda 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -66,11 +66,10 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
 
 		/// <inheritdoc />
 		public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			if(Options.UseWebSocketForQueriesAndMutations)
+			if (Options.UseWebSocketForQueriesAndMutations)
 				return await this.graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
-			
-			var response = await this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
-			return response.Response;
+
+			return await this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
 		}
 
 		/// <inheritdoc />
@@ -116,47 +115,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 		/// </summary>
 		/// <returns></returns>
 		public Task InitializeWebsocketConnection() => graphQlHttpWebSocket.InitializeWebSocket();
-
-		/// <summary>
-		/// Sends a query to the GraphQL server and deserializes the response. Provides access to the HTTP response headers. This method will never utilize the websocket connection!
-		/// </summary>
-		/// <typeparam name="TResponse"></typeparam>
-		/// <param name="request"></param>
-		/// <param name="cancellationToken"></param>
-		/// <returns></returns>
-		public Task<GraphQLHttpResponse<TResponse>> SendQueryHttpAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			return this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
-		}
-		/// <inheritdoc cref="SendQueryHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
-		public Task<GraphQLHttpResponse<TResponse>> SendQueryHttpAsync<TResponse>(GraphQLRequest request,
-			Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-			=> SendQueryHttpAsync<TResponse>(request, cancellationToken);
-		/// <inheritdoc cref="SendQueryHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
-		public Task<GraphQLHttpResponse<TResponse>> SendQueryHttpAsync<TResponse>(string query, object? variables = null,
-			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
-			return SendQueryHttpAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
-		}
-
-		/// <summary>
-		/// Sends a mutation to the GraphQL server and deserializes the response. Provides access to the HTTP response headers. This method will never utilize the websocket connection!
-		/// </summary>
-		/// <typeparam name="TResponse"></typeparam>
-		/// <param name="request"></param>
-		/// <param name="cancellationToken"></param>
-		/// <returns></returns>
-		public Task<GraphQLHttpResponse<TResponse>> SendMutationHttpAsync<TResponse>(GraphQLRequest request,
-			CancellationToken cancellationToken = default)
-			=> SendQueryHttpAsync<TResponse>(request, cancellationToken);
-		/// <inheritdoc cref="SendMutationHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
-		public Task<GraphQLHttpResponse<TResponse>> SendMutationHttpAsync<TResponse>(GraphQLRequest request,
-			Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-			=> SendQueryHttpAsync<TResponse>(request, cancellationToken);
-		/// <inheritdoc cref="SendMutationHttpAsync{TResponse}(GraphQL.GraphQLRequest,System.Threading.CancellationToken)"/>
-		public Task<GraphQLHttpResponse<TResponse>> SendMutationHttpAsync<TResponse>(string query, object? variables = null,
-			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
-			return SendQueryHttpAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
-		}
-
+		
 		#region Private Methods
 
 		private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
@@ -166,15 +125,10 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TRes
 			if (!httpResponseMessage.IsSuccessStatusCode) {
 				throw new GraphQLHttpException(httpResponseMessage);
 			}
-			
-			var response = new GraphQLHttpResponse<TResponse> {
-				ResponseHeaders = httpResponseMessage.Headers,
-				StatusCode = httpResponseMessage.StatusCode
-			};
 
 			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
-			response.Response = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
-			return response;
+			var response = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
+			return response.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
 		}
 
 		private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request) {
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index 30282b00..b14d8790 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -1,15 +1,36 @@
+using System;
 using System.Net;
 using System.Net.Http.Headers;
 
 namespace GraphQL.Client.Http {
 
-	public class GraphQLHttpResponse<T> {
-		public GraphQLHttpResponse()
-		{
+	public class GraphQLHttpResponse<T>: GraphQLResponse<T> {
+		public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) {
+			Data = response.Data;
+			Errors = response.Errors;
+			Extensions = response.Extensions;
+			ResponseHeaders = responseHeaders;
+			StatusCode = statusCode;
 		}
-		
-		public GraphQLResponse<T> Response { get; set; }
+
 		public HttpResponseHeaders ResponseHeaders { get; set; }
 		public HttpStatusCode StatusCode { get; set; }
 	}
+
+	public static class GraphQLResponseExtensions {
+		public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) {
+			return new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
+		}
+
+		/// <summary>
+		/// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws ig the cast fails.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="response"></param>
+		/// <exception cref="InvalidCastException"><paramref name="response"/> is not a <see cref="GraphQLHttpResponse{T}"/></exception>
+		/// <returns></returns>
+		public static GraphQLHttpResponse<T> AsGraphQLHttpResponse<T>(this GraphQLResponse<T> response) {
+			return (GraphQLHttpResponse<T>) response;
+		}
+	}
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 51328c7b..e55fd2c6 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -50,12 +50,18 @@ public async void QueryTheory(int id, string name) {
 
 		[Theory]
 		[ClassData(typeof(StarWarsHumans))]
-		public async void QueryHttpTheory(int id, string name) {
+		public async void QueryAsHttpResponseTheory(int id, string name) {
 			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
-			var httpResponse = await StarWarsClient.SendQueryHttpAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+			var responseType = new {Human = new {Name = string.Empty}};
+			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => responseType );
 
-			httpResponse.Response.Errors.Should().BeNull();
-			httpResponse.Response.Data.Human.Name.Should().Be(name);
+			FluentActions.Invoking(() => response.AsGraphQLHttpResponse()).Should()
+				.NotThrow("because the returned object is a GraphQLHttpResponse");
+
+			var httpResponse = response.AsGraphQLHttpResponse();
+
+			httpResponse.Errors.Should().BeNull();
+			httpResponse.Data.Human.Name.Should().Be(name);
 
 			httpResponse.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
 			httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));

From 7660bcc8a3fabc9995b04c7255b5eea939f96513 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 20 Mar 2020 22:09:55 +0100
Subject: [PATCH 218/455] use .editorconfig from graphql-dotnet

---
 .editorconfig | 259 +++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 248 insertions(+), 11 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index d8898a08..8f9adfad 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,19 +1,256 @@
-# EditorConfig (http://editorconfig.org/)
+# EditorConfig is awesome: http://EditorConfig.org
+
+# Create portable, custom editor settings with EditorConfig
+# https://docs.microsoft.com/en-us/visualstudio/ide/create-portable-custom-editor-options
+
+# .NET coding convention settings for EditorConfig
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2019
+
+# Language conventions
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019
+
+# Formatting conventions
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions?view=vs-2019
+
+# .NET naming conventions for EditorConfig
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions?view=vs-2019
+
+# Top-most EditorConfig file
 root = true
 
-# Default Code Style
+# Editor default newlines with a newline ending every file
 [*]
-charset = utf-8
-end_of_line = lf
-indent_size = 4
-indent_style = tab
 insert_final_newline = true
-tab_width = 4
+charset = utf-8
+indent_style = space
+indent_size = 2
 trim_trailing_whitespace = true
 
 [*.cs]
-csharp_new_line_before_open_brace = false
+indent_size = 4
 
-[*.{yaml,yml}]
-indent_size = 2
-indent_style = space
+# Do not insert newline for ApiApprovalTests
+[*.txt]
+insert_final_newline = false
+
+# Code files
+[*.{cs,vb}]
+ 
+# .NET code style settings - "This." and "Me." qualifiers
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#this-and-me
+dotnet_style_qualification_for_field = false:warning
+dotnet_style_qualification_for_property = false:warning
+dotnet_style_qualification_for_method = false:warning
+dotnet_style_qualification_for_event = false:warning
+
+# .NET code style settings - Language keywords instead of framework type names for type references
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#language-keywords
+dotnet_style_predefined_type_for_locals_parameters_members = true:error
+dotnet_style_predefined_type_for_member_access = true:error
+
+# .NET code style settings - Modifier preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#normalize-modifiers
+dotnet_style_require_accessibility_modifiers = always:warning
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning
+dotnet_style_readonly_field = true:warning
+
+# .NET code style settings - Parentheses preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#parentheses-preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:suggestion
+dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:suggestion
+dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:suggestion
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary:suggestion
+
+# .NET code style settings - Expression-level preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#expression-level-preferences
+dotnet_style_object_initializer = true:error
+dotnet_style_collection_initializer = true:error
+dotnet_style_explicit_tuple_names = true:warning
+dotnet_style_prefer_inferred_tuple_names = true:suggestion
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
+dotnet_style_prefer_auto_properties = true:warning
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
+dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion
+dotnet_style_prefer_conditional_expression_over_return = true:suggestion
+dotnet_style_prefer_compound_assignment = true:warning
+
+# .NET code style settings - Null-checking preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#null-checking-preferences
+dotnet_style_coalesce_expression = true:warning
+dotnet_style_null_propagation = true:error
+
+# .NET code quality settings - Parameter preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#parameter-preferences
+dotnet_code_quality_unused_parameters = all:warning
+
+# C# code style settings - Implicit and explicit types
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#implicit-and-explicit-types
+csharp_style_var_for_built_in_types = false:suggestion
+csharp_style_var_when_type_is_apparent = true:warning
+csharp_style_var_elsewhere = true:suggestion
+
+# C# code style settings - Expression-bodied members
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#expression-bodied-members
+csharp_style_expression_bodied_methods = when_on_single_line:warning
+csharp_style_expression_bodied_constructors = false:suggestion
+csharp_style_expression_bodied_operators = when_on_single_line:warning
+csharp_style_expression_bodied_properties = when_on_single_line:warning
+csharp_style_expression_bodied_indexers = when_on_single_line:warning
+csharp_style_expression_bodied_accessors = when_on_single_line:warning
+csharp_style_expression_bodied_lambdas = when_on_single_line:warning
+csharp_style_expression_bodied_local_functions = when_on_single_line:warning
+
+# C# code style settings - Pattern matching
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#pattern-matching
+csharp_style_pattern_matching_over_is_with_cast_check = true:error
+csharp_style_pattern_matching_over_as_with_null_check = true:error
+
+# C# code style settings - Inlined variable declaration
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#inlined-variable-declarations
+csharp_style_inlined_variable_declaration = true:error
+
+# C# code style settings - C# expression-level preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#c-expression-level-preferences
+csharp_prefer_simple_default_expression = true:suggestion
+
+# C# code style settings - C# null-checking preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#c-null-checking-preferences
+csharp_style_throw_expression = true:warning
+csharp_style_conditional_delegate_call = true:warning
+
+# C# code style settings - Code block preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#code-block-preferences
+csharp_prefer_braces = false:suggestion
+
+# C# code style - Unused value preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#unused-value-preferences
+csharp_style_unused_value_expression_statement_preference = discard_variable:suggestion
+csharp_style_unused_value_assignment_preference = discard_variable:suggestion
+
+# C# code style - Index and range preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#index-and-range-preferences
+csharp_style_prefer_index_operator = true:warning
+csharp_style_prefer_range_operator = true:warning
+
+# C# code style - Miscellaneous preferences
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#miscellaneous-preferences
+csharp_style_deconstructed_variable_declaration = true:suggestion
+csharp_style_pattern_local_over_anonymous_function = true:suggestion
+csharp_using_directive_placement = outside_namespace:warning
+csharp_prefer_static_local_function = true:suggestion
+csharp_prefer_simple_using_statement = false:suggestion
+csharp_style_prefer_switch_expression = true:suggestion
+
+# .NET formatting settings - Organize using directives
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions?view=vs-2019#organize-using-directives
+dotnet_sort_system_directives_first = true
+dotnet_separate_import_directive_groups = false
+
+# C# formatting settings - New-line options
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions?view=vs-2019#new-line-options
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_between_query_expression_clauses = true
+
+# C# formatting settings - Indentation options
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions?view=vs-2019#indentation-options
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = one_less_than_current
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents_when_block = false
+
+# C# formatting settings - Spacing options
+csharp_space_after_cast = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_between_parentheses = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_after_comma = true
+csharp_space_before_comma = false
+csharp_space_after_dot = false
+csharp_space_before_dot = false
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_around_declaration_statements = false
+csharp_space_before_open_square_brackets = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_square_brackets = false
+
+# C# formatting settings - Wrap options
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions?view=vs-2019#wrap-options
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = false
+
+########## name all private fields using camelCase with underscore prefix ##########
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions?view=vs-2019
+# dotnet_naming_rule.<namingRuleTitle>.symbols = <symbolTitle>
+dotnet_naming_rule.private_fields_with_underscore.symbols = private_fields
+ 
+# dotnet_naming_symbols.<symbolTitle>.<property> = <value>
+dotnet_naming_symbols.private_fields.applicable_kinds = field
+dotnet_naming_symbols.private_fields.applicable_accessibilities = private
+ 
+# dotnet_naming_rule.<namingRuleTitle>.style = <styleTitle>
+dotnet_naming_rule.private_fields_with_underscore.style = prefix_underscore
+ 
+# dotnet_naming_style.<styleTitle>.<property> = <value>
+dotnet_naming_style.prefix_underscore.capitalization = camel_case
+dotnet_naming_style.prefix_underscore.required_prefix = _
+ 
+# dotnet_naming_rule.<namingRuleTitle>.severity = <value>
+dotnet_naming_rule.private_fields_with_underscore.severity = warning
+
+########## name all constant fields using UPPER_CASE ##########
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions?view=vs-2019
+# dotnet_naming_rule.<namingRuleTitle>.symbols = <symbolTitle>
+dotnet_naming_rule.constant_fields_should_be_upper_case.symbols = constant_fields
+
+# dotnet_naming_symbols.<symbolTitle>.<property> = <value>
+dotnet_naming_symbols.constant_fields.applicable_kinds = field
+dotnet_naming_symbols.constant_fields.applicable_accessibilities = *
+dotnet_naming_symbols.constant_fields.required_modifiers = const
+
+# dotnet_naming_rule.<namingRuleTitle>.style = <styleTitle>
+dotnet_naming_rule.constant_fields_should_be_upper_case.style = upper_case_style
+
+# dotnet_naming_style.<styleTitle>.<property> = <value>
+dotnet_naming_style.upper_case_style.capitalization = all_upper
+dotnet_naming_style.upper_case_style.word_separator = _
+
+# dotnet_naming_rule.<namingRuleTitle>.severity = <value>
+dotnet_naming_rule.constant_fields_should_be_upper_case.severity = warning
+
+########## Async methods should have "Async" suffix ##########
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions?view=vs-2019
+# dotnet_naming_rule.<namingRuleTitle>.symbols = <symbolTitle>
+dotnet_naming_rule.async_methods_end_in_async.symbols = any_async_methods
+
+# dotnet_naming_symbols.<symbolTitle>.<property> = <value>
+dotnet_naming_symbols.any_async_methods.applicable_kinds = method
+dotnet_naming_symbols.any_async_methods.applicable_accessibilities = *
+dotnet_naming_symbols.any_async_methods.required_modifiers = async
+
+# dotnet_naming_rule.<namingRuleTitle>.style = <styleTitle>
+dotnet_naming_rule.async_methods_end_in_async.style = end_in_async_style
+
+# dotnet_naming_style.<styleTitle>.<property> = <value>
+dotnet_naming_style.end_in_async_style.capitalization = pascal_case
+dotnet_naming_style.end_in_async_style.word_separator = 
+dotnet_naming_style.end_in_async_style.required_prefix = 
+dotnet_naming_style.end_in_async_style.required_suffix = Async
+
+# dotnet_naming_rule.<namingRuleTitle>.severity = <value>
+dotnet_naming_rule.async_methods_end_in_async.severity = warning

From 19b5ae59ff0e6eb4b1c6bb6c1093156ba0b38718 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 20 Mar 2020 22:29:59 +0100
Subject: [PATCH 219/455] run dotnet-format on the solution

---
 .../PersonAndFilmsResponse.cs                 |   30 +-
 examples/GraphQL.Client.Example/Program.cs    |   59 +-
 .../GraphQLWebSocketMessageType.cs            |  152 +--
 .../GraphQLWebSocketRequest.cs                |  206 +--
 .../GraphQLWebSocketResponse.cs               |  180 +--
 .../GraphQLWebsocketConnectionState.cs        |   14 +-
 .../IGraphQLWebsocketJsonSerializer.cs        |   19 +-
 .../WebsocketMessageWrapper.cs                |   12 +-
 .../GraphQLClientExtensions.cs                |   54 +-
 .../GraphQLJsonSerializerExtensions.cs        |   53 +-
 .../IGraphQLClient.cs                         |   52 +-
 .../IGraphQLJsonSerializer.cs                 |   14 +-
 .../ExecutionResultExtensions.cs              |   10 +-
 .../GraphQLEnumConverter.cs                   |   51 +-
 .../GraphQLLocalExecutionClient.cs            |  208 +--
 .../GraphQLExtensionsConverter.cs             |  126 +-
 .../NewtonsoftJsonSerializer.cs               |   89 +-
 .../GraphQLExtensionsConverter.cs             |  123 +-
 .../ImmutableConverter.cs                     |  347 ++---
 .../JsonSerializerOptionsExtensions.cs        |   19 +-
 .../SystemTextJsonSerializer.cs               |   94 +-
 src/GraphQL.Client/GraphQLHttpClient.cs       |  311 ++---
 .../GraphQLHttpClientExtensions.cs            |   56 +-
 .../GraphQLHttpClientOptions.cs               |  105 +-
 src/GraphQL.Client/GraphQLHttpException.cs    |   37 +-
 src/GraphQL.Client/GraphQLHttpRequest.cs      |   30 +-
 src/GraphQL.Client/GraphQLHttpResponse.cs     |   60 +-
 .../GraphQLSubscriptionException.cs           |   41 +-
 src/GraphQL.Client/HttpClientExtensions.cs    |   20 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 1143 +++++++++--------
 src/GraphQL.Primitives/GraphQLError.cs        |  193 +--
 .../GraphQLExtensionsType.cs                  |   11 +-
 src/GraphQL.Primitives/GraphQLLocation.cs     |  109 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |  179 +--
 src/GraphQL.Primitives/GraphQLResponse.cs     |  156 ++-
 .../BaseSerializeNoCamelCaseTest.cs           |   84 +-
 .../BaseSerializerTest.cs                     |  163 +--
 .../NewtonsoftSerializerTest.cs               |   19 +-
 .../SystemTextJsonSerializerTests.cs          |   19 +-
 .../TestData/DeserializeResponseTestData.cs   |   78 +-
 .../TestData/SerializeToBytesTestData.cs      |   54 +-
 .../TestData/SerializeToStringTestData.cs     |   44 +-
 .../Chat/AddMessageMutationResult.cs          |   14 +-
 .../Chat/AddMessageVariables.cs               |   21 +-
 .../Chat/GraphQLClientChatExtensions.cs       |   51 +-
 .../Chat/JoinDeveloperMutationResult.cs       |   16 +-
 .../Chat/Schema/CapitalizedFieldsGraphType.cs |   21 +-
 .../Chat/Schema/ChatMutation.cs               |   67 +-
 .../Chat/Schema/ChatQuery.cs                  |   77 +-
 .../Chat/Schema/ChatSchema.cs                 |   21 +-
 .../Chat/Schema/ChatSubscriptions.cs          |  165 +--
 .../Chat/Schema/IChat.cs                      |  192 +--
 .../Chat/Schema/Message.cs                    |   16 +-
 .../Chat/Schema/MessageFrom.cs                |   12 +-
 .../Chat/Schema/MessageFromType.cs            |   17 +-
 .../Chat/Schema/MessageType.cs                |   30 +-
 .../Chat/Schema/ReceivedMessage.cs            |   14 +-
 tests/GraphQL.Client.Tests.Common/Common.cs   |   83 +-
 .../Helpers/AvailableJsonSerializers.cs       |   36 +-
 .../Helpers/CallbackMonitor.cs                |  150 ++-
 .../Helpers/ConcurrentTaskWrapper.cs          |   87 +-
 .../Helpers/MiscellaneousExtensions.cs        |   39 +-
 .../Helpers/NetworkHelpers.cs                 |   23 +-
 .../Helpers/ObservableTester.cs               |  327 ++---
 .../StarWars/StarWarsHumans.cs                |   24 +-
 .../WebApplicationFactoryExtensions.cs        |   25 +-
 .../Helpers/IntegrationServerTestFixture.cs   |   98 +-
 .../Helpers/WebHostHelpers.cs                 |  106 +-
 .../QueryAndMutationTests/Base.cs             |  326 ++---
 .../QueryAndMutationTests/Newtonsoft.cs       |   14 +-
 .../QueryAndMutationTests/SystemTextJson.cs   |   14 +-
 .../WebsocketTests/Base.cs                    |  704 +++++-----
 .../WebsocketTests/Newtonsoft.cs              |   12 +-
 .../WebsocketTests/SystemTextJson.cs          |   14 +-
 .../GraphQLLocationTest.cs                    |  115 +-
 .../GraphQLRequestTest.cs                     |  331 ++---
 .../GraphQLResponseTest.cs                    |  186 +--
 .../JsonSerializationTests.cs                 |   43 +-
 .../GraphQL/Models/Repository.cs              |   40 +-
 tests/GraphQL.Server.Test/GraphQL/Storage.cs  |   27 +-
 .../GraphQL/TestMutation.cs                   |   13 +-
 .../GraphQL.Server.Test/GraphQL/TestQuery.cs  |   24 +-
 .../GraphQL.Server.Test/GraphQL/TestSchema.cs |   19 +-
 .../GraphQL/TestSubscription.cs               |   13 +-
 tests/GraphQL.Server.Test/Program.cs          |   20 +-
 tests/GraphQL.Server.Test/Startup.cs          |   71 +-
 tests/IntegrationTestServer/Program.cs        |   23 +-
 tests/IntegrationTestServer/Startup.cs        |  103 +-
 88 files changed, 4663 insertions(+), 4005 deletions(-)

diff --git a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
index a9ef5a9b..59ab316f 100644
--- a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
+++ b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
@@ -2,20 +2,24 @@
 
 namespace GraphQL.Client.Http.Examples
 {
-	public class PersonAndFilmsResponse {
-		public PersonContent Person { get; set; }
+    public class PersonAndFilmsResponse
+    {
+        public PersonContent Person { get; set; }
 
-		public class PersonContent {
-			public string Name { get; set; }
-			public FilmConnectionContent FilmConnection { get; set; }
+        public class PersonContent
+        {
+            public string Name { get; set; }
+            public FilmConnectionContent FilmConnection { get; set; }
 
-			public class FilmConnectionContent {
-				public List<FilmContent> Films { get; set; }
+            public class FilmConnectionContent
+            {
+                public List<FilmContent> Films { get; set; }
 
-				public class FilmContent {
-					public string Title { get; set; }
-				}
-			}
-		}
-	}
+                public class FilmContent
+                {
+                    public string Title { get; set; }
+                }
+            }
+        }
+    }
 }
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index a7cc00fe..2a9f4a2f 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -4,16 +4,20 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Serializer.Newtonsoft;
 
-namespace GraphQL.Client.Http.Examples {
+namespace GraphQL.Client.Http.Examples
+{
 
-	public class Program {
+    public class Program
+    {
 
-		public static async Task Main(string[] args) {
+        public static async Task Main(string[] args)
+        {
 
-			using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
+            using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
 
-			var personAndFilmsRequest = new GraphQLRequest {
-				Query = @"
+            var personAndFilmsRequest = new GraphQLRequest
+            {
+                Query = @"
 			    query PersonAndFilms($id: ID) {
 			        person(id: $id) {
 			            name
@@ -24,25 +28,26 @@ query PersonAndFilms($id: ID) {
 			            }
 			        }
 			    }",
-				OperationName = "PersonAndFilms",
-				Variables = new {
-					id = "cGVvcGxlOjE="
-				}
-			};
-
-			var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
-			Console.WriteLine("raw response:");
-			Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
-
-			Console.WriteLine();
-			Console.WriteLine($"Name: {graphQLResponse.Data.Person.Name}" );
-			var films = string.Join(", ", graphQLResponse.Data.Person.FilmConnection.Films.Select(f => f.Title));
-			Console.WriteLine($"Films: {films}");
-
-			Console.WriteLine();
-			Console.WriteLine("Press any key to quit...");
-			Console.ReadKey();
-		}
-
-	}
+                OperationName = "PersonAndFilms",
+                Variables = new
+                {
+                    id = "cGVvcGxlOjE="
+                }
+            };
+
+            var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
+            Console.WriteLine("raw response:");
+            Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
+
+            Console.WriteLine();
+            Console.WriteLine($"Name: {graphQLResponse.Data.Person.Name}");
+            var films = string.Join(", ", graphQLResponse.Data.Person.FilmConnection.Films.Select(f => f.Title));
+            Console.WriteLine($"Films: {films}");
+
+            Console.WriteLine();
+            Console.WriteLine("Press any key to quit...");
+            Console.ReadKey();
+        }
+
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
index 6bf17748..6dd7f019 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
@@ -1,87 +1,89 @@
-namespace GraphQL.Client.Abstractions.Websocket {
-	public static class GraphQLWebSocketMessageType {
+namespace GraphQL.Client.Abstractions.Websocket
+{
+    public static class GraphQLWebSocketMessageType
+    {
 
-		/// <summary>
-		///     Client sends this message after plain websocket connection to start the communication with the server
-		///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-		///     to this message.
-		///     payload: Object : optional parameters that the client specifies in connectionParams
-		/// </summary>
-		public const string GQL_CONNECTION_INIT = "connection_init";
+        /// <summary>
+        ///     Client sends this message after plain websocket connection to start the communication with the server
+        ///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+        ///     to this message.
+        ///     payload: Object : optional parameters that the client specifies in connectionParams
+        /// </summary>
+        public const string GQL_CONNECTION_INIT = "connection_init";
 
-		/// <summary>
-		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-		///     the connection.
-		/// </summary>
-		public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+        /// <summary>
+        ///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+        ///     the connection.
+        /// </summary>
+        public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
 
-		/// <summary>
-		///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-		///     the connection.
-		///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-		///     client, just ignore the message).
-		///     payload: Object: the server side error
-		/// </summary>
-		public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+        /// <summary>
+        ///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+        ///     the connection.
+        ///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+        ///     client, just ignore the message).
+        ///     payload: Object: the server side error
+        /// </summary>
+        public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
 
-		/// <summary>
-		///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-		///     client connection alive.
-		///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-		///     server.
-		///     <remarks>
-		///         NOTE: This one here don't follow the standard due to connection optimization
-		///     </remarks>
-		/// </summary>
-		public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+        /// <summary>
+        ///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+        ///     client connection alive.
+        ///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+        ///     server.
+        ///     <remarks>
+        ///         NOTE: This one here don't follow the standard due to connection optimization
+        ///     </remarks>
+        /// </summary>
+        public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
 
-		/// <summary>
-		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-		///     id: string : operation id
-		/// </summary>
-		public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+        /// <summary>
+        ///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+        ///     id: string : operation id
+        /// </summary>
+        public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
 
-		/// <summary>
-		///     Client sends this message to execute GraphQL operation
-		///     id: string : The id of the GraphQL operation to start
-		///     payload: Object:
-		///     query: string : GraphQL operation as string or parsed GraphQL document node
-		///     variables?: Object : Object with GraphQL variables
-		///     operationName?: string : GraphQL operation name
-		/// </summary>
-		public const string GQL_START = "start";
+        /// <summary>
+        ///     Client sends this message to execute GraphQL operation
+        ///     id: string : The id of the GraphQL operation to start
+        ///     payload: Object:
+        ///     query: string : GraphQL operation as string or parsed GraphQL document node
+        ///     variables?: Object : Object with GraphQL variables
+        ///     operationName?: string : GraphQL operation name
+        /// </summary>
+        public const string GQL_START = "start";
 
-		/// <summary>
-		///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-		///     is a response for GQL_START message.
-		///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-		///     id: string : ID of the operation that was successfully set up
-		///     payload: Object :
-		///     data: any: Execution result
-		///     errors?: Error[] : Array of resolvers errors
-		/// </summary>
-		public const string GQL_DATA = "data"; // Server -> Client
+        /// <summary>
+        ///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+        ///     is a response for GQL_START message.
+        ///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+        ///     id: string : ID of the operation that was successfully set up
+        ///     payload: Object :
+        ///     data: any: Execution result
+        ///     errors?: Error[] : Array of resolvers errors
+        /// </summary>
+        public const string GQL_DATA = "data"; // Server -> Client
 
-		/// <summary>
-		///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-		///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-		///     payload: Error : payload with the error attributed to the operation failing on the server
-		///     id: string : operation ID of the operation that failed on the server
-		/// </summary>
-		public const string GQL_ERROR = "error"; // Server -> Client
+        /// <summary>
+        ///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+        ///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+        ///     payload: Error : payload with the error attributed to the operation failing on the server
+        ///     id: string : operation ID of the operation that failed on the server
+        /// </summary>
+        public const string GQL_ERROR = "error"; // Server -> Client
 
-		/// <summary>
-		///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-		///     specific operation.
-		///     id: string : operation ID of the operation that completed
-		/// </summary>
-		public const string GQL_COMPLETE = "complete"; // Server -> Client
+        /// <summary>
+        ///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+        ///     specific operation.
+        ///     id: string : operation ID of the operation that completed
+        /// </summary>
+        public const string GQL_COMPLETE = "complete"; // Server -> Client
 
-		/// <summary>
-		///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-		///     id: string : operation id
-		/// </summary>
-		public const string GQL_STOP = "stop"; // Client -> Server
+        /// <summary>
+        ///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+        ///     id: string : operation id
+        /// </summary>
+        public const string GQL_STOP = "stop"; // Client -> Server
 
-	}
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index a44e57d6..1a2a6fb6 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -3,102 +3,114 @@
 using System.Runtime.Serialization;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client.Abstractions.Websocket {
-
-	/// <summary>
-	/// A Subscription Request
-	/// </summary>
-	public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<GraphQLWebSocketRequest> {
-		public const string IdKey = "id";
-		public const string TypeKey = "type";
-		public const string PayloadKey = "payload";
-
-		/// <summary>
-		/// The Identifier of the Response
-		/// </summary>
-		public string Id {
-			get => ContainsKey(IdKey) ? (string)this[IdKey] : null;
-			set => this[IdKey] = value;
-		}
-
-		/// <summary>
-		/// The Type of the Request
-		/// </summary>
-		public string Type {
-			get => ContainsKey(TypeKey) ? (string)this[TypeKey] : null;
-			set => this[TypeKey] = value;
-		}
-
-		/// <summary>
-		/// The payload of the websocket request
-		/// </summary>
-		public GraphQLRequest Payload {
-			get => ContainsKey(PayloadKey) ? (GraphQLRequest) this[PayloadKey] : null;
-			set => this[PayloadKey] = value;
-		}
-
-		private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
-
-		/// <summary>
-		/// Task used to await the actual send operation and to convey potential exceptions
-		/// </summary>
-		/// <returns></returns>
-		public Task SendTask() => _tcs.Task;
-
-		/// <summary>
-		/// gets called when the send operation for this request has completed sucessfully
-		/// </summary>
-		public void SendCompleted() => _tcs.SetResult(true);
-
-		/// <summary>
-		/// gets called when an exception occurs during the send operation
-		/// </summary>
-		/// <param name="e"></param>
-		public void SendFailed(Exception e) => _tcs.SetException(e);
-
-		/// <summary>
-		/// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
-		/// </summary>
-		public void SendCanceled() => _tcs.SetCanceled();
-
-		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
-
-		/// <inheritdoc />
-		public bool Equals(GraphQLWebSocketRequest other) {
-			if (other == null) {
-				return false;
-			}
-			if (ReferenceEquals(this, other)) {
-				return true;
-			}
-			if (!Equals(this.Id, other.Id)) {
-				return false;
-			}
-			if (!Equals(this.Type, other.Type)) {
-				return false;
-			}
-			if (!Equals(this.Payload, other.Payload)) {
-				return false;
-			}
-			return true;
-		}
-
-		/// <inheritdoc />
-		public override int GetHashCode() {
-			var hashCode = 9958074;
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
-			hashCode = hashCode * -1521134295 + EqualityComparer<object>.Default.GetHashCode(this.Payload);
-			return hashCode;
-		}
-
-		/// <inheritdoc />
-		public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
-
-		/// <inheritdoc />
-		public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
-
-	}
+namespace GraphQL.Client.Abstractions.Websocket
+{
+
+    /// <summary>
+    /// A Subscription Request
+    /// </summary>
+    public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<GraphQLWebSocketRequest>
+    {
+        public const string IdKey = "id";
+        public const string TypeKey = "type";
+        public const string PayloadKey = "payload";
+
+        /// <summary>
+        /// The Identifier of the Response
+        /// </summary>
+        public string Id
+        {
+            get => ContainsKey(IdKey) ? (string)this[IdKey] : null;
+            set => this[IdKey] = value;
+        }
+
+        /// <summary>
+        /// The Type of the Request
+        /// </summary>
+        public string Type
+        {
+            get => ContainsKey(TypeKey) ? (string)this[TypeKey] : null;
+            set => this[TypeKey] = value;
+        }
+
+        /// <summary>
+        /// The payload of the websocket request
+        /// </summary>
+        public GraphQLRequest Payload
+        {
+            get => ContainsKey(PayloadKey) ? (GraphQLRequest)this[PayloadKey] : null;
+            set => this[PayloadKey] = value;
+        }
+
+        private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
+
+        /// <summary>
+        /// Task used to await the actual send operation and to convey potential exceptions
+        /// </summary>
+        /// <returns></returns>
+        public Task SendTask() => _tcs.Task;
+
+        /// <summary>
+        /// gets called when the send operation for this request has completed sucessfully
+        /// </summary>
+        public void SendCompleted() => _tcs.SetResult(true);
+
+        /// <summary>
+        /// gets called when an exception occurs during the send operation
+        /// </summary>
+        /// <param name="e"></param>
+        public void SendFailed(Exception e) => _tcs.SetException(e);
+
+        /// <summary>
+        /// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
+        /// </summary>
+        public void SendCanceled() => _tcs.SetCanceled();
+
+        /// <inheritdoc />
+        public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
+
+        /// <inheritdoc />
+        public bool Equals(GraphQLWebSocketRequest other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+            if (!Equals(this.Id, other.Id))
+            {
+                return false;
+            }
+            if (!Equals(this.Type, other.Type))
+            {
+                return false;
+            }
+            if (!Equals(this.Payload, other.Payload))
+            {
+                return false;
+            }
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            var hashCode = 9958074;
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
+            hashCode = hashCode * -1521134295 + EqualityComparer<object>.Default.GetHashCode(this.Payload);
+            return hashCode;
+        }
+
+        /// <inheritdoc />
+        public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
+
+        /// <inheritdoc />
+        public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
+
+    }
 
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
index c0fd7bd8..1ab40d70 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
@@ -1,85 +1,103 @@
 using System;
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Abstractions.Websocket {
-
-	/// <summary>
-	/// A Subscription Response
-	/// </summary>
-	public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse> {
-
-		/// <summary>
-		/// The Identifier of the Response
-		/// </summary>
-		public string Id { get; set; }
-
-		/// <summary>
-		/// The Type of the Response
-		/// </summary>
-		public string Type { get; set; }
-
-		/// <inheritdoc />
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
-
-		/// <inheritdoc />
-		public bool Equals(GraphQLWebSocketResponse other) {
-			if (other == null) {
-				return false;
-			}
-
-			if (ReferenceEquals(this, other)) {
-				return true;
-			}
-
-			if (!Equals(this.Id, other.Id)) {
-				return false;
-			}
-
-			if (!Equals(this.Type, other.Type)) {
-				return false;
-			}
-
-			return true;
-		}
-
-		/// <inheritdoc />
-		public override int GetHashCode() {
-			var hashCode = 9958074;
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
-			hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
-			return hashCode;
-		}
-
-		/// <inheritdoc />
-		public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
-			EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
-
-		/// <inheritdoc />
-		public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
-			!(response1 == response2);
-
-	}
-
-	public class GraphQLWebSocketResponse<TPayload> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TPayload>> {
-		public TPayload Payload { get; set; }
-
-		public bool Equals(GraphQLWebSocketResponse<TPayload>? other) {
-			if (ReferenceEquals(null, other)) return false;
-			if (ReferenceEquals(this, other)) return true;
-			return base.Equals(other) && Payload.Equals(other.Payload);
-		}
-
-		public override bool Equals(object? obj) {
-			if (ReferenceEquals(null, obj)) return false;
-			if (ReferenceEquals(this, obj)) return true;
-			if (obj.GetType() != this.GetType()) return false;
-			return Equals((GraphQLWebSocketResponse<TPayload>)obj);
-		}
-
-		public override int GetHashCode() {
-			unchecked {
-				return (base.GetHashCode() * 397) ^ Payload.GetHashCode();
-			}
-		}
-	}
+namespace GraphQL.Client.Abstractions.Websocket
+{
+
+    /// <summary>
+    /// A Subscription Response
+    /// </summary>
+    public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse>
+    {
+
+        /// <summary>
+        /// The Identifier of the Response
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// The Type of the Response
+        /// </summary>
+        public string Type { get; set; }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
+
+        /// <inheritdoc />
+        public bool Equals(GraphQLWebSocketResponse other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            if (!Equals(this.Id, other.Id))
+            {
+                return false;
+            }
+
+            if (!Equals(this.Type, other.Type))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+        {
+            var hashCode = 9958074;
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
+            return hashCode;
+        }
+
+        /// <inheritdoc />
+        public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
+            EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
+
+        /// <inheritdoc />
+        public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
+            !(response1 == response2);
+
+    }
+
+    public class GraphQLWebSocketResponse<TPayload> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TPayload>>
+    {
+        public TPayload Payload { get; set; }
+
+        public bool Equals(GraphQLWebSocketResponse<TPayload>? other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+            if (ReferenceEquals(this, other))
+                return true;
+            return base.Equals(other) && Payload.Equals(other.Payload);
+        }
+
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj))
+                return false;
+            if (ReferenceEquals(this, obj))
+                return true;
+            if (obj.GetType() != this.GetType())
+                return false;
+            return Equals((GraphQLWebSocketResponse<TPayload>)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (base.GetHashCode() * 397) ^ Payload.GetHashCode();
+            }
+        }
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
index 3ab5a0e2..148436cd 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
@@ -1,7 +1,9 @@
-namespace GraphQL.Client.Abstractions.Websocket {
-	public enum GraphQLWebsocketConnectionState {
-		Disconnected,
-		Connecting,
-		Connected
-	}
+namespace GraphQL.Client.Abstractions.Websocket
+{
+    public enum GraphQLWebsocketConnectionState
+    {
+        Disconnected,
+        Connecting,
+        Connected
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index 376f45b6..23536db5 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -3,15 +3,16 @@
 
 namespace GraphQL.Client.Abstractions.Websocket
 {
-	/// <summary>
-	/// The json serializer interface for the graphql-dotnet http client.
-	/// Implementations should provide a parameterless constructor for convenient usage
-	/// </summary>
-    public interface IGraphQLWebsocketJsonSerializer: IGraphQLJsonSerializer {
-	    byte[] SerializeToBytes(GraphQLWebSocketRequest request);
+    /// <summary>
+    /// The json serializer interface for the graphql-dotnet http client.
+    /// Implementations should provide a parameterless constructor for convenient usage
+    /// </summary>
+    public interface IGraphQLWebsocketJsonSerializer : IGraphQLJsonSerializer
+    {
+        byte[] SerializeToBytes(GraphQLWebSocketRequest request);
 
-	    Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
-	    GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
+        Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
+        GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
 
-	}
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs b/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
index 2a27677e..e7ca0ab8 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
@@ -1,9 +1,11 @@
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Abstractions.Websocket {
-	public class WebsocketMessageWrapper : GraphQLWebSocketResponse {
+namespace GraphQL.Client.Abstractions.Websocket
+{
+    public class WebsocketMessageWrapper : GraphQLWebSocketResponse
+    {
 
-		[IgnoreDataMember]
-		public byte[] MessageBytes { get; set; }
-	}
+        [IgnoreDataMember]
+        public byte[] MessageBytes { get; set; }
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index 5bd30c9d..44abd469 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -2,33 +2,37 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client.Abstractions {
-	public static class GraphQLClientExtensions {
-		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
-			string query, object? variables = null,
-			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
-			return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
-		}
-		public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
-			string query, object? variables = null,
-			string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default) {
-			return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
-		}
+namespace GraphQL.Client.Abstractions
+{
+    public static class GraphQLClientExtensions
+    {
+        public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
+            string query, object? variables = null,
+            string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
+        {
+            return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
+        }
+        public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
+            string query, object? variables = null,
+            string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
+        {
+            return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
+        }
 
-		public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
-			GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-			=> client.SendQueryAsync<TResponse>(request, cancellationToken);
+        public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
+            GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+            => client.SendQueryAsync<TResponse>(request, cancellationToken);
 
-		public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
-			GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-			=> client.SendMutationAsync<TResponse>(request, cancellationToken);
+        public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
+            GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+            => client.SendMutationAsync<TResponse>(request, cancellationToken);
 
-		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-			this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
-			=> client.CreateSubscriptionStream<TResponse>(request);
+        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
+            => client.CreateSubscriptionStream<TResponse>(request);
 
-		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-			this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<Exception> exceptionHandler)
-			=> client.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
-	}
+        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<Exception> exceptionHandler)
+            => client.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index 960f687f..d56b847d 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -2,32 +2,37 @@
 using System.Diagnostics;
 using System.Linq;
 
-namespace GraphQL.Client.Abstractions {
-	public static class GraphQLJsonSerializerExtensions {
-		public static TSerializerInterface EnsureAssigned<TSerializerInterface>(this TSerializerInterface jsonSerializer) where TSerializerInterface: IGraphQLJsonSerializer {
-			// if no serializer was assigned
-			if (jsonSerializer == null) {
-				// try to find one in the assembly and assign that
-				var type = typeof(TSerializerInterface);
-				var serializerType = AppDomain.CurrentDomain
-					.GetAssemblies()
-					.SelectMany(s => s.GetTypes())
-					.FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
-				if (serializerType == null)
-					throw new InvalidOperationException($"no implementation of \"{type}\" found");
+namespace GraphQL.Client.Abstractions
+{
+    public static class GraphQLJsonSerializerExtensions
+    {
+        public static TSerializerInterface EnsureAssigned<TSerializerInterface>(this TSerializerInterface jsonSerializer) where TSerializerInterface : IGraphQLJsonSerializer
+        {
+            // if no serializer was assigned
+            if (jsonSerializer == null)
+            {
+                // try to find one in the assembly and assign that
+                var type = typeof(TSerializerInterface);
+                var serializerType = AppDomain.CurrentDomain
+                    .GetAssemblies()
+                    .SelectMany(s => s.GetTypes())
+                    .FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
+                if (serializerType == null)
+                    throw new InvalidOperationException($"no implementation of \"{type}\" found");
 
-				jsonSerializer = (TSerializerInterface)Activator.CreateInstance(serializerType);
-			}
+                jsonSerializer = (TSerializerInterface)Activator.CreateInstance(serializerType);
+            }
 
-			return jsonSerializer;
-		}
+            return jsonSerializer;
+        }
 
-		public static TOptions New<TOptions>(this Action<TOptions> configure) =>
-			configure.AndReturn(Activator.CreateInstance<TOptions>());
+        public static TOptions New<TOptions>(this Action<TOptions> configure) =>
+            configure.AndReturn(Activator.CreateInstance<TOptions>());
 
-		public static TOptions AndReturn<TOptions>(this Action<TOptions> configure, TOptions options) {
-			configure(options);
-			return options;
-		}
-	}
+        public static TOptions AndReturn<TOptions>(this Action<TOptions> configure, TOptions options)
+        {
+            configure(options);
+            return options;
+        }
+    }
 }
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
index 6889a179..df0557af 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
@@ -3,34 +3,36 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client.Abstractions {
+namespace GraphQL.Client.Abstractions
+{
 
-	public interface IGraphQLClient : IDisposable {
+    public interface IGraphQLClient : IDisposable
+    {
 
-		Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
+        Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
-		Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
+        Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// The stream must be recreated completely after an error has occured within its logic (i.e. a <see cref="WebSocketException"/>)
-		/// </summary>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request);
-		
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
-		/// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		/// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
-		/// </summary>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler);
-	}
+        /// <summary>
+        /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+        /// All subscriptions made to this stream share the same hot observable.<br/>
+        /// The stream must be recreated completely after an error has occured within its logic (i.e. a <see cref="WebSocketException"/>)
+        /// </summary>
+        /// <param name="request">the GraphQL request for this subscription</param>
+        /// <returns>an observable stream for the specified subscription</returns>
+        IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request);
+
+        /// <summary>
+        /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+        /// All subscriptions made to this stream share the same hot observable.<br/>
+        /// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+        /// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+        /// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+        /// </summary>
+        /// <param name="request">the GraphQL request for this subscription</param>
+        /// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+        /// <returns>an observable stream for the specified subscription</returns>
+        IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler);
+    }
 
 }
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
index d29378ca..5c119e4a 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
@@ -2,13 +2,15 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client.Abstractions {
-	public interface IGraphQLJsonSerializer {
-		string SerializeToString(GraphQLRequest request);
+namespace GraphQL.Client.Abstractions
+{
+    public interface IGraphQLJsonSerializer
+    {
+        string SerializeToString(GraphQLRequest request);
 
-		Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream,
-			CancellationToken cancellationToken);
-	}
+        Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream,
+            CancellationToken cancellationToken);
+    }
 
 
 }
diff --git a/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs b/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
index a8ce44d8..32133976 100644
--- a/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
+++ b/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
@@ -1,5 +1,7 @@
-namespace GraphQL.Client.LocalExecution {
-	public class ExecutionResultExtensions {
-		
-	}
+namespace GraphQL.Client.LocalExecution
+{
+    public class ExecutionResultExtensions
+    {
+
+    }
 }
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs b/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
index a9919454..89bbcfc0 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
@@ -5,27 +5,34 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
-namespace GraphQL.Client.LocalExecution {
-	public class GraphQLEnumConverter : StringEnumConverter {
-		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) {
-			if (value == null) {
-				writer.WriteNull();
-			}
-			else {
-				var enumString = ((Enum)value).ToString("G");
-				var memberName = value.GetType()
-					.GetMember(enumString, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
-					.FirstOrDefault()?.Name;
-				if (string.IsNullOrEmpty(memberName)) {
-					if (!AllowIntegerValues)
-						throw new JsonSerializationException($"Integer value {value} is not allowed.");
-					writer.WriteValue(value);
-				}
-				else {
-					writer.WriteValue(StringUtils.ToConstantCase(memberName));
-				}
-			}
-		}
-	}
+namespace GraphQL.Client.LocalExecution
+{
+    public class GraphQLEnumConverter : StringEnumConverter
+    {
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            if (value == null)
+            {
+                writer.WriteNull();
+            }
+            else
+            {
+                var enumString = ((Enum)value).ToString("G");
+                var memberName = value.GetType()
+                    .GetMember(enumString, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
+                    .FirstOrDefault()?.Name;
+                if (string.IsNullOrEmpty(memberName))
+                {
+                    if (!AllowIntegerValues)
+                        throw new JsonSerializationException($"Integer value {value} is not allowed.");
+                    writer.WriteValue(value);
+                }
+                else
+                {
+                    writer.WriteValue(StringUtils.ToConstantCase(memberName));
+                }
+            }
+        }
+    }
 
 }
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 6624020c..c9d00c9a 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -16,102 +16,114 @@
 
 namespace GraphQL.Client.LocalExecution
 {
-	public static class GraphQLLocalExecutionClient {
-		public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema) where TSchema : ISchema
-			=> new GraphQLLocalExecutionClient<TSchema>(schema);
-
-		public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer serializer) where TSchema : ISchema
-			=> new GraphQLLocalExecutionClient<TSchema>(schema, serializer);
-	}
-
-
-	public class GraphQLLocalExecutionClient<TSchema>: IGraphQLClient where TSchema: ISchema {
-
-	    private static readonly JsonSerializerSettings VariablesSerializerSettings = new JsonSerializerSettings {
-		    Formatting = Formatting.Indented,
-		    DateTimeZoneHandling = DateTimeZoneHandling.Local,
-		    ContractResolver = new CamelCasePropertyNamesContractResolver(),
-		    Converters = new List<JsonConverter>
-		    {
-			    new GraphQLEnumConverter()
-		    }
-	    };
-
-		public TSchema Schema { get; }
-		public IGraphQLJsonSerializer Serializer { get; }
-
-
-		private readonly DocumentExecuter documentExecuter;
-
-		public GraphQLLocalExecutionClient(TSchema schema) {
-			Serializer.EnsureAssigned();
-			Schema = schema;
-			if (!Schema.Initialized) Schema.Initialize();
-			documentExecuter = new DocumentExecuter();
-		}
-
-		public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer) : this(schema) {
-			Serializer = serializer;
-		}
-
-		public void Dispose() { }
-
-	    public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-		    => ExecuteQueryAsync<TResponse>(request, cancellationToken);
-
-	    public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-		    => ExecuteQueryAsync<TResponse>(request, cancellationToken);
-
-		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) {
-			return Observable.Defer(() => ExecuteSubscriptionAsync<TResponse>(request).ToObservable())
-				.Concat()
-				.Publish()
-				.RefCount();
-		}
-
-		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request,
-			Action<Exception> exceptionHandler)
-			=> CreateSubscriptionStream<TResponse>(request);
-
-	    #region Private Methods
-
-	    private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken) {
-		    var executionResult = await ExecuteAsync(request, cancellationToken);
-		    return await ExecutionResultToGraphQLResponse<TResponse>(executionResult, cancellationToken);
-	    }
-	    private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-		    var result = await ExecuteAsync(request, cancellationToken);
-		    return ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault()?
-			    .SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
-	    }
-
-	    private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
-		    var serializedRequest = Serializer.SerializeToString(request);
-
-		    var deserializedRequest = JsonConvert.DeserializeObject<GraphQLRequest>(serializedRequest);
-		    var inputs = deserializedRequest.Variables != null
-			    ? (JObject.FromObject(request.Variables, JsonSerializer.Create(VariablesSerializerSettings)) as JObject)
-			    .ToInputs()
-			    : null;
-
-		    var result = await documentExecuter.ExecuteAsync(options => {
-			    options.Schema = Schema;
-			    options.OperationName = request.OperationName;
-			    options.Query = request.Query;
-			    options.Inputs = inputs;
-			    options.CancellationToken = cancellationToken;
-		    });
-
-		    return result;
-	    }
-
-	    private Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponse<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default) {
-		    // serialize result into utf8 byte stream
-		    var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(executionResult, VariablesSerializerSettings)));
-		    // deserialize using the provided serializer
-		    return Serializer.DeserializeFromUtf8StreamAsync<TResponse>(resultStream, cancellationToken);
-	    }
-
-	    #endregion
-	}
+    public static class GraphQLLocalExecutionClient
+    {
+        public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema) where TSchema : ISchema
+            => new GraphQLLocalExecutionClient<TSchema>(schema);
+
+        public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer serializer) where TSchema : ISchema
+            => new GraphQLLocalExecutionClient<TSchema>(schema, serializer);
+    }
+
+
+    public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
+    {
+
+        private static readonly JsonSerializerSettings VariablesSerializerSettings = new JsonSerializerSettings
+        {
+            Formatting = Formatting.Indented,
+            DateTimeZoneHandling = DateTimeZoneHandling.Local,
+            ContractResolver = new CamelCasePropertyNamesContractResolver(),
+            Converters = new List<JsonConverter>
+            {
+                new GraphQLEnumConverter()
+            }
+        };
+
+        public TSchema Schema { get; }
+        public IGraphQLJsonSerializer Serializer { get; }
+
+
+        private readonly DocumentExecuter documentExecuter;
+
+        public GraphQLLocalExecutionClient(TSchema schema)
+        {
+            Serializer.EnsureAssigned();
+            Schema = schema;
+            if (!Schema.Initialized)
+                Schema.Initialize();
+            documentExecuter = new DocumentExecuter();
+        }
+
+        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer) : this(schema)
+        {
+            Serializer = serializer;
+        }
+
+        public void Dispose() { }
+
+        public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+            => ExecuteQueryAsync<TResponse>(request, cancellationToken);
+
+        public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+            => ExecuteQueryAsync<TResponse>(request, cancellationToken);
+
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request)
+        {
+            return Observable.Defer(() => ExecuteSubscriptionAsync<TResponse>(request).ToObservable())
+                .Concat()
+                .Publish()
+                .RefCount();
+        }
+
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request,
+            Action<Exception> exceptionHandler)
+            => CreateSubscriptionStream<TResponse>(request);
+
+        #region Private Methods
+
+        private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken)
+        {
+            var executionResult = await ExecuteAsync(request, cancellationToken);
+            return await ExecutionResultToGraphQLResponse<TResponse>(executionResult, cancellationToken);
+        }
+        private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+        {
+            var result = await ExecuteAsync(request, cancellationToken);
+            return ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault()?
+                .SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
+        }
+
+        private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+        {
+            var serializedRequest = Serializer.SerializeToString(request);
+
+            var deserializedRequest = JsonConvert.DeserializeObject<GraphQLRequest>(serializedRequest);
+            var inputs = deserializedRequest.Variables != null
+                ? (JObject.FromObject(request.Variables, JsonSerializer.Create(VariablesSerializerSettings)) as JObject)
+                .ToInputs()
+                : null;
+
+            var result = await documentExecuter.ExecuteAsync(options =>
+            {
+                options.Schema = Schema;
+                options.OperationName = request.OperationName;
+                options.Query = request.Query;
+                options.Inputs = inputs;
+                options.CancellationToken = cancellationToken;
+            });
+
+            return result;
+        }
+
+        private Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponse<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
+        {
+            // serialize result into utf8 byte stream
+            var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(executionResult, VariablesSerializerSettings)));
+            // deserialize using the provided serializer
+            return Serializer.DeserializeFromUtf8StreamAsync<TResponse>(resultStream, cancellationToken);
+        }
+
+        #endregion
+    }
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
index 4c603f0c..ccca9970 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
@@ -6,65 +6,79 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace GraphQL.Client.Serializer.Newtonsoft {
-	public class GraphQLExtensionsConverter: JsonConverter<GraphQLExtensionsType> {
-		public override void WriteJson(JsonWriter writer, GraphQLExtensionsType value, JsonSerializer serializer) {
-			throw new NotImplementedException(
-				"This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
-		}
+namespace GraphQL.Client.Serializer.Newtonsoft
+{
+    public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType>
+    {
+        public override void WriteJson(JsonWriter writer, GraphQLExtensionsType value, JsonSerializer serializer)
+        {
+            throw new NotImplementedException(
+                "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+        }
 
-		public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectType, GraphQLExtensionsType existingValue,
-			bool hasExistingValue, JsonSerializer serializer) {
-			var rootToken = JToken.ReadFrom(reader);
-			if (rootToken is JObject) {
-				return ReadDictionary<GraphQLExtensionsType>(rootToken);
-			}
-			else
-				throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
-		}
+        public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectType, GraphQLExtensionsType existingValue,
+            bool hasExistingValue, JsonSerializer serializer)
+        {
+            var rootToken = JToken.ReadFrom(reader);
+            if (rootToken is JObject)
+            {
+                return ReadDictionary<GraphQLExtensionsType>(rootToken);
+            }
+            else
+                throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+        }
 
-		private object ReadToken(JToken? token) {
-			return token.Type switch {
-				JTokenType.Undefined => null,
-				JTokenType.None => null,
-				JTokenType.Null => null,
-				JTokenType.Object => ReadDictionary<Dictionary<string, object>>(token),
-				JTokenType.Array => ReadArray(token),
-				JTokenType.Integer => token.Value<int>(),
-				JTokenType.Float => token.Value<double>(),
-				JTokenType.Raw => token.Value<string>(),
-				JTokenType.String => token.Value<string>(),
-				JTokenType.Uri => token.Value<string>(),
-				JTokenType.Boolean => token.Value<bool>(),
-				JTokenType.Date => token.Value<DateTime>(),
-				JTokenType.Bytes => token.Value<byte[]>(),
-				JTokenType.Guid => token.Value<Guid>(),
-				JTokenType.TimeSpan => token.Value<TimeSpan>(),
-				JTokenType.Constructor => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON constructor"),
-				JTokenType.Property => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON property"),
-				JTokenType.Comment => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON comment"),
-				_ => throw new ArgumentOutOfRangeException(nameof(token.Type))
-			};
-		}
+        private object ReadToken(JToken? token)
+        {
+            return token.Type switch
+            {
+                JTokenType.Undefined => null,
+                JTokenType.None => null,
+                JTokenType.Null => null,
+                JTokenType.Object => ReadDictionary<Dictionary<string, object>>(token),
+                JTokenType.Array => ReadArray(token),
+                JTokenType.Integer => token.Value<int>(),
+                JTokenType.Float => token.Value<double>(),
+                JTokenType.Raw => token.Value<string>(),
+                JTokenType.String => token.Value<string>(),
+                JTokenType.Uri => token.Value<string>(),
+                JTokenType.Boolean => token.Value<bool>(),
+                JTokenType.Date => token.Value<DateTime>(),
+                JTokenType.Bytes => token.Value<byte[]>(),
+                JTokenType.Guid => token.Value<Guid>(),
+                JTokenType.TimeSpan => token.Value<TimeSpan>(),
+                JTokenType.Constructor => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON constructor"),
+                JTokenType.Property => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON property"),
+                JTokenType.Comment => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON comment"),
+                _ => throw new ArgumentOutOfRangeException(nameof(token.Type))
+            };
+        }
 
-		private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionary : Dictionary<string, object> {
-			var result = Activator.CreateInstance<TDictionary>();
-			foreach (var property in ((JObject)element).Properties()) {
-				if (IsUnsupportedJTokenType(property.Value.Type)) continue;
-				result[property.Name] = ReadToken(property.Value);
-			}
-			return result;
-		}
+        private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionary : Dictionary<string, object>
+        {
+            var result = Activator.CreateInstance<TDictionary>();
+            foreach (var property in ((JObject)element).Properties())
+            {
+                if (IsUnsupportedJTokenType(property.Value.Type))
+                    continue;
+                result[property.Name] = ReadToken(property.Value);
+            }
+            return result;
+        }
 
-		private IEnumerable<object> ReadArray(JToken element) {
-			foreach (var item in element.Values()) {
-				if (IsUnsupportedJTokenType(item.Type)) continue;
-				yield return ReadToken(item);
-			}
-		}
+        private IEnumerable<object> ReadArray(JToken element)
+        {
+            foreach (var item in element.Values())
+            {
+                if (IsUnsupportedJTokenType(item.Type))
+                    continue;
+                yield return ReadToken(item);
+            }
+        }
 
-		private bool IsUnsupportedJTokenType(JTokenType type) {
-			return type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
-		}
-	}
+        private bool IsUnsupportedJTokenType(JTokenType type)
+        {
+            return type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
+        }
+    }
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 67679432..ca30e64c 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -10,58 +10,67 @@
 
 namespace GraphQL.Client.Serializer.Newtonsoft
 {
-    public class NewtonsoftJsonSerializer: IGraphQLWebsocketJsonSerializer
+    public class NewtonsoftJsonSerializer : IGraphQLWebsocketJsonSerializer
     {
-		public static JsonSerializerSettings DefaultJsonSerializerSettings => new JsonSerializerSettings {
-			ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
-			MissingMemberHandling = MissingMemberHandling.Ignore
-		};
+        public static JsonSerializerSettings DefaultJsonSerializerSettings => new JsonSerializerSettings
+        {
+            ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
+            MissingMemberHandling = MissingMemberHandling.Ignore
+        };
 
-		public JsonSerializerSettings JsonSerializerSettings { get; }
+        public JsonSerializerSettings JsonSerializerSettings { get; }
 
-	    public NewtonsoftJsonSerializer() : this(DefaultJsonSerializerSettings) { }
+        public NewtonsoftJsonSerializer() : this(DefaultJsonSerializerSettings) { }
 
-		public NewtonsoftJsonSerializer(Action<JsonSerializerSettings> configure) : this(configure.AndReturn(DefaultJsonSerializerSettings)) { }
+        public NewtonsoftJsonSerializer(Action<JsonSerializerSettings> configure) : this(configure.AndReturn(DefaultJsonSerializerSettings)) { }
 
-		public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings) {
-		    JsonSerializerSettings = jsonSerializerSettings;
-		    ConfigureMandatorySerializerOptions();
-		}
+        public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
+        {
+            JsonSerializerSettings = jsonSerializerSettings;
+            ConfigureMandatorySerializerOptions();
+        }
 
-		private void ConfigureMandatorySerializerOptions() {
-			// deserialize extensions to Dictionary<string, object>
-			JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
-		}
+        private void ConfigureMandatorySerializerOptions()
+        {
+            // deserialize extensions to Dictionary<string, object>
+            JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
+        }
 
-		public string SerializeToString(GraphQL.GraphQLRequest request) {
-		    return JsonConvert.SerializeObject(request, JsonSerializerSettings);
-		}
+        public string SerializeToString(GraphQL.GraphQLRequest request)
+        {
+            return JsonConvert.SerializeObject(request, JsonSerializerSettings);
+        }
 
-		public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
-			var json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
-			return Encoding.UTF8.GetBytes(json);
-		}
+        public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request)
+        {
+            var json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
+            return Encoding.UTF8.GetBytes(json);
+        }
 
-		public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
-			return DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
-		}
+        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream)
+        {
+            return DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
+        }
 
-		public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
-			return JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
-				JsonSerializerSettings);
-		}
+        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes)
+        {
+            return JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
+                JsonSerializerSettings);
+        }
 
-		public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
-			return DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
-		}
+        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken)
+        {
+            return DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
+        }
 
 
-		private Task<T> DeserializeFromUtf8Stream<T>(Stream stream) {
-			using StreamReader sr = new StreamReader(stream);
-			using JsonReader reader = new JsonTextReader(sr);
-			JsonSerializer serializer = JsonSerializer.Create(JsonSerializerSettings);
-			return Task.FromResult(serializer.Deserialize<T>(reader));
-		}
+        private Task<T> DeserializeFromUtf8Stream<T>(Stream stream)
+        {
+            using StreamReader sr = new StreamReader(stream);
+            using JsonReader reader = new JsonTextReader(sr);
+            JsonSerializer serializer = JsonSerializer.Create(JsonSerializerSettings);
+            return Task.FromResult(serializer.Deserialize<T>(reader));
+        }
 
-	}
+    }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
index e10c8635..111f9804 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
@@ -5,69 +5,78 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GraphQL.Client.Serializer.SystemTextJson {
-	/// <summary>
-	/// A custom JsonConverter for reading the extension fields of <see cref="GraphQLResponse{T}"/> and <see cref="GraphQLError"/>.
-	/// </summary>
-	/// <remarks>
-	/// Taken and modified from GraphQL.SystemTextJson.ObjectDictionaryConverter (GraphQL.NET)
-	/// </remarks>
-	public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType> {
-		public override GraphQLExtensionsType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
-			using var doc = JsonDocument.ParseValue(ref reader);
+namespace GraphQL.Client.Serializer.SystemTextJson
+{
+    /// <summary>
+    /// A custom JsonConverter for reading the extension fields of <see cref="GraphQLResponse{T}"/> and <see cref="GraphQLError"/>.
+    /// </summary>
+    /// <remarks>
+    /// Taken and modified from GraphQL.SystemTextJson.ObjectDictionaryConverter (GraphQL.NET)
+    /// </remarks>
+    public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType>
+    {
+        public override GraphQLExtensionsType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            using var doc = JsonDocument.ParseValue(ref reader);
 
-			if (doc?.RootElement == null || doc?.RootElement.ValueKind != JsonValueKind.Object) {
-				throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
-			}
+            if (doc?.RootElement == null || doc?.RootElement.ValueKind != JsonValueKind.Object)
+            {
+                throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+            }
 
-			return ReadDictionary<GraphQLExtensionsType>(doc.RootElement);
-		}
+            return ReadDictionary<GraphQLExtensionsType>(doc.RootElement);
+        }
 
-		public override void Write(Utf8JsonWriter writer, GraphQLExtensionsType value, JsonSerializerOptions options)
-			=> throw new NotImplementedException(
-				"This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+        public override void Write(Utf8JsonWriter writer, GraphQLExtensionsType value, JsonSerializerOptions options)
+            => throw new NotImplementedException(
+                "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-		private TDictionary ReadDictionary<TDictionary>(JsonElement element) where TDictionary: Dictionary<string, object> {
-			var result = Activator.CreateInstance<TDictionary>();
-			foreach (var property in element.EnumerateObject()) {
-				result[property.Name] = ReadValue(property.Value);
-			}
-			return result;
-		}
+        private TDictionary ReadDictionary<TDictionary>(JsonElement element) where TDictionary : Dictionary<string, object>
+        {
+            var result = Activator.CreateInstance<TDictionary>();
+            foreach (var property in element.EnumerateObject())
+            {
+                result[property.Name] = ReadValue(property.Value);
+            }
+            return result;
+        }
 
-		private IEnumerable<object> ReadArray(JsonElement value) {
-			foreach (var item in value.EnumerateArray()) {
-				yield return ReadValue(item);
-			}
-		}
+        private IEnumerable<object> ReadArray(JsonElement value)
+        {
+            foreach (var item in value.EnumerateArray())
+            {
+                yield return ReadValue(item);
+            }
+        }
 
-		private object ReadValue(JsonElement value)
-			=> value.ValueKind switch
-			{
-				JsonValueKind.Array => ReadArray(value).ToList(),
-				JsonValueKind.Object => ReadDictionary<Dictionary<string, object>>(value),
-				JsonValueKind.Number => ReadNumber(value),
-				JsonValueKind.True => true,
-				JsonValueKind.False => false,
-				JsonValueKind.String => value.GetString(),
-				JsonValueKind.Null => null,
-				JsonValueKind.Undefined => null,
-				_ => throw new InvalidOperationException($"Unexpected value kind: {value.ValueKind}")
-			};
+        private object ReadValue(JsonElement value)
+            => value.ValueKind switch
+            {
+                JsonValueKind.Array => ReadArray(value).ToList(),
+                JsonValueKind.Object => ReadDictionary<Dictionary<string, object>>(value),
+                JsonValueKind.Number => ReadNumber(value),
+                JsonValueKind.True => true,
+                JsonValueKind.False => false,
+                JsonValueKind.String => value.GetString(),
+                JsonValueKind.Null => null,
+                JsonValueKind.Undefined => null,
+                _ => throw new InvalidOperationException($"Unexpected value kind: {value.ValueKind}")
+            };
 
-		private object ReadNumber(JsonElement value) {
-			if (value.TryGetInt32(out var i))
-				return i;
-			else if (value.TryGetInt64(out var l))
-				return l;
-			else if (BigInteger.TryParse(value.GetRawText(), out var bi))
-				return bi;
-			else if (value.TryGetDouble(out var d))
-				return d;
-			else if (value.TryGetDecimal(out var dd))
-				return dd;
+        private object ReadNumber(JsonElement value)
+        {
+            if (value.TryGetInt32(out var i))
+                return i;
+            else if (value.TryGetInt64(out var l))
+                return l;
+            else if (BigInteger.TryParse(value.GetRawText(), out var bi))
+                return bi;
+            else if (value.TryGetDouble(out var d))
+                return d;
+            else if (value.TryGetDecimal(out var dd))
+                return dd;
 
-			throw new NotImplementedException($"Unexpected Number value. Raw text was: {value.GetRawText()}");
-		}
-	}
+            throw new NotImplementedException($"Unexpected Number value. Raw text was: {value.GetRawText()}");
+        }
+    }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index a4f49f49..c87eb4cd 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -6,161 +6,194 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GraphQL.Client.Serializer.SystemTextJson {
-
-	/// <summary>
-	/// class for converting immutable objects, derived from https://github.com/manne/obviously/blob/master/src/system.text.json/Core/ImmutableConverter.cs
-	/// </summary>
-	public class ImmutableConverter : JsonConverter<object> {
-		public override bool CanConvert(Type typeToConvert) {
-			bool result;
-			var constructors = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
-			if (constructors.Length != 1) {
-				result = false;
-			}
-			else {
-				var constructor = constructors[0];
-				var parameters = constructor.GetParameters();
-				var hasParameters = parameters.Length > 0;
-				if (hasParameters) {
-					var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
-					result = true;
-					foreach (var parameter in parameters) {
-						var hasMatchingProperty = properties.Any(p =>
-							NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous()));
-						if (!hasMatchingProperty) {
-							result = false;
-							break;
-						}
-					}
-				}
-				else {
-					result = false;
-				}
-			}
-
-			return result;
-		}
-
-		public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) {
-			var valueOfProperty = new Dictionary<PropertyInfo, object>();
-			var namedPropertiesMapping = GetNamedProperties(options, GetProperties(typeToConvert));
-			reader.Read();
-			while (true) {
-				if (reader.TokenType != JsonTokenType.PropertyName && reader.TokenType != JsonTokenType.String) {
-					break;
-				}
-
-				var jsonPropName = reader.GetString();
-				var normalizedPropName = ConvertAndNormalizeName(jsonPropName, options);
-				if (!namedPropertiesMapping.TryGetValue(normalizedPropName, out var obProp)) {
-					reader.Read();
-				}
-				else {
-					var value = JsonSerializer.Deserialize(ref reader, obProp.PropertyType, options);
-					reader.Read();
-					valueOfProperty[obProp] = value;
-				}
-			}
-
-			var ctor = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First();
-			var parameters = ctor.GetParameters();
-			var parameterValues = new object[parameters.Length];
-			for (var index = 0; index < parameters.Length; index++) {
-				var parameterInfo = parameters[index];
-				var value = valueOfProperty.First(prop =>
-					NameOfPropertyAndParameter.Matches(prop.Key.Name, parameterInfo.Name, typeToConvert.IsAnonymous())).Value;
-
-				parameterValues[index] = value;
-			}
-
-			var instance = ctor.Invoke(parameterValues);
-			return instance;
-		}
-
-		public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options) {
-			var strippedOptions = new JsonSerializerOptions {
-				AllowTrailingCommas = options.AllowTrailingCommas,
-				DefaultBufferSize = options.DefaultBufferSize,
-				DictionaryKeyPolicy = options.DictionaryKeyPolicy,
-				Encoder = options.Encoder,
-				IgnoreNullValues = options.IgnoreNullValues,
-				IgnoreReadOnlyProperties = options.IgnoreReadOnlyProperties,
-				MaxDepth = options.MaxDepth,
-				PropertyNameCaseInsensitive = options.PropertyNameCaseInsensitive,
-				PropertyNamingPolicy = options.PropertyNamingPolicy,
-				ReadCommentHandling = options.ReadCommentHandling,
-				WriteIndented = options.WriteIndented
-			};
-			foreach (var converter in options.Converters) {
-				if (!(converter is ImmutableConverter))
-					strippedOptions.Converters.Add(converter);
-			}
-			JsonSerializer.Serialize(writer, value, strippedOptions);
-		}
-
-		private static PropertyInfo[] GetProperties(IReflect typeToConvert) {
-			return typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
-		}
-
-		private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(JsonSerializerOptions options, IEnumerable<PropertyInfo> properties) {
-			var result = new Dictionary<string, PropertyInfo>();
-			foreach (var property in properties) {
-				string name;
-				var nameAttribute = property.GetCustomAttribute<JsonPropertyNameAttribute>();
-				if (nameAttribute != null) {
-					name = nameAttribute.Name;
-				}
-				else {
-					name = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
-				}
-
-				var normalizedName = NormalizeName(name, options);
-				result.Add(normalizedName, property);
-			}
-
-			return result;
-		}
-
-		private static string ConvertAndNormalizeName(string name, JsonSerializerOptions options) {
-			var convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;
-			return options.PropertyNameCaseInsensitive ? convertedName.ToLowerInvariant() : convertedName;
-		}
-
-		private static string NormalizeName(string name, JsonSerializerOptions options) {
-			return options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
-		}
-	}
-
-	internal static class NameOfPropertyAndParameter {
-		public static bool Matches(string propertyName, string parameterName, bool anonymousType) {
-			if (propertyName is null && parameterName is null) {
-				return true;
-			}
-
-			if (propertyName is null || parameterName is null) {
-				return false;
-			}
-
-			if (anonymousType) {
-				return propertyName.Equals(parameterName, StringComparison.Ordinal);
-			}
-			else {
-				var xRight = propertyName.AsSpan(1);
-				var yRight = parameterName.AsSpan(1);
-				return char.ToLowerInvariant(propertyName[0]).CompareTo(parameterName[0]) == 0 && xRight.Equals(yRight, StringComparison.Ordinal);
-			}
-		}
-	}
-
-	internal static class TypeExtensions {
-		// copied from https://github.com/dahomey-technologies/Dahomey.Json/blob/master/src/Dahomey.Json/Util/TypeExtensions.cs
-		public static bool IsAnonymous(this Type type) {
-			return type.Namespace == null
-			       && type.IsSealed
-			       && type.BaseType == typeof(object)
-			       && !type.IsPublic
-			       && type.IsDefined(typeof(CompilerGeneratedAttribute), false);
-		}
-	}
+namespace GraphQL.Client.Serializer.SystemTextJson
+{
+
+    /// <summary>
+    /// class for converting immutable objects, derived from https://github.com/manne/obviously/blob/master/src/system.text.json/Core/ImmutableConverter.cs
+    /// </summary>
+    public class ImmutableConverter : JsonConverter<object>
+    {
+        public override bool CanConvert(Type typeToConvert)
+        {
+            bool result;
+            var constructors = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+            if (constructors.Length != 1)
+            {
+                result = false;
+            }
+            else
+            {
+                var constructor = constructors[0];
+                var parameters = constructor.GetParameters();
+                var hasParameters = parameters.Length > 0;
+                if (hasParameters)
+                {
+                    var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                    result = true;
+                    foreach (var parameter in parameters)
+                    {
+                        var hasMatchingProperty = properties.Any(p =>
+                            NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous()));
+                        if (!hasMatchingProperty)
+                        {
+                            result = false;
+                            break;
+                        }
+                    }
+                }
+                else
+                {
+                    result = false;
+                }
+            }
+
+            return result;
+        }
+
+        public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            var valueOfProperty = new Dictionary<PropertyInfo, object>();
+            var namedPropertiesMapping = GetNamedProperties(options, GetProperties(typeToConvert));
+            reader.Read();
+            while (true)
+            {
+                if (reader.TokenType != JsonTokenType.PropertyName && reader.TokenType != JsonTokenType.String)
+                {
+                    break;
+                }
+
+                var jsonPropName = reader.GetString();
+                var normalizedPropName = ConvertAndNormalizeName(jsonPropName, options);
+                if (!namedPropertiesMapping.TryGetValue(normalizedPropName, out var obProp))
+                {
+                    reader.Read();
+                }
+                else
+                {
+                    var value = JsonSerializer.Deserialize(ref reader, obProp.PropertyType, options);
+                    reader.Read();
+                    valueOfProperty[obProp] = value;
+                }
+            }
+
+            var ctor = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First();
+            var parameters = ctor.GetParameters();
+            var parameterValues = new object[parameters.Length];
+            for (var index = 0; index < parameters.Length; index++)
+            {
+                var parameterInfo = parameters[index];
+                var value = valueOfProperty.First(prop =>
+                    NameOfPropertyAndParameter.Matches(prop.Key.Name, parameterInfo.Name, typeToConvert.IsAnonymous())).Value;
+
+                parameterValues[index] = value;
+            }
+
+            var instance = ctor.Invoke(parameterValues);
+            return instance;
+        }
+
+        public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
+        {
+            var strippedOptions = new JsonSerializerOptions
+            {
+                AllowTrailingCommas = options.AllowTrailingCommas,
+                DefaultBufferSize = options.DefaultBufferSize,
+                DictionaryKeyPolicy = options.DictionaryKeyPolicy,
+                Encoder = options.Encoder,
+                IgnoreNullValues = options.IgnoreNullValues,
+                IgnoreReadOnlyProperties = options.IgnoreReadOnlyProperties,
+                MaxDepth = options.MaxDepth,
+                PropertyNameCaseInsensitive = options.PropertyNameCaseInsensitive,
+                PropertyNamingPolicy = options.PropertyNamingPolicy,
+                ReadCommentHandling = options.ReadCommentHandling,
+                WriteIndented = options.WriteIndented
+            };
+            foreach (var converter in options.Converters)
+            {
+                if (!(converter is ImmutableConverter))
+                    strippedOptions.Converters.Add(converter);
+            }
+            JsonSerializer.Serialize(writer, value, strippedOptions);
+        }
+
+        private static PropertyInfo[] GetProperties(IReflect typeToConvert)
+        {
+            return typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+        }
+
+        private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(JsonSerializerOptions options, IEnumerable<PropertyInfo> properties)
+        {
+            var result = new Dictionary<string, PropertyInfo>();
+            foreach (var property in properties)
+            {
+                string name;
+                var nameAttribute = property.GetCustomAttribute<JsonPropertyNameAttribute>();
+                if (nameAttribute != null)
+                {
+                    name = nameAttribute.Name;
+                }
+                else
+                {
+                    name = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
+                }
+
+                var normalizedName = NormalizeName(name, options);
+                result.Add(normalizedName, property);
+            }
+
+            return result;
+        }
+
+        private static string ConvertAndNormalizeName(string name, JsonSerializerOptions options)
+        {
+            var convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;
+            return options.PropertyNameCaseInsensitive ? convertedName.ToLowerInvariant() : convertedName;
+        }
+
+        private static string NormalizeName(string name, JsonSerializerOptions options)
+        {
+            return options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
+        }
+    }
+
+    internal static class NameOfPropertyAndParameter
+    {
+        public static bool Matches(string propertyName, string parameterName, bool anonymousType)
+        {
+            if (propertyName is null && parameterName is null)
+            {
+                return true;
+            }
+
+            if (propertyName is null || parameterName is null)
+            {
+                return false;
+            }
+
+            if (anonymousType)
+            {
+                return propertyName.Equals(parameterName, StringComparison.Ordinal);
+            }
+            else
+            {
+                var xRight = propertyName.AsSpan(1);
+                var yRight = parameterName.AsSpan(1);
+                return char.ToLowerInvariant(propertyName[0]).CompareTo(parameterName[0]) == 0 && xRight.Equals(yRight, StringComparison.Ordinal);
+            }
+        }
+    }
+
+    internal static class TypeExtensions
+    {
+        // copied from https://github.com/dahomey-technologies/Dahomey.Json/blob/master/src/Dahomey.Json/Util/TypeExtensions.cs
+        public static bool IsAnonymous(this Type type)
+        {
+            return type.Namespace == null
+                   && type.IsSealed
+                   && type.BaseType == typeof(object)
+                   && !type.IsPublic
+                   && type.IsDefined(typeof(CompilerGeneratedAttribute), false);
+        }
+    }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
index b4cc2614..e2d914c0 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
@@ -1,11 +1,14 @@
 using System.Text.Json;
 
-namespace GraphQL.Client.Serializer.SystemTextJson {
-	public static class JsonSerializerOptionsExtensions {
-		public static JsonSerializerOptions SetupImmutableConverter(
-			this JsonSerializerOptions options) {
-			options.Converters.Add(new ImmutableConverter());
-			return options;
-		}
-	}
+namespace GraphQL.Client.Serializer.SystemTextJson
+{
+    public static class JsonSerializerOptionsExtensions
+    {
+        public static JsonSerializerOptions SetupImmutableConverter(
+            this JsonSerializerOptions options)
+        {
+            options.Converters.Add(new ImmutableConverter());
+            return options;
+        }
+    }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 0f3b1e2c..de7be686 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -8,50 +8,58 @@
 
 namespace GraphQL.Client.Serializer.SystemTextJson
 {
-    public class SystemTextJsonSerializer: IGraphQLWebsocketJsonSerializer
+    public class SystemTextJsonSerializer : IGraphQLWebsocketJsonSerializer
     {
-	    public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions {
-		    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
-	    }.SetupImmutableConverter();
-		
-		public JsonSerializerOptions Options { get; }
-
-	    public SystemTextJsonSerializer() : this(DefaultJsonSerializerOptions) { }
-
-	    public SystemTextJsonSerializer(Action<JsonSerializerOptions> configure) : this(configure.AndReturn(DefaultJsonSerializerOptions)) { }
-
-		public SystemTextJsonSerializer(JsonSerializerOptions options) {
-		    Options = options;
-		    ConfigureMandatorySerializerOptions();
-		}
-
-		private void ConfigureMandatorySerializerOptions() {
-			// deserialize extensions to Dictionary<string, object>
-			Options.Converters.Insert(0, new GraphQLExtensionsConverter());
-			// allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
-			Options.PropertyNameCaseInsensitive = true;
-		}
-
-	    public string SerializeToString(GraphQL.GraphQLRequest request) {
-		    return JsonSerializer.Serialize(request, Options);
-	    }
-
-	    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) {
-		    return JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options, cancellationToken).AsTask();
-	    }
-
-	    public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request) {
-		    return JsonSerializer.SerializeToUtf8Bytes(request, Options);
-	    }
-
-	    public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) {
-		    return JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
-		}
-
-	    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) {
-		    return JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
-			    Options);
-	    }
+        public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+        }.SetupImmutableConverter();
+
+        public JsonSerializerOptions Options { get; }
+
+        public SystemTextJsonSerializer() : this(DefaultJsonSerializerOptions) { }
+
+        public SystemTextJsonSerializer(Action<JsonSerializerOptions> configure) : this(configure.AndReturn(DefaultJsonSerializerOptions)) { }
+
+        public SystemTextJsonSerializer(JsonSerializerOptions options)
+        {
+            Options = options;
+            ConfigureMandatorySerializerOptions();
+        }
+
+        private void ConfigureMandatorySerializerOptions()
+        {
+            // deserialize extensions to Dictionary<string, object>
+            Options.Converters.Insert(0, new GraphQLExtensionsConverter());
+            // allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
+            Options.PropertyNameCaseInsensitive = true;
+        }
+
+        public string SerializeToString(GraphQL.GraphQLRequest request)
+        {
+            return JsonSerializer.Serialize(request, Options);
+        }
+
+        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken)
+        {
+            return JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options, cancellationToken).AsTask();
+        }
+
+        public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request)
+        {
+            return JsonSerializer.SerializeToUtf8Bytes(request, Options);
+        }
+
+        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream)
+        {
+            return JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
+        }
+
+        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes)
+        {
+            return JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
+                Options);
+        }
 
     }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 5f000dda..2734e3e3 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -11,172 +11,187 @@
 using GraphQL.Client.Http.Websocket;
 using GraphQL.Client.Serializer.Newtonsoft;
 
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http
+{
 
-	public class GraphQLHttpClient : IGraphQLClient {
+    public class GraphQLHttpClient : IGraphQLClient
+    {
 
-		private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
-		private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-		private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
-		private IGraphQLWebsocketJsonSerializer JsonSerializer => Options.JsonSerializer;
+        private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
+        private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
+        private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
+        private IGraphQLWebsocketJsonSerializer JsonSerializer => Options.JsonSerializer;
 
-		/// <summary>
-		/// the instance of <see cref="HttpClient"/> which is used internally
-		/// </summary>
-		public HttpClient HttpClient { get; }
+        /// <summary>
+        /// the instance of <see cref="HttpClient"/> which is used internally
+        /// </summary>
+        public HttpClient HttpClient { get; }
 
-		/// <summary>
-		/// The Options	to be used
-		/// </summary>
-		public GraphQLHttpClientOptions Options { get; }
+        /// <summary>
+        /// The Options	to be used
+        /// </summary>
+        public GraphQLHttpClientOptions Options { get; }
 
-		/// <summary>
-		/// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
-		/// </summary>
-		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
+        /// <summary>
+        /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+        /// </summary>
+        public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
 
-		/// <summary>
-		/// the websocket connection state
-		/// </summary>
-		public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState =>
-			graphQlHttpWebSocket.ConnectionState;
+        /// <summary>
+        /// the websocket connection state
+        /// </summary>
+        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState =>
+            graphQlHttpWebSocket.ConnectionState;
 
-		#region Constructors
+        #region Constructors
 
-		public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint)) { }
+        public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint)) { }
 
-		public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
+        public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
 
-		public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) : this(configure.New()) { }
+        public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) : this(configure.New()) { }
 
-		public GraphQLHttpClient(GraphQLHttpClientOptions options) : this(options, new HttpClient(options.HttpMessageHandler)) { }
+        public GraphQLHttpClient(GraphQLHttpClientOptions options) : this(options, new HttpClient(options.HttpMessageHandler)) { }
 
-		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) : this(options, httpClient, new NewtonsoftJsonSerializer()) { }
+        public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) : this(options, httpClient, new NewtonsoftJsonSerializer()) { }
 
-		public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer) {
-			Options = options ?? throw new ArgumentNullException(nameof(options));
-			Options.JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
-			this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
-			this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
-		}
+        public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer)
+        {
+            Options = options ?? throw new ArgumentNullException(nameof(options));
+            Options.JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
+            this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
+            this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
+        }
 
-		#endregion
+        #endregion
 
-		#region IGraphQLClient
+        #region IGraphQLClient
 
-		/// <inheritdoc />
-		public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			if (Options.UseWebSocketForQueriesAndMutations)
-				return await this.graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
+        /// <inheritdoc />
+        public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+        {
+            if (Options.UseWebSocketForQueriesAndMutations)
+                return await this.graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
 
-			return await this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
-		}
+            return await this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
+        }
+
+        /// <inheritdoc />
+        public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request,
+            CancellationToken cancellationToken = default)
+            => SendQueryAsync<TResponse>(request, cancellationToken);
 
-		/// <inheritdoc />
-		public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request,
-			CancellationToken cancellationToken = default)
-			=> SendQueryAsync<TResponse>(request, cancellationToken);
+        /// <inheritdoc />
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request)
+        {
+            if (disposed)
+                throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+            var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
+
+            if (subscriptionStreams.ContainsKey(key))
+                return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
+
+            var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
+
+            subscriptionStreams.TryAdd(key, observable);
+            return observable;
+        }
+
+        /// <inheritdoc />
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler)
+        {
+            if (disposed)
+                throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+
+            var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
+
+            if (subscriptionStreams.ContainsKey(key))
+                return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
+
+            var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+            subscriptionStreams.TryAdd(key, observable);
+            return observable;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
+        /// </summary>
+        /// <returns></returns>
+        public Task InitializeWebsocketConnection() => graphQlHttpWebSocket.InitializeWebSocket();
+
+        #region Private Methods
+
+        private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+        {
+            var preprocessedRequest = await Options.PreprocessRequest(request, this);
+            using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest);
+            using var httpResponseMessage = await this.HttpClient.SendAsync(httpRequestMessage, cancellationToken);
+            if (!httpResponseMessage.IsSuccessStatusCode)
+            {
+                throw new GraphQLHttpException(httpResponseMessage);
+            }
+
+            var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
+            var response = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
+            return response.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
+        }
 
-		/// <inheritdoc />
-		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) {
-			if (disposed)
-				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
-			var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
-
-			if (subscriptionStreams.ContainsKey(key))
-				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
-
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
-
-			subscriptionStreams.TryAdd(key, observable);
-			return observable;
-		}
-		
-		/// <inheritdoc />
-		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler) {
-			if (disposed)
-				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
-			var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
-
-			if (subscriptionStreams.ContainsKey(key))
-				return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
-
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
-			subscriptionStreams.TryAdd(key, observable);
-			return observable;
-		}
-
-		#endregion
-
-		/// <summary>
-		/// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
-		/// </summary>
-		/// <returns></returns>
-		public Task InitializeWebsocketConnection() => graphQlHttpWebSocket.InitializeWebSocket();
-		
-		#region Private Methods
-
-		private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			var preprocessedRequest = await Options.PreprocessRequest(request, this);
-			using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest);
-			using var httpResponseMessage = await this.HttpClient.SendAsync(httpRequestMessage, cancellationToken);
-			if (!httpResponseMessage.IsSuccessStatusCode) {
-				throw new GraphQLHttpException(httpResponseMessage);
-			}
-
-			var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
-			var response = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
-			return response.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
-		}
-
-		private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request) {
-			var message = new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint) {
-				Content = new StringContent(JsonSerializer.SerializeToString(request), Encoding.UTF8, Options.MediaType)
-			};
-
-			if (request is GraphQLHttpRequest httpRequest)
-				httpRequest.PreprocessHttpRequestMessage(message);
-
-			return message;
-		}
-
-		private Uri GetWebSocketUri() {
-			var webSocketSchema = this.Options.EndPoint.Scheme == "https" ? "wss" : "ws";
-			return new Uri($"{webSocketSchema}://{this.Options.EndPoint.Host}:{this.Options.EndPoint.Port}{this.Options.EndPoint.AbsolutePath}");
-		}
-
-		#endregion
-
-
-		#region IDisposable
-
-		/// <summary>
-		/// Releases unmanaged resources
-		/// </summary>
-		public void Dispose() {
-			lock (disposeLocker) {
-				if (!disposed) {
-					_dispose();
-				}
-			}
-		}
-
-		private bool disposed = false;
-		private readonly object disposeLocker = new object();
-
-		private void _dispose() {
-			disposed = true;
-			Debug.WriteLine($"disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
-			cancellationTokenSource.Cancel();
-			this.HttpClient.Dispose();
-			this.graphQlHttpWebSocket.Dispose();
-			cancellationTokenSource.Dispose();
-		}
-
-		#endregion
-
-	}
+        private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request)
+        {
+            var message = new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint)
+            {
+                Content = new StringContent(JsonSerializer.SerializeToString(request), Encoding.UTF8, Options.MediaType)
+            };
+
+            if (request is GraphQLHttpRequest httpRequest)
+                httpRequest.PreprocessHttpRequestMessage(message);
+
+            return message;
+        }
+
+        private Uri GetWebSocketUri()
+        {
+            var webSocketSchema = this.Options.EndPoint.Scheme == "https" ? "wss" : "ws";
+            return new Uri($"{webSocketSchema}://{this.Options.EndPoint.Host}:{this.Options.EndPoint.Port}{this.Options.EndPoint.AbsolutePath}");
+        }
+
+        #endregion
+
+
+        #region IDisposable
+
+        /// <summary>
+        /// Releases unmanaged resources
+        /// </summary>
+        public void Dispose()
+        {
+            lock (disposeLocker)
+            {
+                if (!disposed)
+                {
+                    _dispose();
+                }
+            }
+        }
+
+        private bool disposed = false;
+        private readonly object disposeLocker = new object();
+
+        private void _dispose()
+        {
+            disposed = true;
+            Debug.WriteLine($"disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
+            cancellationTokenSource.Cancel();
+            this.HttpClient.Dispose();
+            this.graphQlHttpWebSocket.Dispose();
+            cancellationTokenSource.Dispose();
+        }
+
+        #endregion
+
+    }
 
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index 405d041c..99409d12 100644
--- a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -2,31 +2,35 @@
 using System.Net.WebSockets;
 using GraphQL.Client.Abstractions;
 
-namespace GraphQL.Client.Http {
-	public static class GraphQLHttpClientExtensions {
-		/// <summary>
-		/// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-		/// All subscriptions made to this stream share the same hot observable.<br/>
-		/// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
-		/// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-		/// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
-		/// </summary>
-		/// <param name="client">the GraphQL client</param>
-		/// <param name="request">the GraphQL request for this subscription</param>
-		/// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
-		/// <returns>an observable stream for the specified subscription</returns>
-		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(this IGraphQLClient client,
-			GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) {
-			return client.CreateSubscriptionStream<TResponse>(request, e => {
-				if (e is WebSocketException webSocketException)
-					webSocketExceptionHandler(webSocketException);
-				else
-					throw e;
-			});
-		}
+namespace GraphQL.Client.Http
+{
+    public static class GraphQLHttpClientExtensions
+    {
+        /// <summary>
+        /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+        /// All subscriptions made to this stream share the same hot observable.<br/>
+        /// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+        /// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+        /// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+        /// </summary>
+        /// <param name="client">the GraphQL client</param>
+        /// <param name="request">the GraphQL request for this subscription</param>
+        /// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+        /// <returns>an observable stream for the specified subscription</returns>
+        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(this IGraphQLClient client,
+            GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
+        {
+            return client.CreateSubscriptionStream<TResponse>(request, e =>
+            {
+                if (e is WebSocketException webSocketException)
+                    webSocketExceptionHandler(webSocketException);
+                else
+                    throw e;
+            });
+        }
 
-		public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-			this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
-			=> client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
-	}
+        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
+            => client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
+    }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index a52c772c..915ad967 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -4,55 +4,58 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
 
-namespace GraphQL.Client.Http {
-
-	/// <summary>
-	/// The Options that the <see cref="GraphQLHttpClient"/> will use
-	/// </summary>
-	public class GraphQLHttpClientOptions {
-
-		/// <summary>
-		/// The GraphQL EndPoint to be used
-		/// </summary>
-		public Uri EndPoint { get; set; }
-
-		/// <summary>
-		/// the json serializer
-		/// </summary>
-		public IGraphQLWebsocketJsonSerializer JsonSerializer { get; set; }
-
-		/// <summary>
-		/// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
-		/// </summary>
-		public HttpMessageHandler HttpMessageHandler { get; set; } = new HttpClientHandler();
-
-		/// <summary>
-		/// The <see cref="MediaTypeHeaderValue"/> that will be send on POST
-		/// </summary>
-		public string MediaType { get; set; } = "application/json"; // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
-
-		/// <summary>
-		/// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
-		/// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
-		/// </summary>
-		public Func<int, TimeSpan> BackOffStrategy { get; set; } = n => {
-			var rnd = new Random();
-			return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
-		};
-
-		/// <summary>
-		/// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
-		/// </summary>
-		public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
-
-		/// <summary>
-		/// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
-		/// </summary>
-		public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
-
-		/// <summary>
-		/// This callback is called after successfully establishing a websocket connection but before any regular request is made. 
-		/// </summary>
-		public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
-	}
+namespace GraphQL.Client.Http
+{
+
+    /// <summary>
+    /// The Options that the <see cref="GraphQLHttpClient"/> will use
+    /// </summary>
+    public class GraphQLHttpClientOptions
+    {
+
+        /// <summary>
+        /// The GraphQL EndPoint to be used
+        /// </summary>
+        public Uri EndPoint { get; set; }
+
+        /// <summary>
+        /// the json serializer
+        /// </summary>
+        public IGraphQLWebsocketJsonSerializer JsonSerializer { get; set; }
+
+        /// <summary>
+        /// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
+        /// </summary>
+        public HttpMessageHandler HttpMessageHandler { get; set; } = new HttpClientHandler();
+
+        /// <summary>
+        /// The <see cref="MediaTypeHeaderValue"/> that will be send on POST
+        /// </summary>
+        public string MediaType { get; set; } = "application/json"; // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
+
+        /// <summary>
+        /// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
+        /// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+        /// </summary>
+        public Func<int, TimeSpan> BackOffStrategy { get; set; } = n =>
+        {
+            var rnd = new Random();
+            return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+        };
+
+        /// <summary>
+        /// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
+        /// </summary>
+        public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
+
+        /// <summary>
+        /// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
+        /// </summary>
+        public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
+
+        /// <summary>
+        /// This callback is called after successfully establishing a websocket connection but before any regular request is made. 
+        /// </summary>
+        public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
+    }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpException.cs b/src/GraphQL.Client/GraphQLHttpException.cs
index b40807ca..4a606507 100644
--- a/src/GraphQL.Client/GraphQLHttpException.cs
+++ b/src/GraphQL.Client/GraphQLHttpException.cs
@@ -1,26 +1,29 @@
 using System;
 using System.Net.Http;
 
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http
+{
 
-	/// <summary>
-	/// An exception thrown on unexpected <see cref="System.Net.Http.HttpResponseMessage"/>
-	/// </summary>
-	public class GraphQLHttpException : Exception {
+    /// <summary>
+    /// An exception thrown on unexpected <see cref="System.Net.Http.HttpResponseMessage"/>
+    /// </summary>
+    public class GraphQLHttpException : Exception
+    {
 
-		/// <summary>
-		/// The <see cref="System.Net.Http.HttpResponseMessage"/>
-		/// </summary>
-		public HttpResponseMessage HttpResponseMessage { get; }
+        /// <summary>
+        /// The <see cref="System.Net.Http.HttpResponseMessage"/>
+        /// </summary>
+        public HttpResponseMessage HttpResponseMessage { get; }
 
-		/// <summary>
-		/// Creates a new instance of <see cref="GraphQLHttpException"/>
-		/// </summary>
-		/// <param name="httpResponseMessage">The unexpected <see cref="System.Net.Http.HttpResponseMessage"/></param>
-		public GraphQLHttpException(HttpResponseMessage httpResponseMessage) : base($"Unexpected {nameof(System.Net.Http.HttpResponseMessage)} with code: {httpResponseMessage?.StatusCode}") {
-			this.HttpResponseMessage = httpResponseMessage ?? throw new ArgumentNullException(nameof(httpResponseMessage));
-		}
+        /// <summary>
+        /// Creates a new instance of <see cref="GraphQLHttpException"/>
+        /// </summary>
+        /// <param name="httpResponseMessage">The unexpected <see cref="System.Net.Http.HttpResponseMessage"/></param>
+        public GraphQLHttpException(HttpResponseMessage httpResponseMessage) : base($"Unexpected {nameof(System.Net.Http.HttpResponseMessage)} with code: {httpResponseMessage?.StatusCode}")
+        {
+            this.HttpResponseMessage = httpResponseMessage ?? throw new ArgumentNullException(nameof(httpResponseMessage));
+        }
 
-	}
+    }
 
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 67e06259..f801f9c7 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -2,21 +2,23 @@
 using System.Net.Http;
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http
+{
 
-	public class GraphQLHttpRequest : GraphQLRequest {
-		public GraphQLHttpRequest()
-		{
-		}
+    public class GraphQLHttpRequest : GraphQLRequest
+    {
+        public GraphQLHttpRequest()
+        {
+        }
 
-		public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null) : base(query, variables, operationName)
-		{
-		}
+        public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null) : base(query, variables, operationName)
+        {
+        }
 
-		/// <summary>
-		/// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
-		/// </summary>
-		[IgnoreDataMember]
-		public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
-	}
+        /// <summary>
+        /// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
+        /// </summary>
+        [IgnoreDataMember]
+        public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
+    }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index b14d8790..06669984 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -2,35 +2,41 @@
 using System.Net;
 using System.Net.Http.Headers;
 
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http
+{
 
-	public class GraphQLHttpResponse<T>: GraphQLResponse<T> {
-		public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) {
-			Data = response.Data;
-			Errors = response.Errors;
-			Extensions = response.Extensions;
-			ResponseHeaders = responseHeaders;
-			StatusCode = statusCode;
-		}
+    public class GraphQLHttpResponse<T> : GraphQLResponse<T>
+    {
+        public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode)
+        {
+            Data = response.Data;
+            Errors = response.Errors;
+            Extensions = response.Extensions;
+            ResponseHeaders = responseHeaders;
+            StatusCode = statusCode;
+        }
 
-		public HttpResponseHeaders ResponseHeaders { get; set; }
-		public HttpStatusCode StatusCode { get; set; }
-	}
+        public HttpResponseHeaders ResponseHeaders { get; set; }
+        public HttpStatusCode StatusCode { get; set; }
+    }
 
-	public static class GraphQLResponseExtensions {
-		public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) {
-			return new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
-		}
+    public static class GraphQLResponseExtensions
+    {
+        public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode)
+        {
+            return new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
+        }
 
-		/// <summary>
-		/// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws ig the cast fails.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="response"></param>
-		/// <exception cref="InvalidCastException"><paramref name="response"/> is not a <see cref="GraphQLHttpResponse{T}"/></exception>
-		/// <returns></returns>
-		public static GraphQLHttpResponse<T> AsGraphQLHttpResponse<T>(this GraphQLResponse<T> response) {
-			return (GraphQLHttpResponse<T>) response;
-		}
-	}
+        /// <summary>
+        /// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws ig the cast fails.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="response"></param>
+        /// <exception cref="InvalidCastException"><paramref name="response"/> is not a <see cref="GraphQLHttpResponse{T}"/></exception>
+        /// <returns></returns>
+        public static GraphQLHttpResponse<T> AsGraphQLHttpResponse<T>(this GraphQLResponse<T> response)
+        {
+            return (GraphQLHttpResponse<T>)response;
+        }
+    }
 }
diff --git a/src/GraphQL.Client/GraphQLSubscriptionException.cs b/src/GraphQL.Client/GraphQLSubscriptionException.cs
index 8607c5be..d9accc85 100644
--- a/src/GraphQL.Client/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client/GraphQLSubscriptionException.cs
@@ -1,25 +1,30 @@
 using System;
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Http {
-	[Serializable]
-	public class GraphQLSubscriptionException : Exception {
-		//
-		// For guidelines regarding the creation of new exception types, see
-		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
-		// and
-		//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
-		//
+namespace GraphQL.Client.Http
+{
+    [Serializable]
+    public class GraphQLSubscriptionException : Exception
+    {
+        //
+        // For guidelines regarding the creation of new exception types, see
+        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+        // and
+        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+        //
 
-		public GraphQLSubscriptionException() {
-		}
+        public GraphQLSubscriptionException()
+        {
+        }
 
-		public GraphQLSubscriptionException(object error) : base(error.ToString()) {
-		}
+        public GraphQLSubscriptionException(object error) : base(error.ToString())
+        {
+        }
 
-		protected GraphQLSubscriptionException(
-			SerializationInfo info,
-			StreamingContext context) : base(info, context) {
-		}
-	}
+        protected GraphQLSubscriptionException(
+            SerializationInfo info,
+            StreamingContext context) : base(info, context)
+        {
+        }
+    }
 }
diff --git a/src/GraphQL.Client/HttpClientExtensions.cs b/src/GraphQL.Client/HttpClientExtensions.cs
index 7e78cae3..06315817 100644
--- a/src/GraphQL.Client/HttpClientExtensions.cs
+++ b/src/GraphQL.Client/HttpClientExtensions.cs
@@ -1,18 +1,20 @@
 using System;
 using System.Net.Http;
 
-namespace GraphQL.Client.Http {
+namespace GraphQL.Client.Http
+{
 
-	public static class HttpClientExtensions {
+    public static class HttpClientExtensions
+    {
 
-		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, string endPoint) =>
-			httpClient.AsGraphQLClient(new Uri(endPoint));
+        public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, string endPoint) =>
+            httpClient.AsGraphQLClient(new Uri(endPoint));
 
-		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
-			new GraphQLHttpClient(new GraphQLHttpClientOptions { EndPoint = endPoint }, httpClient);
+        public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
+            new GraphQLHttpClient(new GraphQLHttpClientOptions { EndPoint = endPoint }, httpClient);
 
-		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
-			new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
-	}
+        public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
+            new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
+    }
 
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index ec3d5a18..cab0f1d2 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -12,342 +12,387 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
 
-namespace GraphQL.Client.Http.Websocket {
-	internal class GraphQLHttpWebSocket : IDisposable {
-
-		#region Private fields
-
-		private readonly Uri webSocketUri;
-		private readonly GraphQLHttpClient client;
-		private readonly ArraySegment<byte> buffer;
-		private readonly CancellationTokenSource internalCancellationTokenSource = new CancellationTokenSource();
-		private readonly CancellationToken internalCancellationToken;
-		private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
-		private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
-		private readonly BehaviorSubject<GraphQLWebsocketConnectionState> stateSubject =
-			new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
-		private readonly IDisposable requestSubscription;
-		private readonly EventLoopScheduler receiveLoopScheduler = new EventLoopScheduler();
-		private readonly EventLoopScheduler sendLoopScheduler = new EventLoopScheduler();
-
-		private int connectionAttempt = 0;
-		private IConnectableObservable<WebsocketMessageWrapper> incomingMessages;
-		private IDisposable incomingMessagesConnection;
-		private GraphQLHttpClientOptions Options => client.Options;
-		
-		private Task initializeWebSocketTask = Task.CompletedTask;
-		private readonly object initializeLock = new object();
+namespace GraphQL.Client.Http.Websocket
+{
+    internal class GraphQLHttpWebSocket : IDisposable
+    {
+
+        #region Private fields
+
+        private readonly Uri webSocketUri;
+        private readonly GraphQLHttpClient client;
+        private readonly ArraySegment<byte> buffer;
+        private readonly CancellationTokenSource internalCancellationTokenSource = new CancellationTokenSource();
+        private readonly CancellationToken internalCancellationToken;
+        private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
+        private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
+        private readonly BehaviorSubject<GraphQLWebsocketConnectionState> stateSubject =
+            new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
+        private readonly IDisposable requestSubscription;
+        private readonly EventLoopScheduler receiveLoopScheduler = new EventLoopScheduler();
+        private readonly EventLoopScheduler sendLoopScheduler = new EventLoopScheduler();
+
+        private int connectionAttempt = 0;
+        private IConnectableObservable<WebsocketMessageWrapper> incomingMessages;
+        private IDisposable incomingMessagesConnection;
+        private GraphQLHttpClientOptions Options => client.Options;
+
+        private Task initializeWebSocketTask = Task.CompletedTask;
+        private readonly object initializeLock = new object();
 
 #if NETFRAMEWORK
 		private WebSocket clientWebSocket = null;
 #else
-		private ClientWebSocket clientWebSocket = null;
+        private ClientWebSocket clientWebSocket = null;
 #endif
 
-		#endregion
-
-		
-		#region Public properties
-
-		/// <summary>
-		/// The current websocket state
-		/// </summary>
-		public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
-
-		/// <summary>
-		/// Publishes all errors which occur within the receive pipeline
-		/// </summary>
-		public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
-
-		/// <summary>
-		/// Publishes the connection state of the <see cref="GraphQLHttpWebSocket"/>
-		/// </summary>
-		public IObservable<GraphQLWebsocketConnectionState> ConnectionState => stateSubject.DistinctUntilChanged();
-
-		/// <summary>
-		/// Publishes all messages which are received on the websocket
-		/// </summary>
-		public IObservable<WebsocketMessageWrapper> IncomingMessageStream { get; }
-
-		#endregion
-
-		
-		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client) {
-			internalCancellationToken = internalCancellationTokenSource.Token;
-			this.webSocketUri = webSocketUri;
-			this.client = client;
-			buffer = new ArraySegment<byte>(new byte[8192]);
-			IncomingMessageStream = GetMessageStream();
-			receiveLoopScheduler.Schedule(() =>
-				Debug.WriteLine($"receive loop scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
-
-			requestSubscription = requestSubject
-				.ObserveOn(sendLoopScheduler)
-				.Subscribe(async request => await SendWebSocketRequest(request));
-		}
-
-
-		#region Send requests
-
-		/// <summary>
-		/// Create a new subscription stream
-		/// </summary>
-		/// <typeparam name="TResponse">the response type</typeparam>
-		/// <param name="request">the <see cref="GraphQLRequest"/> to start the subscription</param>
-		/// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
-		/// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
-		public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler = null) {
-			return Observable.Defer(() =>
-				Observable.Create<GraphQLResponse<TResponse>>(async observer => {
-					Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
-					await client.Options.PreprocessRequest(request, client);
-					var startRequest = new GraphQLWebSocketRequest {
-						Id = Guid.NewGuid().ToString("N"),
-						Type = GraphQLWebSocketMessageType.GQL_START,
-						Payload = request
-					};
-					var closeRequest = new GraphQLWebSocketRequest {
-						Id = startRequest.Id,
-						Type = GraphQLWebSocketMessageType.GQL_STOP
-					};
-					var initRequest = new GraphQLWebSocketRequest {
-						Id = startRequest.Id,
-						Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-					};
-
-					var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
-						IncomingMessageStream
-							// ignore null values and messages for other requests
-							.Where(response => response != null && response.Id == startRequest.Id)
-							.Subscribe(response => {
-								// terminate the sequence when a 'complete' message is received
-								if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE) {
-									Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-									o.OnCompleted();
-									return;
-								}
-
-								// post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-								Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
-								var typedResponse =
-									client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-										response.MessageBytes);
-								o.OnNext(typedResponse.Payload);
-
-								// in case of a GraphQL error, terminate the sequence after the response has been posted
-								if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR) {
-									Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
-									o.OnCompleted();
-								}
-								},
-								e => {
-									Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
-									o.OnError(e);
-								},
-								() => {
-									Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
-									o.OnCompleted();
-								})
-					);
-
-					try {
-						// initialize websocket (completes immediately if socket is already open)
-						await InitializeWebSocket();
-					}
-					catch (Exception e) {
-						// subscribe observer to failed observable
-						return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-					}
-
-					var disposable = new CompositeDisposable(
-						observable.Subscribe(observer),
-						Disposable.Create(async () => {
-							// only try to send close request on open websocket
-							if (WebSocketState != WebSocketState.Open) return;
-
-							try {
-								Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-								await QueueWebSocketRequest(closeRequest);
-							}
-							// do not break on disposing
-							catch (OperationCanceledException) { }
-						})
-					);
-
-					// send connection init
-					Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
-					try {
-						await QueueWebSocketRequest(initRequest);
-					}
-					catch (Exception e) {
-						Console.WriteLine(e);
-						throw;
-					}
-
-					Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
-					// send subscription request
-					try {
-						await QueueWebSocketRequest(startRequest);
-					}
-					catch (Exception e) {
-						Console.WriteLine(e);
-						throw;
-					}
-
-					return disposable;
-				}))
-				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-				.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-					Observable.Empty<GraphQLResponse<TResponse>>())
-				// wrap results
-				.Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
-				// do exception handling
-				.Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e => {
-					try {
-						if (exceptionHandler == null) {
-							// if the external handler is not set, propagate all exceptions except WebSocketExceptions
-							// this will ensure that the client tries to re-establish subscriptions on connection loss
-							if (!(e is WebSocketException)) throw e;
-						}
-						else {
-							// exceptions thrown by the handler will propagate to OnError()
-							exceptionHandler?.Invoke(e);
-						}
-
-						// throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-						if (internalCancellationToken.IsCancellationRequested)
-							return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
-						else {
-							Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
-							return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
-						}
-					}
-					catch (Exception exception) {
-						// wrap all other exceptions to be propagated behind retry
-						return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
-					}
-				})
-				// attempt to recreate the websocket for rethrown exceptions
-				.Retry()
-				// unwrap and push results or throw wrapped exceptions
-				.SelectMany(t => {
-					Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId}");
-					// if the result contains an exception, throw it on the observable
-					if (t.Item2 != null)
-						return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
-
-					return t.Item1 == null
-						? Observable.Empty<GraphQLResponse<TResponse>>()
-						: Observable.Return(t.Item1);
-				})
-				// transform to hot observable and auto-connect
-				.Publish().RefCount();
-		}
-
-		/// <summary>
-		/// Send a regular GraphQL request (query, mutation) via websocket
-		/// </summary>
-		/// <typeparam name="TResponse">the response type</typeparam>
-		/// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
-		/// <param name="cancellationToken">the token to cancel the request</param>
-		/// <returns></returns>
-		public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) {
-			return Observable.Create<GraphQLResponse<TResponse>>(async observer => {
-				await client.Options.PreprocessRequest(request, client);
-				var websocketRequest = new GraphQLWebSocketRequest {
-					Id = Guid.NewGuid().ToString("N"),
-					Type = GraphQLWebSocketMessageType.GQL_START,
-					Payload = request
-				};
-				var observable = IncomingMessageStream
-					.Where(response => response != null && response.Id == websocketRequest.Id)
-					.TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-					.Select(response => {
-						Debug.WriteLine($"received response for request {websocketRequest.Id}");
-						var typedResponse =
-							client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-								response.MessageBytes);
-						return typedResponse.Payload;
-					});
-
-				try {
-					// initialize websocket (completes immediately if socket is already open)
-					await InitializeWebSocket();
-				}
-				catch (Exception e) {
-					// subscribe observer to failed observable
-					return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-				}
-
-				var disposable = new CompositeDisposable(
-					observable.Subscribe(observer)
-				);
-
-				Debug.WriteLine($"submitting request {websocketRequest.Id}");
-				// send request
-				try {
-					await QueueWebSocketRequest(websocketRequest);
-				}
-				catch (Exception e) {
-					Console.WriteLine(e);
-					throw;
-				}
-
-				return disposable;
-			})
-			// complete sequence on OperationCanceledException, this is triggered by the cancellation token
-			.Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-				Observable.Empty<GraphQLResponse<TResponse>>())
-			.FirstAsync()
-			.ToTask(cancellationToken);
-		}
-
-		private Task QueueWebSocketRequest(GraphQLWebSocketRequest request) {
-			requestSubject.OnNext(request);
-			return request.SendTask();
-		}
-
-		private async Task SendWebSocketRequest(GraphQLWebSocketRequest request) {
-			try {
-				if (internalCancellationToken.IsCancellationRequested) {
-					request.SendCanceled();
-					return;
-				}
-
-				await InitializeWebSocket();
-				var requestBytes = Options.JsonSerializer.SerializeToBytes(request);
-				await this.clientWebSocket.SendAsync(
-					new ArraySegment<byte>(requestBytes),
-					WebSocketMessageType.Text,
-					true,
-					internalCancellationToken);
-				request.SendCompleted();
-			}
-			catch (Exception e) {
-				request.SendFailed(e);
-			}
-		}
-
-		#endregion
-		
-		public Task InitializeWebSocket() {
-			// do not attempt to initialize if cancellation is requested
-			if (Completion != null)
-				throw new OperationCanceledException();
-
-			lock (initializeLock) {
-				// if an initialization task is already running, return that
-				if (initializeWebSocketTask != null &&
-				   !initializeWebSocketTask.IsFaulted &&
-				   !initializeWebSocketTask.IsCompleted)
-					return initializeWebSocketTask;
-
-				// if the websocket is open, return a completed task
-				if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
-					return Task.CompletedTask;
-
-				// else (re-)create websocket and connect
-				clientWebSocket?.Dispose();
+        #endregion
+
+
+        #region Public properties
+
+        /// <summary>
+        /// The current websocket state
+        /// </summary>
+        public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
+
+        /// <summary>
+        /// Publishes all errors which occur within the receive pipeline
+        /// </summary>
+        public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
+
+        /// <summary>
+        /// Publishes the connection state of the <see cref="GraphQLHttpWebSocket"/>
+        /// </summary>
+        public IObservable<GraphQLWebsocketConnectionState> ConnectionState => stateSubject.DistinctUntilChanged();
+
+        /// <summary>
+        /// Publishes all messages which are received on the websocket
+        /// </summary>
+        public IObservable<WebsocketMessageWrapper> IncomingMessageStream { get; }
+
+        #endregion
+
+
+        public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
+        {
+            internalCancellationToken = internalCancellationTokenSource.Token;
+            this.webSocketUri = webSocketUri;
+            this.client = client;
+            buffer = new ArraySegment<byte>(new byte[8192]);
+            IncomingMessageStream = GetMessageStream();
+            receiveLoopScheduler.Schedule(() =>
+                Debug.WriteLine($"receive loop scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
+
+            requestSubscription = requestSubject
+                .ObserveOn(sendLoopScheduler)
+                .Subscribe(async request => await SendWebSocketRequest(request));
+        }
+
+
+        #region Send requests
+
+        /// <summary>
+        /// Create a new subscription stream
+        /// </summary>
+        /// <typeparam name="TResponse">the response type</typeparam>
+        /// <param name="request">the <see cref="GraphQLRequest"/> to start the subscription</param>
+        /// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
+        /// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler = null)
+        {
+            return Observable.Defer(() =>
+                Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+                {
+                    Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
+                    await client.Options.PreprocessRequest(request, client);
+                    var startRequest = new GraphQLWebSocketRequest
+                    {
+                        Id = Guid.NewGuid().ToString("N"),
+                        Type = GraphQLWebSocketMessageType.GQL_START,
+                        Payload = request
+                    };
+                    var closeRequest = new GraphQLWebSocketRequest
+                    {
+                        Id = startRequest.Id,
+                        Type = GraphQLWebSocketMessageType.GQL_STOP
+                    };
+                    var initRequest = new GraphQLWebSocketRequest
+                    {
+                        Id = startRequest.Id,
+                        Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+                    };
+
+                    var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
+                        IncomingMessageStream
+                            // ignore null values and messages for other requests
+                            .Where(response => response != null && response.Id == startRequest.Id)
+                            .Subscribe(response =>
+                            {
+                                // terminate the sequence when a 'complete' message is received
+                                if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                                {
+                                    Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+                                    o.OnCompleted();
+                                    return;
+                                }
+
+                                // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+                                Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+                                var typedResponse =
+                                    client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                        response.MessageBytes);
+                                o.OnNext(typedResponse.Payload);
+
+                                // in case of a GraphQL error, terminate the sequence after the response has been posted
+                                if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
+                                {
+                                    Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+                                    o.OnCompleted();
+                                }
+                            },
+                                e =>
+                                {
+                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
+                                    o.OnError(e);
+                                },
+                                () =>
+                                {
+                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+                                    o.OnCompleted();
+                                })
+                    );
+
+                    try
+                    {
+                        // initialize websocket (completes immediately if socket is already open)
+                        await InitializeWebSocket();
+                    }
+                    catch (Exception e)
+                    {
+                        // subscribe observer to failed observable
+                        return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+                    }
+
+                    var disposable = new CompositeDisposable(
+                        observable.Subscribe(observer),
+                        Disposable.Create(async () =>
+                        {
+                            // only try to send close request on open websocket
+                            if (WebSocketState != WebSocketState.Open)
+                                return;
+
+                            try
+                            {
+                                Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+                                await QueueWebSocketRequest(closeRequest);
+                            }
+                            // do not break on disposing
+                            catch (OperationCanceledException) { }
+                        })
+                    );
+
+                    // send connection init
+                    Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
+                    try
+                    {
+                        await QueueWebSocketRequest(initRequest);
+                    }
+                    catch (Exception e)
+                    {
+                        Console.WriteLine(e);
+                        throw;
+                    }
+
+                    Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+                    // send subscription request
+                    try
+                    {
+                        await QueueWebSocketRequest(startRequest);
+                    }
+                    catch (Exception e)
+                    {
+                        Console.WriteLine(e);
+                        throw;
+                    }
+
+                    return disposable;
+                }))
+                // complete sequence on OperationCanceledException, this is triggered by the cancellation token
+                .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+                    Observable.Empty<GraphQLResponse<TResponse>>())
+                // wrap results
+                .Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
+                // do exception handling
+                .Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e =>
+                {
+                    try
+                    {
+                        if (exceptionHandler == null)
+                        {
+                            // if the external handler is not set, propagate all exceptions except WebSocketExceptions
+                            // this will ensure that the client tries to re-establish subscriptions on connection loss
+                            if (!(e is WebSocketException))
+                                throw e;
+                        }
+                        else
+                        {
+                            // exceptions thrown by the handler will propagate to OnError()
+                            exceptionHandler?.Invoke(e);
+                        }
+
+                        // throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+                        if (internalCancellationToken.IsCancellationRequested)
+                            return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
+                        else
+                        {
+                            Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
+                            return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
+                        }
+                    }
+                    catch (Exception exception)
+                    {
+                        // wrap all other exceptions to be propagated behind retry
+                        return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
+                    }
+                })
+                // attempt to recreate the websocket for rethrown exceptions
+                .Retry()
+                // unwrap and push results or throw wrapped exceptions
+                .SelectMany(t =>
+                {
+                    Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId}");
+                    // if the result contains an exception, throw it on the observable
+                    if (t.Item2 != null)
+                        return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
+
+                    return t.Item1 == null
+                        ? Observable.Empty<GraphQLResponse<TResponse>>()
+                        : Observable.Return(t.Item1);
+                })
+                // transform to hot observable and auto-connect
+                .Publish().RefCount();
+        }
+
+        /// <summary>
+        /// Send a regular GraphQL request (query, mutation) via websocket
+        /// </summary>
+        /// <typeparam name="TResponse">the response type</typeparam>
+        /// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
+        /// <param name="cancellationToken">the token to cancel the request</param>
+        /// <returns></returns>
+        public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+        {
+            return Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+            {
+                await client.Options.PreprocessRequest(request, client);
+                var websocketRequest = new GraphQLWebSocketRequest
+                {
+                    Id = Guid.NewGuid().ToString("N"),
+                    Type = GraphQLWebSocketMessageType.GQL_START,
+                    Payload = request
+                };
+                var observable = IncomingMessageStream
+                    .Where(response => response != null && response.Id == websocketRequest.Id)
+                    .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                    .Select(response =>
+                    {
+                        Debug.WriteLine($"received response for request {websocketRequest.Id}");
+                        var typedResponse =
+                            client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                response.MessageBytes);
+                        return typedResponse.Payload;
+                    });
+
+                try
+                {
+                    // initialize websocket (completes immediately if socket is already open)
+                    await InitializeWebSocket();
+                }
+                catch (Exception e)
+                {
+                    // subscribe observer to failed observable
+                    return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+                }
+
+                var disposable = new CompositeDisposable(
+                    observable.Subscribe(observer)
+                );
+
+                Debug.WriteLine($"submitting request {websocketRequest.Id}");
+                // send request
+                try
+                {
+                    await QueueWebSocketRequest(websocketRequest);
+                }
+                catch (Exception e)
+                {
+                    Console.WriteLine(e);
+                    throw;
+                }
+
+                return disposable;
+            })
+            // complete sequence on OperationCanceledException, this is triggered by the cancellation token
+            .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+                Observable.Empty<GraphQLResponse<TResponse>>())
+            .FirstAsync()
+            .ToTask(cancellationToken);
+        }
+
+        private Task QueueWebSocketRequest(GraphQLWebSocketRequest request)
+        {
+            requestSubject.OnNext(request);
+            return request.SendTask();
+        }
+
+        private async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+        {
+            try
+            {
+                if (internalCancellationToken.IsCancellationRequested)
+                {
+                    request.SendCanceled();
+                    return;
+                }
+
+                await InitializeWebSocket();
+                var requestBytes = Options.JsonSerializer.SerializeToBytes(request);
+                await this.clientWebSocket.SendAsync(
+                    new ArraySegment<byte>(requestBytes),
+                    WebSocketMessageType.Text,
+                    true,
+                    internalCancellationToken);
+                request.SendCompleted();
+            }
+            catch (Exception e)
+            {
+                request.SendFailed(e);
+            }
+        }
+
+        #endregion
+
+        public Task InitializeWebSocket()
+        {
+            // do not attempt to initialize if cancellation is requested
+            if (Completion != null)
+                throw new OperationCanceledException();
+
+            lock (initializeLock)
+            {
+                // if an initialization task is already running, return that
+                if (initializeWebSocketTask != null &&
+                   !initializeWebSocketTask.IsFaulted &&
+                   !initializeWebSocketTask.IsCompleted)
+                    return initializeWebSocketTask;
+
+                // if the websocket is open, return a completed task
+                if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+                    return Task.CompletedTask;
+
+                // else (re-)create websocket and connect
+                clientWebSocket?.Dispose();
 
 #if NETFRAMEWORK
 				// fix websocket not supported on win 7 using
@@ -368,212 +413,236 @@ public Task InitializeWebSocket() {
 						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
 				}
 #else
-				clientWebSocket = new ClientWebSocket();
-				clientWebSocket.Options.AddSubProtocol("graphql-ws");
-				clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
-				clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+                clientWebSocket = new ClientWebSocket();
+                clientWebSocket.Options.AddSubProtocol("graphql-ws");
+                clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 #endif
-				return initializeWebSocketTask = ConnectAsync(internalCancellationToken);
-			}
-		}
-
-		private async Task ConnectAsync(CancellationToken token) {
-			try {
-				await BackOff();
-				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
-				Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
-				await clientWebSocket.ConnectAsync(webSocketUri, token);
-				stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
-				Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
-				await (Options.OnWebsocketConnected?.Invoke(client) ?? Task.CompletedTask);
-				Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {clientWebSocket.GetHashCode()}");
-				connectionAttempt = 1;
-
-				// create receiving observable
-				incomingMessages = Observable
-					.Defer(() => GetReceiveTask().ToObservable().ObserveOn(receiveLoopScheduler))
-					.Repeat()
-					// complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
-					.Catch<WebsocketMessageWrapper, OperationCanceledException>(exception => Observable.Empty<WebsocketMessageWrapper>())
-					.Publish();
-
-				// subscribe maintenance
-				var maintenanceSubscription = incomingMessages.Subscribe(_ => { }, ex => {
-						Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} received an error: {ex}");
-						exceptionSubject.OnNext(ex);
-						incomingMessagesConnection?.Dispose();
-						stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-					},
-					() => {
-						Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} completed");
-						incomingMessagesConnection?.Dispose();
-						stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-					});
-
-
-				// connect observable
-				var connection = incomingMessages.Connect();
-				Debug.WriteLine($"new incoming message stream {incomingMessages.GetHashCode()} created");
-
-				incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
-			}
-			catch (Exception e) {
-				stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-				exceptionSubject.OnNext(e);
-				throw;
-			}
-		}
-
-		/// <summary>
-		/// delay the next connection attempt using <see cref="GraphQLHttpClientOptions.BackOffStrategy"/>
-		/// </summary>
-		/// <returns></returns>
-		private Task BackOff() {
-			connectionAttempt++;
-
-			if (connectionAttempt == 1) return Task.CompletedTask;
-
-			var delay = Options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
-			Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
-			return Task.Delay(delay, internalCancellationToken);
-		}
-
-		private IObservable<WebsocketMessageWrapper> GetMessageStream() {
-			return Observable.Using(() => new EventLoopScheduler(), scheduler =>
-				Observable.Create<WebsocketMessageWrapper>(async observer => {
-					// make sure the websocket ist connected
-					await InitializeWebSocket();
-					// subscribe observer to message stream
-					var subscription = new CompositeDisposable(incomingMessages.ObserveOn(scheduler).Subscribe(observer));
-					// register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
-					subscription.Add(internalCancellationTokenSource.Token.Register(observer.OnCompleted));
-
-					// add some debug output
-					var hashCode = subscription.GetHashCode();
-					subscription.Add(Disposable.Create(() => {
-						Debug.WriteLine($"incoming message subscription {hashCode} disposed");
-					}));
-					Debug.WriteLine($"new incoming message subscription {hashCode} created");
-
-					return subscription;
-				}));
-		}
-
-		private Task<WebsocketMessageWrapper> receiveAsyncTask = null;
-		private readonly object receiveTaskLocker = new object();
-		/// <summary>
-		/// wrapper method to pick up the existing request task if already running
-		/// </summary>
-		/// <returns></returns>
-		private Task<WebsocketMessageWrapper> GetReceiveTask() {
-			lock (receiveTaskLocker) {
-				internalCancellationToken.ThrowIfCancellationRequested();
-				if (receiveAsyncTask == null ||
-					receiveAsyncTask.IsFaulted ||
-					receiveAsyncTask.IsCompleted)
-					receiveAsyncTask = ReceiveWebsocketMessagesAsync();
-			}
-
-			return receiveAsyncTask;
-		}
-
-		/// <summary>
-		/// read a single message from the websocket
-		/// </summary>
-		/// <returns></returns>
-		private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync() {
-			internalCancellationToken.ThrowIfCancellationRequested();
-
-			try {
-				Debug.WriteLine($"waiting for data on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
-
-				using var ms = new MemoryStream();
-				WebSocketReceiveResult webSocketReceiveResult = null;
-				do {
-					// cancellation is done implicitly via the close method
-					webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
-					ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
-				}
-				while (!webSocketReceiveResult.EndOfMessage && !internalCancellationToken.IsCancellationRequested);
-
-				internalCancellationToken.ThrowIfCancellationRequested();
-				ms.Seek(0, SeekOrigin.Begin);
-
-				if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text) {
-					var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
-					response.MessageBytes = ms.ToArray();
-					Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
-					return response;
-				}
-				else {
-					throw new NotSupportedException("binary websocket messages are not supported");
-				}
-			}
-			catch (Exception e) {
-				Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
-				throw;
-			}
-		}
-
-		private async Task CloseAsync() {
-			if (clientWebSocket == null)
-				return;
-
-			// don't attempt to close the websocket if it is in a failed state
-			if (this.clientWebSocket.State != WebSocketState.Open &&
-				this.clientWebSocket.State != WebSocketState.CloseReceived &&
-				this.clientWebSocket.State != WebSocketState.CloseSent) {
-				Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
-				return;
-			}
-
-			Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
-			stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-		}
-
-		#region IDisposable
-		public void Dispose() => Complete();
-
-		/// <summary>
-		/// Cancels the current operation, closes the websocket connection and disposes of internal resources.
-		/// </summary>
-		public void Complete() {
-			lock (completedLocker) {
-				if (Completion == null) Completion = CompleteAsync();
-			}
-		}
-
-		/// <summary>
-		/// Task to await the completion (a.k.a. disposal) of this websocket.
-		/// </summary> 
-		/// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-		public Task Completion { get; private set; }
-
-		private readonly object completedLocker = new object();
-		private async Task CompleteAsync() {
-			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
-			incomingMessagesConnection?.Dispose();
-
-			if (!internalCancellationTokenSource.IsCancellationRequested)
-				internalCancellationTokenSource.Cancel();
-			
-			await CloseAsync();
-			requestSubscription?.Dispose();
-			clientWebSocket?.Dispose();
-			
-			stateSubject?.OnCompleted();
-			stateSubject?.Dispose();
-
-			exceptionSubject?.OnCompleted();
-			exceptionSubject?.Dispose();
-			internalCancellationTokenSource.Dispose();
-
-			sendLoopScheduler?.Dispose();
-			receiveLoopScheduler?.Dispose();
-
-			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
-		}
-#endregion
-	}
+                return initializeWebSocketTask = ConnectAsync(internalCancellationToken);
+            }
+        }
+
+        private async Task ConnectAsync(CancellationToken token)
+        {
+            try
+            {
+                await BackOff();
+                stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
+                Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
+                await clientWebSocket.ConnectAsync(webSocketUri, token);
+                stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
+                Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
+                await (Options.OnWebsocketConnected?.Invoke(client) ?? Task.CompletedTask);
+                Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {clientWebSocket.GetHashCode()}");
+                connectionAttempt = 1;
+
+                // create receiving observable
+                incomingMessages = Observable
+                    .Defer(() => GetReceiveTask().ToObservable().ObserveOn(receiveLoopScheduler))
+                    .Repeat()
+                    // complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
+                    .Catch<WebsocketMessageWrapper, OperationCanceledException>(exception => Observable.Empty<WebsocketMessageWrapper>())
+                    .Publish();
+
+                // subscribe maintenance
+                var maintenanceSubscription = incomingMessages.Subscribe(_ => { }, ex =>
+                {
+                    Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} received an error: {ex}");
+                    exceptionSubject.OnNext(ex);
+                    incomingMessagesConnection?.Dispose();
+                    stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+                },
+                    () =>
+                    {
+                        Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} completed");
+                        incomingMessagesConnection?.Dispose();
+                        stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+                    });
+
+
+                // connect observable
+                var connection = incomingMessages.Connect();
+                Debug.WriteLine($"new incoming message stream {incomingMessages.GetHashCode()} created");
+
+                incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
+            }
+            catch (Exception e)
+            {
+                stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+                exceptionSubject.OnNext(e);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// delay the next connection attempt using <see cref="GraphQLHttpClientOptions.BackOffStrategy"/>
+        /// </summary>
+        /// <returns></returns>
+        private Task BackOff()
+        {
+            connectionAttempt++;
+
+            if (connectionAttempt == 1)
+                return Task.CompletedTask;
+
+            var delay = Options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
+            Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
+            return Task.Delay(delay, internalCancellationToken);
+        }
+
+        private IObservable<WebsocketMessageWrapper> GetMessageStream()
+        {
+            return Observable.Using(() => new EventLoopScheduler(), scheduler =>
+                Observable.Create<WebsocketMessageWrapper>(async observer =>
+                {
+                    // make sure the websocket ist connected
+                    await InitializeWebSocket();
+                    // subscribe observer to message stream
+                    var subscription = new CompositeDisposable(incomingMessages.ObserveOn(scheduler).Subscribe(observer));
+                    // register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
+                    subscription.Add(internalCancellationTokenSource.Token.Register(observer.OnCompleted));
+
+                    // add some debug output
+                    var hashCode = subscription.GetHashCode();
+                    subscription.Add(Disposable.Create(() =>
+                    {
+                        Debug.WriteLine($"incoming message subscription {hashCode} disposed");
+                    }));
+                    Debug.WriteLine($"new incoming message subscription {hashCode} created");
+
+                    return subscription;
+                }));
+        }
+
+        private Task<WebsocketMessageWrapper> receiveAsyncTask = null;
+        private readonly object receiveTaskLocker = new object();
+        /// <summary>
+        /// wrapper method to pick up the existing request task if already running
+        /// </summary>
+        /// <returns></returns>
+        private Task<WebsocketMessageWrapper> GetReceiveTask()
+        {
+            lock (receiveTaskLocker)
+            {
+                internalCancellationToken.ThrowIfCancellationRequested();
+                if (receiveAsyncTask == null ||
+                    receiveAsyncTask.IsFaulted ||
+                    receiveAsyncTask.IsCompleted)
+                    receiveAsyncTask = ReceiveWebsocketMessagesAsync();
+            }
+
+            return receiveAsyncTask;
+        }
+
+        /// <summary>
+        /// read a single message from the websocket
+        /// </summary>
+        /// <returns></returns>
+        private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
+        {
+            internalCancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                Debug.WriteLine($"waiting for data on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+
+                using var ms = new MemoryStream();
+                WebSocketReceiveResult webSocketReceiveResult = null;
+                do
+                {
+                    // cancellation is done implicitly via the close method
+                    webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
+                    ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+                }
+                while (!webSocketReceiveResult.EndOfMessage && !internalCancellationToken.IsCancellationRequested);
+
+                internalCancellationToken.ThrowIfCancellationRequested();
+                ms.Seek(0, SeekOrigin.Begin);
+
+                if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
+                {
+                    var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+                    response.MessageBytes = ms.ToArray();
+                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+                    return response;
+                }
+                else
+                {
+                    throw new NotSupportedException("binary websocket messages are not supported");
+                }
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
+                throw;
+            }
+        }
+
+        private async Task CloseAsync()
+        {
+            if (clientWebSocket == null)
+                return;
+
+            // don't attempt to close the websocket if it is in a failed state
+            if (this.clientWebSocket.State != WebSocketState.Open &&
+                this.clientWebSocket.State != WebSocketState.CloseReceived &&
+                this.clientWebSocket.State != WebSocketState.CloseSent)
+            {
+                Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
+                return;
+            }
+
+            Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
+            await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
+            stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+        }
+
+        #region IDisposable
+        public void Dispose() => Complete();
+
+        /// <summary>
+        /// Cancels the current operation, closes the websocket connection and disposes of internal resources.
+        /// </summary>
+        public void Complete()
+        {
+            lock (completedLocker)
+            {
+                if (Completion == null)
+                    Completion = CompleteAsync();
+            }
+        }
+
+        /// <summary>
+        /// Task to await the completion (a.k.a. disposal) of this websocket.
+        /// </summary> 
+        /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+        public Task Completion { get; private set; }
+
+        private readonly object completedLocker = new object();
+        private async Task CompleteAsync()
+        {
+            Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
+            incomingMessagesConnection?.Dispose();
+
+            if (!internalCancellationTokenSource.IsCancellationRequested)
+                internalCancellationTokenSource.Cancel();
+
+            await CloseAsync();
+            requestSubscription?.Dispose();
+            clientWebSocket?.Dispose();
+
+            stateSubject?.OnCompleted();
+            stateSubject?.Dispose();
+
+            exceptionSubject?.OnCompleted();
+            exceptionSubject?.Dispose();
+            internalCancellationTokenSource.Dispose();
+
+            sendLoopScheduler?.Dispose();
+            receiveLoopScheduler?.Dispose();
+
+            Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
+        }
+        #endregion
+    }
 }
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 3392e97c..c7935675 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -3,104 +3,121 @@
 using System.Linq;
 using System.Runtime.Serialization;
 
-namespace GraphQL {
+namespace GraphQL
+{
 
-	/// <summary>
-	/// Represents a GraphQL Error of a GraphQL Query
-	/// </summary>
-	public class GraphQLError : IEquatable<GraphQLError?> {
+    /// <summary>
+    /// Represents a GraphQL Error of a GraphQL Query
+    /// </summary>
+    public class GraphQLError : IEquatable<GraphQLError?>
+    {
 
-		/// <summary>
-		/// The locations of the error
-		/// </summary>
-		[DataMember(Name = "locations")]
-		public GraphQLLocation[]? Locations { get; set; }
+        /// <summary>
+        /// The locations of the error
+        /// </summary>
+        [DataMember(Name = "locations")]
+        public GraphQLLocation[]? Locations { get; set; }
 
-		/// <summary>
-		/// The message of the error
-		/// </summary>
-		[DataMember(Name = "message")]
-		public string Message { get; set; }
+        /// <summary>
+        /// The message of the error
+        /// </summary>
+        [DataMember(Name = "message")]
+        public string Message { get; set; }
 
-		/// <summary>
-		/// The Path of the error
-		/// </summary>
-		[DataMember(Name = "path")]
-		public object[]? Path { get; set; }
+        /// <summary>
+        /// The Path of the error
+        /// </summary>
+        [DataMember(Name = "path")]
+        public object[]? Path { get; set; }
 
-		/// <summary>
-		/// The extensions of the error
-		/// </summary> 
-		[DataMember(Name = "extensions")]
-		public GraphQLExtensionsType? Extensions { get; set; }
+        /// <summary>
+        /// The extensions of the error
+        /// </summary> 
+        [DataMember(Name = "extensions")]
+        public GraphQLExtensionsType? Extensions { get; set; }
 
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="obj">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
-		public override bool Equals(object? obj) =>
-			this.Equals(obj as GraphQLError);
+        /// <summary>
+        /// Returns a value that indicates whether this instance is equal to a specified object
+        /// </summary>
+        /// <param name="obj">The object to compare with this instance</param>
+        /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
+        public override bool Equals(object? obj) =>
+            this.Equals(obj as GraphQLError);
 
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="other">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
-		public bool Equals(GraphQLError? other) {
-			if (other == null) { return false; }
-			if (ReferenceEquals(this, other)) { return true; }
-			{
-				if (this.Locations != null && other.Locations != null) {
-					if (!this.Locations.SequenceEqual(other.Locations)) { return false; }
-				}
-				else if (this.Locations != null && other.Locations == null) { return false; }
-				else if (this.Locations == null && other.Locations != null) { return false; }
-			}
-			if (!EqualityComparer<string>.Default.Equals(this.Message, other.Message)) { return false; }
-			{
-				if (this.Path != null && other.Path != null) {
-					if (!this.Path.SequenceEqual(other.Path)) { return false; }
-				}
-				else if (this.Path != null && other.Path == null) { return false; }
-				else if (this.Path == null && other.Path != null) { return false; }
-			}
-			return true;
-		}
+        /// <summary>
+        /// Returns a value that indicates whether this instance is equal to a specified object
+        /// </summary>
+        /// <param name="other">The object to compare with this instance</param>
+        /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
+        public bool Equals(GraphQLError? other)
+        {
+            if (other == null)
+            { return false; }
+            if (ReferenceEquals(this, other))
+            { return true; }
+            {
+                if (this.Locations != null && other.Locations != null)
+                {
+                    if (!this.Locations.SequenceEqual(other.Locations))
+                    { return false; }
+                }
+                else if (this.Locations != null && other.Locations == null)
+                { return false; }
+                else if (this.Locations == null && other.Locations != null)
+                { return false; }
+            }
+            if (!EqualityComparer<string>.Default.Equals(this.Message, other.Message))
+            { return false; }
+            {
+                if (this.Path != null && other.Path != null)
+                {
+                    if (!this.Path.SequenceEqual(other.Path))
+                    { return false; }
+                }
+                else if (this.Path != null && other.Path == null)
+                { return false; }
+                else if (this.Path == null && other.Path != null)
+                { return false; }
+            }
+            return true;
+        }
 
-		/// <summary>
-		/// <inheritdoc cref="Object.GetHashCode"/>
-		/// </summary>
-		public override int GetHashCode() {
-			var hashCode = 0;
-			if (this.Locations != null) {
-				hashCode = hashCode ^ EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(this.Locations);
-			}
-			hashCode = hashCode ^ EqualityComparer<string>.Default.GetHashCode(this.Message);
-			if (this.Path != null) {
-				hashCode = hashCode ^ EqualityComparer<dynamic>.Default.GetHashCode(this.Path);
-			}
-			return hashCode;
-		}
+        /// <summary>
+        /// <inheritdoc cref="Object.GetHashCode"/>
+        /// </summary>
+        public override int GetHashCode()
+        {
+            var hashCode = 0;
+            if (this.Locations != null)
+            {
+                hashCode = hashCode ^ EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(this.Locations);
+            }
+            hashCode = hashCode ^ EqualityComparer<string>.Default.GetHashCode(this.Message);
+            if (this.Path != null)
+            {
+                hashCode = hashCode ^ EqualityComparer<dynamic>.Default.GetHashCode(this.Path);
+            }
+            return hashCode;
+        }
 
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLError"/> instances are equivalent
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the equality operator</param>
-		/// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the equality operator</param>
-		/// <returns>true if left and right are equal; otherwise, false</returns>
-		public static bool operator ==(GraphQLError? left, GraphQLError? right) =>
-			EqualityComparer<GraphQLError?>.Default.Equals(left, right);
+        /// <summary>
+        /// Tests whether two specified <see cref="GraphQLError"/> instances are equivalent
+        /// </summary>
+        /// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the equality operator</param>
+        /// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the equality operator</param>
+        /// <returns>true if left and right are equal; otherwise, false</returns>
+        public static bool operator ==(GraphQLError? left, GraphQLError? right) =>
+            EqualityComparer<GraphQLError?>.Default.Equals(left, right);
 
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLError"/> instances are not equal
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the not equal operator</param>
-		/// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the not equal operator</param>
-		/// <returns>true if left and right are unequal; otherwise, false</returns>
-		public static bool operator !=(GraphQLError? left, GraphQLError? right) =>
-			!EqualityComparer<GraphQLError?>.Default.Equals(left, right);
+        /// <summary>
+        /// Tests whether two specified <see cref="GraphQLError"/> instances are not equal
+        /// </summary>
+        /// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the not equal operator</param>
+        /// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the not equal operator</param>
+        /// <returns>true if left and right are unequal; otherwise, false</returns>
+        public static bool operator !=(GraphQLError? left, GraphQLError? right) =>
+            !EqualityComparer<GraphQLError?>.Default.Equals(left, right);
 
-	}
+    }
 
 }
diff --git a/src/GraphQL.Primitives/GraphQLExtensionsType.cs b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
index 2de718d0..76599121 100644
--- a/src/GraphQL.Primitives/GraphQLExtensionsType.cs
+++ b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
@@ -1,9 +1,10 @@
 using System.Collections.Generic;
 
-namespace GraphQL {
+namespace GraphQL
+{
 
-	/// <summary>
-	/// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
-	/// </summary>
-	public class GraphQLExtensionsType: Dictionary<string, object> { }
+    /// <summary>
+    /// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
+    /// </summary>
+    public class GraphQLExtensionsType : Dictionary<string, object> { }
 }
diff --git a/src/GraphQL.Primitives/GraphQLLocation.cs b/src/GraphQL.Primitives/GraphQLLocation.cs
index 0147b05a..335f28b8 100644
--- a/src/GraphQL.Primitives/GraphQLLocation.cs
+++ b/src/GraphQL.Primitives/GraphQLLocation.cs
@@ -1,66 +1,71 @@
 using System;
 using System.Collections.Generic;
 
-namespace GraphQL {
+namespace GraphQL
+{
 
-	/// <summary>
-	/// Represents a GraphQL Location of a GraphQL Query
-	/// </summary>
-	public sealed class GraphQLLocation : IEquatable<GraphQLLocation?> {
+    /// <summary>
+    /// Represents a GraphQL Location of a GraphQL Query
+    /// </summary>
+    public sealed class GraphQLLocation : IEquatable<GraphQLLocation?>
+    {
 
-		/// <summary>
-		/// The Column
-		/// </summary>
-		public uint Column { get; set; }
+        /// <summary>
+        /// The Column
+        /// </summary>
+        public uint Column { get; set; }
 
-		/// <summary>
-		/// The Line
-		/// </summary>
-		public uint Line { get; set; }
+        /// <summary>
+        /// The Line
+        /// </summary>
+        public uint Line { get; set; }
 
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="obj">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
-		public override bool Equals(object obj) => this.Equals(obj as GraphQLLocation);
+        /// <summary>
+        /// Returns a value that indicates whether this instance is equal to a specified object
+        /// </summary>
+        /// <param name="obj">The object to compare with this instance</param>
+        /// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
+        public override bool Equals(object obj) => this.Equals(obj as GraphQLLocation);
 
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="other">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
-		public bool Equals(GraphQLLocation? other) {
-			if (other == null) { return false; }
-			if (ReferenceEquals(this, other)) { return true; }
-			return EqualityComparer<uint>.Default.Equals(this.Column, other.Column) &&
-				EqualityComparer<uint>.Default.Equals(this.Line, other.Line);
-		}
+        /// <summary>
+        /// Returns a value that indicates whether this instance is equal to a specified object
+        /// </summary>
+        /// <param name="other">The object to compare with this instance</param>
+        /// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
+        public bool Equals(GraphQLLocation? other)
+        {
+            if (other == null)
+            { return false; }
+            if (ReferenceEquals(this, other))
+            { return true; }
+            return EqualityComparer<uint>.Default.Equals(this.Column, other.Column) &&
+                EqualityComparer<uint>.Default.Equals(this.Line, other.Line);
+        }
 
-		/// <summary>
-		/// <inheritdoc cref="Object.GetHashCode"/>
-		/// </summary>
-		public override int GetHashCode() =>
-			this.Column.GetHashCode() ^ this.Line.GetHashCode();
+        /// <summary>
+        /// <inheritdoc cref="Object.GetHashCode"/>
+        /// </summary>
+        public override int GetHashCode() =>
+            this.Column.GetHashCode() ^ this.Line.GetHashCode();
 
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLLocation"/> instances are equivalent
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the equality operator</param>
-		/// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the equality operator</param>
-		/// <returns>true if left and right are equal; otherwise, false</returns>
-		public static bool operator ==(GraphQLLocation? left, GraphQLLocation? right) =>
-			EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
+        /// <summary>
+        /// Tests whether two specified <see cref="GraphQLLocation"/> instances are equivalent
+        /// </summary>
+        /// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the equality operator</param>
+        /// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the equality operator</param>
+        /// <returns>true if left and right are equal; otherwise, false</returns>
+        public static bool operator ==(GraphQLLocation? left, GraphQLLocation? right) =>
+            EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
 
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLLocation"/> instances are not equal
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the not equal operator</param>
-		/// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the not equal operator</param>
-		/// <returns>true if left and right are unequal; otherwise, false</returns>
-		public static bool operator !=(GraphQLLocation? left, GraphQLLocation? right) =>
-			!EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
+        /// <summary>
+        /// Tests whether two specified <see cref="GraphQLLocation"/> instances are not equal
+        /// </summary>
+        /// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the not equal operator</param>
+        /// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the not equal operator</param>
+        /// <returns>true if left and right are unequal; otherwise, false</returns>
+        public static bool operator !=(GraphQLLocation? left, GraphQLLocation? right) =>
+            !EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
 
-	}
+    }
 
 }
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index c8931c90..27681ed8 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -3,99 +3,114 @@
 using System.Linq;
 using System.Runtime.Serialization;
 
-namespace GraphQL {
+namespace GraphQL
+{
 
-	/// <summary>
-	/// A GraphQL request
-	/// </summary>
-	public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequest?> {
-		public const string OperationNameKey = "operationName";
-		public const string QueryKey = "query";
-		public const string VariablesKey = "variables";
+    /// <summary>
+    /// A GraphQL request
+    /// </summary>
+    public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequest?>
+    {
+        public const string OperationNameKey = "operationName";
+        public const string QueryKey = "query";
+        public const string VariablesKey = "variables";
 
-		/// <summary>
-		/// The Query
-		/// </summary>
-		public string Query {
-			get => ContainsKey(QueryKey) ? (string) this[QueryKey] : null;
-			set => this[QueryKey] = value;
-		}
+        /// <summary>
+        /// The Query
+        /// </summary>
+        public string Query
+        {
+            get => ContainsKey(QueryKey) ? (string)this[QueryKey] : null;
+            set => this[QueryKey] = value;
+        }
 
-		/// <summary>
-		/// The name of the Operation
-		/// </summary>
-		public string? OperationName {
-			get => ContainsKey(OperationNameKey) ? (string)this[OperationNameKey] : null;
-			set => this[OperationNameKey] = value;
-		}
+        /// <summary>
+        /// The name of the Operation
+        /// </summary>
+        public string? OperationName
+        {
+            get => ContainsKey(OperationNameKey) ? (string)this[OperationNameKey] : null;
+            set => this[OperationNameKey] = value;
+        }
 
-		/// <summary>
-		/// Represents the request variables
-		/// </summary>
-		public object? Variables {
-			get => ContainsKey(VariablesKey) ? this[VariablesKey] : null;
-			set => this[VariablesKey] = value;
-		}
+        /// <summary>
+        /// Represents the request variables
+        /// </summary>
+        public object? Variables
+        {
+            get => ContainsKey(VariablesKey) ? this[VariablesKey] : null;
+            set => this[VariablesKey] = value;
+        }
 
-		public GraphQLRequest() { }
+        public GraphQLRequest() { }
 
-		public GraphQLRequest(string query, object? variables = null, string? operationName = null) {
-			Query = query;
-			Variables = variables;
-			OperationName = operationName;
-		}
+        public GraphQLRequest(string query, object? variables = null, string? operationName = null)
+        {
+            Query = query;
+            Variables = variables;
+            OperationName = operationName;
+        }
 
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="obj">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public override bool Equals(object? obj) {
-			if (ReferenceEquals(null, obj)) return false;
-			if (ReferenceEquals(this, obj)) return true;
-			if (obj.GetType() != this.GetType()) return false;
-			return Equals((GraphQLRequest)obj);
-		}
+        /// <summary>
+        /// Returns a value that indicates whether this instance is equal to a specified object
+        /// </summary>
+        /// <param name="obj">The object to compare with this instance</param>
+        /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
+        public override bool Equals(object? obj)
+        {
+            if (ReferenceEquals(null, obj))
+                return false;
+            if (ReferenceEquals(this, obj))
+                return true;
+            if (obj.GetType() != this.GetType())
+                return false;
+            return Equals((GraphQLRequest)obj);
+        }
 
-		/// <summary>
-		/// Returns a value that indicates whether this instance is equal to a specified object
-		/// </summary>
-		/// <param name="other">The object to compare with this instance</param>
-		/// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-		public virtual bool Equals(GraphQLRequest? other) {
-			if (ReferenceEquals(null, other)) return false;
-			if (ReferenceEquals(this, other)) return true;
-			return this.Count == other.Count && !this.Except(other).Any();
-		}
+        /// <summary>
+        /// Returns a value that indicates whether this instance is equal to a specified object
+        /// </summary>
+        /// <param name="other">The object to compare with this instance</param>
+        /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
+        public virtual bool Equals(GraphQLRequest? other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+            if (ReferenceEquals(this, other))
+                return true;
+            return this.Count == other.Count && !this.Except(other).Any();
+        }
 
-		/// <summary>
-		/// <inheritdoc cref="Object.GetHashCode"/>
-		/// </summary>
-		public override int GetHashCode() {
-			unchecked {
-				var hashCode = Query.GetHashCode();
-				hashCode = (hashCode * 397) ^ OperationName?.GetHashCode() ?? 0;
-				hashCode = (hashCode * 397) ^ Variables?.GetHashCode() ?? 0;
-				return hashCode;
-			}
-		}
+        /// <summary>
+        /// <inheritdoc cref="Object.GetHashCode"/>
+        /// </summary>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Query.GetHashCode();
+                hashCode = (hashCode * 397) ^ OperationName?.GetHashCode() ?? 0;
+                hashCode = (hashCode * 397) ^ Variables?.GetHashCode() ?? 0;
+                return hashCode;
+            }
+        }
 
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the equality operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the equality operator</param>
-		/// <returns>true if left and right are equal; otherwise, false</returns>
-		public static bool operator ==(GraphQLRequest? left, GraphQLRequest? right) => EqualityComparer<GraphQLRequest?>.Default.Equals(left, right);
+        /// <summary>
+        /// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
+        /// </summary>
+        /// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the equality operator</param>
+        /// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the equality operator</param>
+        /// <returns>true if left and right are equal; otherwise, false</returns>
+        public static bool operator ==(GraphQLRequest? left, GraphQLRequest? right) => EqualityComparer<GraphQLRequest?>.Default.Equals(left, right);
 
-		/// <summary>
-		/// Tests whether two specified <see cref="GraphQLRequest"/> instances are not equal
-		/// </summary>
-		/// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the not equal operator</param>
-		/// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the not equal operator</param>
-		/// <returns>true if left and right are unequal; otherwise, false</returns>
-		public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
-	}
+        /// <summary>
+        /// Tests whether two specified <see cref="GraphQLRequest"/> instances are not equal
+        /// </summary>
+        /// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the not equal operator</param>
+        /// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the not equal operator</param>
+        /// <returns>true if left and right are unequal; otherwise, false</returns>
+        public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
+    }
 
 
 }
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 94a6ea21..fbe90e99 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -3,73 +3,95 @@
 using System.Linq;
 using System.Runtime.Serialization;
 
-namespace GraphQL {
-
-	public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?> {
-
-		[DataMember(Name = "data")]
-		public T Data { get; set; }
-
-		[DataMember(Name = "errors")]
-		public GraphQLError[]? Errors { get; set; }
-
-		[DataMember(Name = "extensions")]
-		public GraphQLExtensionsType? Extensions { get; set; }
-
-		public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
-
-		public bool Equals(GraphQLResponse<T>? other) {
-			if (other == null) { return false; }
-			if (ReferenceEquals(this, other)) { return true; }
-			if (!EqualityComparer<T>.Default.Equals(this.Data, other.Data)) { return false; }
-
-			if (this.Errors != null && other.Errors != null) {
-				if (!Enumerable.SequenceEqual(this.Errors, other.Errors)) { return false; }
-			}
-			else if (this.Errors != null && other.Errors == null) { return false; }
-			else if (this.Errors == null && other.Errors != null) { return false; }
-
-			if (this.Extensions!= null && other.Extensions != null) {
-				if (!Enumerable.SequenceEqual(this.Extensions, other.Extensions)) { return false; }
-			}
-			else if (this.Extensions != null && other.Extensions == null) { return false; }
-			else if (this.Extensions == null && other.Extensions != null) { return false; }
-
-			return true;
-		}
-
-		public override int GetHashCode() {
-			unchecked {
-				var hashCode = EqualityComparer<T>.Default.GetHashCode(this.Data);
-				{
-					if (this.Errors != null) {
-						foreach (var element in this.Errors) {
-							hashCode = (hashCode * 397) ^ EqualityComparer<GraphQLError?>.Default.GetHashCode(element);
-						}
-					}
-					else {
-						hashCode = (hashCode * 397) ^ 0;
-					}
-
-					if (this.Extensions != null) {
-						foreach (var element in this.Extensions) {
-							hashCode = (hashCode * 397) ^ EqualityComparer<KeyValuePair<string,object>>.Default.GetHashCode(element);
-						}
-					}
-					else {
-						hashCode = (hashCode * 397) ^ 0;
-					}
-				}
-				return hashCode;
-			}
-		}
-
-
-		public static bool operator ==(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => EqualityComparer<GraphQLResponse<T>?>.Default.Equals(response1, response2);
-
-		public static bool operator !=(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => !(response1 == response2);
-
-	}
+namespace GraphQL
+{
+
+    public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?>
+    {
+
+        [DataMember(Name = "data")]
+        public T Data { get; set; }
+
+        [DataMember(Name = "errors")]
+        public GraphQLError[]? Errors { get; set; }
+
+        [DataMember(Name = "extensions")]
+        public GraphQLExtensionsType? Extensions { get; set; }
+
+        public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
+
+        public bool Equals(GraphQLResponse<T>? other)
+        {
+            if (other == null)
+            { return false; }
+            if (ReferenceEquals(this, other))
+            { return true; }
+            if (!EqualityComparer<T>.Default.Equals(this.Data, other.Data))
+            { return false; }
+
+            if (this.Errors != null && other.Errors != null)
+            {
+                if (!Enumerable.SequenceEqual(this.Errors, other.Errors))
+                { return false; }
+            }
+            else if (this.Errors != null && other.Errors == null)
+            { return false; }
+            else if (this.Errors == null && other.Errors != null)
+            { return false; }
+
+            if (this.Extensions != null && other.Extensions != null)
+            {
+                if (!Enumerable.SequenceEqual(this.Extensions, other.Extensions))
+                { return false; }
+            }
+            else if (this.Extensions != null && other.Extensions == null)
+            { return false; }
+            else if (this.Extensions == null && other.Extensions != null)
+            { return false; }
+
+            return true;
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = EqualityComparer<T>.Default.GetHashCode(this.Data);
+                {
+                    if (this.Errors != null)
+                    {
+                        foreach (var element in this.Errors)
+                        {
+                            hashCode = (hashCode * 397) ^ EqualityComparer<GraphQLError?>.Default.GetHashCode(element);
+                        }
+                    }
+                    else
+                    {
+                        hashCode = (hashCode * 397) ^ 0;
+                    }
+
+                    if (this.Extensions != null)
+                    {
+                        foreach (var element in this.Extensions)
+                        {
+                            hashCode = (hashCode * 397) ^ EqualityComparer<KeyValuePair<string, object>>.Default.GetHashCode(element);
+                        }
+                    }
+                    else
+                    {
+                        hashCode = (hashCode * 397) ^ 0;
+                    }
+                }
+                return hashCode;
+            }
+        }
+
+
+        public static bool operator ==(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => EqualityComparer<GraphQLResponse<T>?>.Default.Equals(response1, response2);
+
+        public static bool operator !=(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => !(response1 == response2);
+
+    }
 
 
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index 13106fcd..40244aac 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -11,54 +11,62 @@
 using Newtonsoft.Json;
 using Xunit;
 
-namespace GraphQL.Client.Serializer.Tests {
-	public abstract class BaseSerializeNoCamelCaseTest {
+namespace GraphQL.Client.Serializer.Tests
+{
+    public abstract class BaseSerializeNoCamelCaseTest
+    {
 
-		public IGraphQLWebsocketJsonSerializer Serializer { get; }
-		public IGraphQLClient ChatClient { get; }
-		public IGraphQLClient StarWarsClient { get; }
+        public IGraphQLWebsocketJsonSerializer Serializer { get; }
+        public IGraphQLClient ChatClient { get; }
+        public IGraphQLClient StarWarsClient { get; }
 
-		protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer serializer) {
-			Serializer = serializer;
-			ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
-			StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
-		}
+        protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer serializer)
+        {
+            Serializer = serializer;
+            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
+            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
+        }
 
-		[Theory]
-		[ClassData(typeof(SerializeToStringTestData))]
-		public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
-			var json = Serializer.SerializeToString(request).RemoveWhitespace();
-			json.Should().Be(expectedJson.RemoveWhitespace());
-		}
+        [Theory]
+        [ClassData(typeof(SerializeToStringTestData))]
+        public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
+        {
+            var json = Serializer.SerializeToString(request).RemoveWhitespace();
+            json.Should().Be(expectedJson.RemoveWhitespace());
+        }
 
-		[Theory]
-		[ClassData(typeof(SerializeToBytesTestData))]
-		public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request) {
-			var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
-			json.Should().Be(expectedJson.RemoveWhitespace());
-		}
+        [Theory]
+        [ClassData(typeof(SerializeToBytesTestData))]
+        public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
+        {
+            var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
+            json.Should().Be(expectedJson.RemoveWhitespace());
+        }
 
 
-		[Fact]
-		public async void WorksWithoutCamelCaseNamingStrategy() {
+        [Fact]
+        public async void WorksWithoutCamelCaseNamingStrategy()
+        {
 
-			const string message = "some random testing message";
-			var graphQLRequest = new GraphQLRequest(
-				@"mutation($input: MessageInputType){
+            const string message = "some random testing message";
+            var graphQLRequest = new GraphQLRequest(
+                @"mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
 				}",
-				new {
-					input = new {
-						fromId = "2",
-						content = message,
-						sentAt = DateTime.Now
-					}
-				});
-			var response = await ChatClient.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
+                new
+                {
+                    input = new
+                    {
+                        fromId = "2",
+                        content = message,
+                        sentAt = DateTime.Now
+                    }
+                });
+            var response = await ChatClient.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
 
-			Assert.Equal(message, response.Data.addMessage.content);
-		}
-	}
+            Assert.Equal(message, response.Data.addMessage.content);
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 1f3a19c2..ab86dbdf 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -19,70 +19,78 @@ namespace GraphQL.Client.Serializer.Tests
 {
     public abstract class BaseSerializerTest
     {
-	    public IGraphQLWebsocketJsonSerializer Serializer { get; }
-	    public IGraphQLClient ChatClient { get; }
-	    public IGraphQLClient StarWarsClient { get; }
-
-		protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer serializer) {
-			Serializer = serializer;
-			ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
-			StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
-		}
-
-		[Theory]
-		[ClassData(typeof(SerializeToStringTestData))]
-		public void SerializeToStringTest(string expectedJson, GraphQLRequest request) {
-			var json = Serializer.SerializeToString(request).RemoveWhitespace();
-			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
-		}
-
-		[Theory]
-		[ClassData(typeof(SerializeToBytesTestData))]
-		public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request) {
-			var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
-			json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
-		}
-
-		[Theory]
-		[ClassData(typeof(DeserializeResponseTestData))]
-		public async void DeserializeFromUtf8StreamTest(string json, GraphQLResponse<object> expectedResponse) {
-			var jsonBytes = Encoding.UTF8.GetBytes(json);
-			await using var ms = new MemoryStream(jsonBytes);
-			var response = await Serializer.DeserializeFromUtf8StreamAsync<GraphQLResponse<object>>(ms, CancellationToken.None);
-
-			response.Data.Should().BeEquivalentTo(expectedResponse.Data);
-			response.Errors.Should().Equal(expectedResponse.Errors);
-
-			if (expectedResponse.Extensions == null)
-				response.Extensions.Should().BeNull();
-			else {
-				foreach (var element in expectedResponse.Extensions) {
-					response.Extensions.Should().ContainKey(element.Key);
-					response.Extensions[element.Key].Should().BeEquivalentTo(element.Value);
-				}
-			}
-		}
-
-		[Fact]
-		public async void CanDeserializeExtensions() {
-
-			var response = await ChatClient.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
-					() => new { extensionsTest = "" })
-				;
-
-			response.Errors.Should().NotBeNull();
-			response.Errors.Should().ContainSingle();
-			response.Errors[0].Extensions.Should().NotBeNull();
-			response.Errors[0].Extensions.Should().ContainKey("data");
-
-			response.Errors[0].Extensions["data"].Should().BeEquivalentTo(ChatQuery.TestExtensions);
-		}
-
-
-		[Theory]
-		[ClassData(typeof(StarWarsHumans))]
-		public async void CanDoSerializationWithAnonymousTypes(int id, string name) {
-			var graphQLRequest = new GraphQLRequest(@"
+        public IGraphQLWebsocketJsonSerializer Serializer { get; }
+        public IGraphQLClient ChatClient { get; }
+        public IGraphQLClient StarWarsClient { get; }
+
+        protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer serializer)
+        {
+            Serializer = serializer;
+            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
+            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
+        }
+
+        [Theory]
+        [ClassData(typeof(SerializeToStringTestData))]
+        public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
+        {
+            var json = Serializer.SerializeToString(request).RemoveWhitespace();
+            json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
+        }
+
+        [Theory]
+        [ClassData(typeof(SerializeToBytesTestData))]
+        public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
+        {
+            var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
+            json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
+        }
+
+        [Theory]
+        [ClassData(typeof(DeserializeResponseTestData))]
+        public async void DeserializeFromUtf8StreamTest(string json, GraphQLResponse<object> expectedResponse)
+        {
+            var jsonBytes = Encoding.UTF8.GetBytes(json);
+            await using var ms = new MemoryStream(jsonBytes);
+            var response = await Serializer.DeserializeFromUtf8StreamAsync<GraphQLResponse<object>>(ms, CancellationToken.None);
+
+            response.Data.Should().BeEquivalentTo(expectedResponse.Data);
+            response.Errors.Should().Equal(expectedResponse.Errors);
+
+            if (expectedResponse.Extensions == null)
+                response.Extensions.Should().BeNull();
+            else
+            {
+                foreach (var element in expectedResponse.Extensions)
+                {
+                    response.Extensions.Should().ContainKey(element.Key);
+                    response.Extensions[element.Key].Should().BeEquivalentTo(element.Value);
+                }
+            }
+        }
+
+        [Fact]
+        public async void CanDeserializeExtensions()
+        {
+
+            var response = await ChatClient.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
+                    () => new { extensionsTest = "" })
+                ;
+
+            response.Errors.Should().NotBeNull();
+            response.Errors.Should().ContainSingle();
+            response.Errors[0].Extensions.Should().NotBeNull();
+            response.Errors[0].Extensions.Should().ContainKey("data");
+
+            response.Errors[0].Extensions["data"].Should().BeEquivalentTo(ChatQuery.TestExtensions);
+        }
+
+
+        [Theory]
+        [ClassData(typeof(StarWarsHumans))]
+        public async void CanDoSerializationWithAnonymousTypes(int id, string name)
+        {
+            var graphQLRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
@@ -94,21 +102,22 @@ query Droid($id: String!) {
 				    name
 				  }
 				}",
-				new { id = id.ToString() },
-				"Human");
+                new { id = id.ToString() },
+                "Human");
 
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
-			Assert.Null(response.Errors);
-			Assert.Equal(name, response.Data.Human.Name);
-		}
+            Assert.Null(response.Errors);
+            Assert.Equal(name, response.Data.Human.Name);
+        }
 
-		[Fact]
-		public async void CanDoSerializationWithPredefinedTypes() {
-				const string message = "some random testing message";
-				var response = await ChatClient.AddMessageAsync(message);
+        [Fact]
+        public async void CanDoSerializationWithPredefinedTypes()
+        {
+            const string message = "some random testing message";
+            var response = await ChatClient.AddMessageAsync(message);
 
-				Assert.Equal(message, response.Data.AddMessage.Content);
-		}
-	}
+            Assert.Equal(message, response.Data.AddMessage.Content);
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 95c18908..b7e4b2d8 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -2,13 +2,16 @@
 using GraphQL.Client.Serializer.Newtonsoft;
 using Newtonsoft.Json;
 
-namespace GraphQL.Client.Serializer.Tests {
-	public class NewtonsoftSerializerTest : BaseSerializerTest {
-		public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
-	}
+namespace GraphQL.Client.Serializer.Tests
+{
+    public class NewtonsoftSerializerTest : BaseSerializerTest
+    {
+        public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
+    }
 
-	public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
-		public NewtonsoftSerializeNoCamelCaseTest()
-			: base(new NewtonsoftJsonSerializer(new JsonSerializerSettings())) { }
-	}
+    public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
+    {
+        public NewtonsoftSerializeNoCamelCaseTest()
+            : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings())) { }
+    }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index 76f9ff78..217c9da1 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -1,13 +1,16 @@
 using System.Text.Json;
 using GraphQL.Client.Serializer.SystemTextJson;
 
-namespace GraphQL.Client.Serializer.Tests {
-	public class SystemTextJsonSerializerTests: BaseSerializerTest {
-		public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) { }
-	}
+namespace GraphQL.Client.Serializer.Tests
+{
+    public class SystemTextJsonSerializerTests : BaseSerializerTest
+    {
+        public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) { }
+    }
 
-	public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest {
-		public SystemTextJsonSerializeNoCamelCaseTest()
-			: base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupImmutableConverter())) { }
-	}
+    public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
+    {
+        public SystemTextJsonSerializeNoCamelCaseTest()
+            : base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupImmutableConverter())) { }
+    }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
index 61ebb0b0..0711780b 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -3,44 +3,48 @@
 using System.Collections.Generic;
 using System.Text;
 
-namespace GraphQL.Client.Serializer.Tests.TestData {
-	public class DeserializeResponseTestData : IEnumerable<object[]> {
-		public IEnumerator<object[]> GetEnumerator() {
-			// object array structure:
-			// [0]: input json
-			// [1]: expected deserialized response
+namespace GraphQL.Client.Serializer.Tests.TestData
+{
+    public class DeserializeResponseTestData : IEnumerable<object[]>
+    {
+        public IEnumerator<object[]> GetEnumerator()
+        {
+            // object array structure:
+            // [0]: input json
+            // [1]: expected deserialized response
 
-			yield return new object[] {
-				"{\"errors\":[{\"message\":\"Throttled\",\"extensions\":{\"code\":\"THROTTLED\",\"documentation\":\"https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits\"}}],\"extensions\":{\"cost\":{\"requestedQueryCost\":992,\"actualQueryCost\":null,\"throttleStatus\":{\"maximumAvailable\":1000,\"currentlyAvailable\":632,\"restoreRate\":50}}}}",
-				new GraphQLResponse<object> {
-					Data = null,
-					Errors = new[] {
-						new GraphQLError {
-							Message = "Throttled",
-							Extensions = new GraphQLExtensionsType {
-								{"code", "THROTTLED" },
-								{"documentation", "https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits" }
-							}
-						}
-					},
-					Extensions = new GraphQLExtensionsType {
-						{"cost", new Dictionary<string, object> {
-							{"requestedQueryCost", 992},
-							{"actualQueryCost", null},
-							{"throttleStatus", new Dictionary<string, object> {
-								{"maximumAvailable", 1000},
-								{"currentlyAvailable", 632},
-								{"restoreRate", 50}
-							}}
-						}}
-					}
-				}
-			};
-		}
+            yield return new object[] {
+                "{\"errors\":[{\"message\":\"Throttled\",\"extensions\":{\"code\":\"THROTTLED\",\"documentation\":\"https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits\"}}],\"extensions\":{\"cost\":{\"requestedQueryCost\":992,\"actualQueryCost\":null,\"throttleStatus\":{\"maximumAvailable\":1000,\"currentlyAvailable\":632,\"restoreRate\":50}}}}",
+                new GraphQLResponse<object> {
+                    Data = null,
+                    Errors = new[] {
+                        new GraphQLError {
+                            Message = "Throttled",
+                            Extensions = new GraphQLExtensionsType {
+                                {"code", "THROTTLED" },
+                                {"documentation", "https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits" }
+                            }
+                        }
+                    },
+                    Extensions = new GraphQLExtensionsType {
+                        {"cost", new Dictionary<string, object> {
+                            {"requestedQueryCost", 992},
+                            {"actualQueryCost", null},
+                            {"throttleStatus", new Dictionary<string, object> {
+                                {"maximumAvailable", 1000},
+                                {"currentlyAvailable", 632},
+                                {"restoreRate", 50}
+                            }}
+                        }}
+                    }
+                }
+            };
+        }
 
-		IEnumerator IEnumerable.GetEnumerator() {
-			return GetEnumerator();
-		}
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
 
-	}
+    }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
index a506cb6d..3a9e7369 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
@@ -3,30 +3,34 @@
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Tests.Common.Chat;
 
-namespace GraphQL.Client.Serializer.Tests.TestData {
-	public class SerializeToBytesTestData : IEnumerable<object[]> {
-		public IEnumerator<object[]> GetEnumerator() {
-			yield return new object[] {
-				"{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}}",
-				new GraphQLWebSocketRequest {
-					Id = "1234567",
-					Type = GraphQLWebSocketMessageType.GQL_START,
-					Payload = new GraphQLRequest("simplequerystring")
-				}
-			};
-			yield return new object[] {
-				"{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}}",
-				new GraphQLWebSocketRequest {
-					Id = "34476567",
-					Type = GraphQLWebSocketMessageType.GQL_START,
-					Payload = new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
-				}
-				
-			};
-		}
+namespace GraphQL.Client.Serializer.Tests.TestData
+{
+    public class SerializeToBytesTestData : IEnumerable<object[]>
+    {
+        public IEnumerator<object[]> GetEnumerator()
+        {
+            yield return new object[] {
+                "{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}}",
+                new GraphQLWebSocketRequest {
+                    Id = "1234567",
+                    Type = GraphQLWebSocketMessageType.GQL_START,
+                    Payload = new GraphQLRequest("simplequerystring")
+                }
+            };
+            yield return new object[] {
+                "{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}}",
+                new GraphQLWebSocketRequest {
+                    Id = "34476567",
+                    Type = GraphQLWebSocketMessageType.GQL_START,
+                    Payload = new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
+                }
 
-		IEnumerator IEnumerable.GetEnumerator() {
-			return GetEnumerator();
-		}
-	}
+            };
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 404fda64..55a94fdc 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -2,25 +2,29 @@
 using System.Collections.Generic;
 using GraphQL.Client.Tests.Common.Chat;
 
-namespace GraphQL.Client.Serializer.Tests.TestData {
-	public class SerializeToStringTestData : IEnumerable<object[]> {
-		public IEnumerator<object[]> GetEnumerator() {
-			yield return new object[] {
-				"{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}",
-				new GraphQLRequest("simple query string")
-			};
-			yield return new object[] {
-				"{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}",
-				new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
-			};
-			yield return new object[] {
-				"{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"authentication\":\"an-authentication-token\"}",
-				new GraphQLRequest("simple query string"){{"authentication", "an-authentication-token"}}
-			};
-		}
+namespace GraphQL.Client.Serializer.Tests.TestData
+{
+    public class SerializeToStringTestData : IEnumerable<object[]>
+    {
+        public IEnumerator<object[]> GetEnumerator()
+        {
+            yield return new object[] {
+                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}",
+                new GraphQLRequest("simple query string")
+            };
+            yield return new object[] {
+                "{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}",
+                new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
+            };
+            yield return new object[] {
+                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"authentication\":\"an-authentication-token\"}",
+                new GraphQLRequest("simple query string"){{"authentication", "an-authentication-token"}}
+            };
+        }
 
-		IEnumerator IEnumerable.GetEnumerator() {
-			return GetEnumerator();
-		}
-	}
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
index e3aaaf1c..385e537b 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
@@ -1,9 +1,11 @@
 namespace GraphQL.Client.Tests.Common.Chat
 {
-	public class AddMessageMutationResult {
-		public AddMessageContent AddMessage { get; set; }
-		public class AddMessageContent {
-			public string Content { get; set; }
-		}
-	}
+    public class AddMessageMutationResult
+    {
+        public AddMessageContent AddMessage { get; set; }
+        public class AddMessageContent
+        {
+            public string Content { get; set; }
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
index 129c5c2d..7bf021be 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
@@ -2,14 +2,17 @@
 using System.Collections.Generic;
 using System.Text;
 
-namespace GraphQL.Client.Tests.Common.Chat {
-	public class AddMessageVariables {
+namespace GraphQL.Client.Tests.Common.Chat
+{
+    public class AddMessageVariables
+    {
 
-		public AddMessageInput Input { get; set; }
-		public class AddMessageInput {
-			public string FromId { get; set; }
-			public string Content { get; set; }
-			public DateTime SentAt { get; set; }
-		}
-	}
+        public AddMessageInput Input { get; set; }
+        public class AddMessageInput
+        {
+            public string FromId { get; set; }
+            public string Content { get; set; }
+            public DateTime SentAt { get; set; }
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index f3d95cf7..5e21b479 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -2,41 +2,48 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 
-namespace GraphQL.Client.Tests.Common.Chat {
-	public static class GraphQLClientChatExtensions {
-		public const string AddMessageQuery =
+namespace GraphQL.Client.Tests.Common.Chat
+{
+    public static class GraphQLClientChatExtensions
+    {
+        public const string AddMessageQuery =
 @"mutation($input: MessageInputType){
   addMessage(message: $input){
     content
   }  
 }";
 
-		public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message) {
-			var variables = new AddMessageVariables {
-				Input = new AddMessageVariables.AddMessageInput {
-					FromId = "2",
-					Content = message,
-					SentAt = DateTime.Now
-				}
-			};
+        public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message)
+        {
+            var variables = new AddMessageVariables
+            {
+                Input = new AddMessageVariables.AddMessageInput
+                {
+                    FromId = "2",
+                    Content = message,
+                    SentAt = DateTime.Now
+                }
+            };
 
-			var graphQLRequest = new GraphQLRequest(AddMessageQuery, variables);
-			return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
-		}
+            var graphQLRequest = new GraphQLRequest(AddMessageQuery, variables);
+            return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
+        }
 
-		public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this IGraphQLClient client) {
-			var graphQLRequest = new GraphQLRequest(@"
+        public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this IGraphQLClient client)
+        {
+            var graphQLRequest = new GraphQLRequest(@"
 				mutation($userId: String){
 				  join(userId: $userId){
 				    displayName
 				    id
 				  }
 				}",
-				new {
-					userId = "1"
-				});
-			return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
-		}
+                new
+                {
+                    userId = "1"
+                });
+            return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
+        }
 
-	}
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
index 2807a5b2..c1b02444 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
@@ -1,10 +1,12 @@
 namespace GraphQL.Client.Tests.Common.Chat
 {
-	public class JoinDeveloperMutationResult {
-		public JoinContent Join { get; set; }
-		public class JoinContent {
-			public string DisplayName { get; set; }
-			public string Id { get; set; }
-		}
-	}
+    public class JoinDeveloperMutationResult
+    {
+        public JoinContent Join { get; set; }
+        public class JoinContent
+        {
+            public string DisplayName { get; set; }
+            public string Id { get; set; }
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
index ddcd1238..ecfeaf00 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
@@ -1,13 +1,16 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class CapitalizedFieldsGraphType: ObjectGraphType {
-		public CapitalizedFieldsGraphType() {
-			Name = "CapitalizedFields";
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class CapitalizedFieldsGraphType : ObjectGraphType
+    {
+        public CapitalizedFieldsGraphType()
+        {
+            Name = "CapitalizedFields";
 
-			Field<StringGraphType>()
-				.Name("StringField")
-				.Resolve(context => "hello world");
-		}
-	}
+            Field<StringGraphType>()
+                .Name("StringField")
+                .Resolve(context => "hello world");
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
index 384639ab..1d2cdd28 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
@@ -1,35 +1,42 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class ChatMutation : ObjectGraphType<object> {
-		public ChatMutation(IChat chat) {
-			Field<MessageType>("addMessage",
-				arguments: new QueryArguments(
-					new QueryArgument<MessageInputType> { Name = "message" }
-				),
-				resolve: context => {
-					var receivedMessage = context.GetArgument<ReceivedMessage>("message");
-					var message = chat.AddMessage(receivedMessage);
-					return message;
-				});
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class ChatMutation : ObjectGraphType<object>
+    {
+        public ChatMutation(IChat chat)
+        {
+            Field<MessageType>("addMessage",
+                arguments: new QueryArguments(
+                    new QueryArgument<MessageInputType> { Name = "message" }
+                ),
+                resolve: context =>
+                {
+                    var receivedMessage = context.GetArgument<ReceivedMessage>("message");
+                    var message = chat.AddMessage(receivedMessage);
+                    return message;
+                });
 
-			Field<MessageFromType>("join",
-				arguments: new QueryArguments(
-					new QueryArgument<StringGraphType> { Name = "userId" }
-				),
-				resolve: context => {
-					var userId = context.GetArgument<string>("userId");
-					var userJoined = chat.Join(userId);
-					return userJoined;
-				});
-		}
-	}
+            Field<MessageFromType>("join",
+                arguments: new QueryArguments(
+                    new QueryArgument<StringGraphType> { Name = "userId" }
+                ),
+                resolve: context =>
+                {
+                    var userId = context.GetArgument<string>("userId");
+                    var userJoined = chat.Join(userId);
+                    return userJoined;
+                });
+        }
+    }
 
-	public class MessageInputType : InputObjectGraphType {
-		public MessageInputType() {
-			Field<StringGraphType>("fromId");
-			Field<StringGraphType>("content");
-			Field<DateGraphType>("sentAt");
-		}
-	}
+    public class MessageInputType : InputObjectGraphType
+    {
+        public MessageInputType()
+        {
+            Field<StringGraphType>("fromId");
+            Field<StringGraphType>("content");
+            Field<DateGraphType>("sentAt");
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 0816fd8c..1e86e125 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -4,40 +4,45 @@
 using System.Threading;
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class ChatQuery : ObjectGraphType {
-
-		public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
-			{"extension1", "hello world"},
-			{"another extension", 4711}
-		};
-
-		// properties for unit testing
-
-		public readonly ManualResetEventSlim LongRunningQueryBlocker = new ManualResetEventSlim();
-		public readonly ManualResetEventSlim WaitingOnQueryBlocker = new ManualResetEventSlim();
-
-
-		public ChatQuery(IChat chat) {
-			Name = "ChatQuery";
-
-			Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
-
-			Field<StringGraphType>()
-				.Name("extensionsTest")
-				.Resolve(context => {
-					context.Errors.Add(new ExecutionError("this error contains extension fields", TestExtensions));
-					return null;
-				});
-
-			Field<StringGraphType>()
-				.Name("longRunning")
-				.Resolve(context => {
-					WaitingOnQueryBlocker.Set();
-					LongRunningQueryBlocker.Wait();
-					WaitingOnQueryBlocker.Reset();
-					return "finally returned";
-				});
-		}
-	}
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class ChatQuery : ObjectGraphType
+    {
+
+        public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
+            {"extension1", "hello world"},
+            {"another extension", 4711}
+        };
+
+        // properties for unit testing
+
+        public readonly ManualResetEventSlim LongRunningQueryBlocker = new ManualResetEventSlim();
+        public readonly ManualResetEventSlim WaitingOnQueryBlocker = new ManualResetEventSlim();
+
+
+        public ChatQuery(IChat chat)
+        {
+            Name = "ChatQuery";
+
+            Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+
+            Field<StringGraphType>()
+                .Name("extensionsTest")
+                .Resolve(context =>
+                {
+                    context.Errors.Add(new ExecutionError("this error contains extension fields", TestExtensions));
+                    return null;
+                });
+
+            Field<StringGraphType>()
+                .Name("longRunning")
+                .Resolve(context =>
+                {
+                    WaitingOnQueryBlocker.Set();
+                    LongRunningQueryBlocker.Wait();
+                    WaitingOnQueryBlocker.Reset();
+                    return "finally returned";
+                });
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
index 8ef13e43..49126f8a 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
@@ -1,10 +1,13 @@
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class ChatSchema : Types.Schema {
-		public ChatSchema(IDependencyResolver resolver)
-			: base(resolver) {
-			Query = resolver.Resolve<ChatQuery>();
-			Mutation = resolver.Resolve<ChatMutation>();
-			Subscription = resolver.Resolve<ChatSubscriptions>();
-		}
-	}
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class ChatSchema : Types.Schema
+    {
+        public ChatSchema(IDependencyResolver resolver)
+            : base(resolver)
+        {
+            Query = resolver.Resolve<ChatQuery>();
+            Mutation = resolver.Resolve<ChatMutation>();
+            Subscription = resolver.Resolve<ChatSubscriptions>();
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
index f7df7dd5..f0d08efb 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
@@ -7,81 +7,92 @@
 using GraphQL.Subscription;
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class ChatSubscriptions : ObjectGraphType<object> {
-		private readonly IChat _chat;
-
-		public ChatSubscriptions(IChat chat) {
-			_chat = chat;
-			AddField(new EventStreamFieldType {
-				Name = "messageAdded",
-				Type = typeof(MessageType),
-				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-				Subscriber = new EventStreamResolver<Message>(Subscribe)
-			});
-
-			AddField(new EventStreamFieldType {
-				Name = "contentAdded",
-				Type = typeof(MessageType),
-				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-				Subscriber = new EventStreamResolver<Message>(Subscribe)
-			});
-
-			AddField(new EventStreamFieldType {
-				Name = "messageAddedByUser",
-				Arguments = new QueryArguments(
-					new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id" }
-				),
-				Type = typeof(MessageType),
-				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-				Subscriber = new EventStreamResolver<Message>(SubscribeById)
-			});
-
-			AddField(new EventStreamFieldType {
-				Name = "userJoined",
-				Type = typeof(MessageFromType),
-				Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
-				Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
-			});
-
-
-			AddField(new EventStreamFieldType {
-				Name = "failImmediately",
-				Type = typeof(MessageType),
-				Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-				Subscriber = new EventStreamResolver<Message>(context => throw new NotSupportedException("this is supposed to fail"))
-			});
-		}
-
-		private IObservable<Message> SubscribeById(ResolveEventStreamContext context) {
-			var messageContext = context.UserContext.As<MessageHandlingContext>();
-			var user = messageContext.Get<ClaimsPrincipal>("user");
-
-			var sub = "Anonymous";
-			if (user != null)
-				sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
-
-			var messages = _chat.Messages(sub);
-
-			var id = context.GetArgument<string>("id");
-			return messages.Where(message => message.From.Id == id);
-		}
-
-		private Message ResolveMessage(ResolveFieldContext context) {
-			var message = context.Source as Message;
-
-			return message;
-		}
-
-		private IObservable<Message> Subscribe(ResolveEventStreamContext context) {
-			var messageContext = context.UserContext.As<MessageHandlingContext>();
-			var user = messageContext.Get<ClaimsPrincipal>("user");
-
-			var sub = "Anonymous";
-			if (user != null)
-				sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
-
-			return _chat.Messages(sub);
-		}
-	}
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class ChatSubscriptions : ObjectGraphType<object>
+    {
+        private readonly IChat _chat;
+
+        public ChatSubscriptions(IChat chat)
+        {
+            _chat = chat;
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAdded",
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(Subscribe)
+            });
+
+            AddField(new EventStreamFieldType
+            {
+                Name = "contentAdded",
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(Subscribe)
+            });
+
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAddedByUser",
+                Arguments = new QueryArguments(
+                    new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id" }
+                ),
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(SubscribeById)
+            });
+
+            AddField(new EventStreamFieldType
+            {
+                Name = "userJoined",
+                Type = typeof(MessageFromType),
+                Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
+                Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
+            });
+
+
+            AddField(new EventStreamFieldType
+            {
+                Name = "failImmediately",
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(context => throw new NotSupportedException("this is supposed to fail"))
+            });
+        }
+
+        private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            var messages = _chat.Messages(sub);
+
+            var id = context.GetArgument<string>("id");
+            return messages.Where(message => message.From.Id == id);
+        }
+
+        private Message ResolveMessage(ResolveFieldContext context)
+        {
+            var message = context.Source as Message;
+
+            return message;
+        }
+
+        private IObservable<Message> Subscribe(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            return _chat.Messages(sub);
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index 9ebfbd1a..c01810a8 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -3,91 +3,109 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public interface IChat {
-		ConcurrentStack<Message> AllMessages { get; }
-
-		Message AddMessage(Message message);
-
-		MessageFrom Join(string userId);
-
-		IObservable<Message> Messages(string user);
-		IObservable<MessageFrom> UserJoined();
-
-		Message AddMessage(ReceivedMessage message);
-	}
-	
-	public class Chat : IChat {
-		private readonly ISubject<Message> messageStream = new ReplaySubject<Message>(1);
-		private readonly ISubject<MessageFrom> userJoined = new Subject<MessageFrom>();
-
-		public Chat() {
-			AllMessages = new ConcurrentStack<Message>();
-			Users = new ConcurrentDictionary<string, string> {
-				["1"] = "developer",
-				["2"] = "tester"
-			};
-		}
-
-		public ConcurrentDictionary<string, string> Users { get; private set; }
-
-		public ConcurrentStack<Message> AllMessages { get; private set; }
-
-		public Message AddMessage(ReceivedMessage message) {
-			if (!Users.TryGetValue(message.FromId, out var displayName)) {
-				displayName = "(unknown)";
-			}
-
-			return AddMessage(new Message {
-				Content = message.Content,
-				SentAt = message.SentAt,
-				From = new MessageFrom {
-					DisplayName = displayName,
-					Id = message.FromId
-				}
-			});
-		}
-
-		public Message AddMessage(Message message) {
-			AllMessages.Push(message);
-			messageStream.OnNext(message);
-			return message;
-		}
-
-		public MessageFrom Join(string userId) {
-			if (!Users.TryGetValue(userId, out var displayName)) {
-				displayName = "(unknown)";
-			}
-
-			var joinedUser = new MessageFrom {
-				Id = userId,
-				DisplayName = displayName
-			};
-
-			userJoined.OnNext(joinedUser);
-			return joinedUser;
-		}
-
-		public IObservable<Message> Messages(string user) {
-			return messageStream
-				.Select(message => {
-					message.Sub = user;
-					return message;
-				})
-				.AsObservable();
-		}
-
-		public void AddError(Exception exception) {
-			messageStream.OnError(exception);
-		}
-
-		public IObservable<MessageFrom> UserJoined() {
-			return userJoined.AsObservable();
-		}
-	}
-
-	public class User {
-		public string Id { get; set; }
-		public string Name { get; set; }
-	}
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public interface IChat
+    {
+        ConcurrentStack<Message> AllMessages { get; }
+
+        Message AddMessage(Message message);
+
+        MessageFrom Join(string userId);
+
+        IObservable<Message> Messages(string user);
+        IObservable<MessageFrom> UserJoined();
+
+        Message AddMessage(ReceivedMessage message);
+    }
+
+    public class Chat : IChat
+    {
+        private readonly ISubject<Message> messageStream = new ReplaySubject<Message>(1);
+        private readonly ISubject<MessageFrom> userJoined = new Subject<MessageFrom>();
+
+        public Chat()
+        {
+            AllMessages = new ConcurrentStack<Message>();
+            Users = new ConcurrentDictionary<string, string>
+            {
+                ["1"] = "developer",
+                ["2"] = "tester"
+            };
+        }
+
+        public ConcurrentDictionary<string, string> Users { get; private set; }
+
+        public ConcurrentStack<Message> AllMessages { get; private set; }
+
+        public Message AddMessage(ReceivedMessage message)
+        {
+            if (!Users.TryGetValue(message.FromId, out var displayName))
+            {
+                displayName = "(unknown)";
+            }
+
+            return AddMessage(new Message
+            {
+                Content = message.Content,
+                SentAt = message.SentAt,
+                From = new MessageFrom
+                {
+                    DisplayName = displayName,
+                    Id = message.FromId
+                }
+            });
+        }
+
+        public Message AddMessage(Message message)
+        {
+            AllMessages.Push(message);
+            messageStream.OnNext(message);
+            return message;
+        }
+
+        public MessageFrom Join(string userId)
+        {
+            if (!Users.TryGetValue(userId, out var displayName))
+            {
+                displayName = "(unknown)";
+            }
+
+            var joinedUser = new MessageFrom
+            {
+                Id = userId,
+                DisplayName = displayName
+            };
+
+            userJoined.OnNext(joinedUser);
+            return joinedUser;
+        }
+
+        public IObservable<Message> Messages(string user)
+        {
+            return messageStream
+                .Select(message =>
+                {
+                    message.Sub = user;
+                    return message;
+                })
+                .AsObservable();
+        }
+
+        public void AddError(Exception exception)
+        {
+            messageStream.OnError(exception);
+        }
+
+        public IObservable<MessageFrom> UserJoined()
+        {
+            return userJoined.AsObservable();
+        }
+    }
+
+    public class User
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
index 1b68c7e4..345a397e 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
@@ -1,13 +1,15 @@
 using System;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class Message {
-		public MessageFrom From { get; set; }
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class Message
+    {
+        public MessageFrom From { get; set; }
 
-		public string Sub { get; set; }
+        public string Sub { get; set; }
 
-		public string Content { get; set; }
+        public string Content { get; set; }
 
-		public DateTime SentAt { get; set; }
-	}
+        public DateTime SentAt { get; set; }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
index b6bc81a4..203f979b 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
@@ -1,7 +1,9 @@
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class MessageFrom {
-		public string Id { get; set; }
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class MessageFrom
+    {
+        public string Id { get; set; }
 
-		public string DisplayName { get; set; }
-	}
+        public string DisplayName { get; set; }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
index 4d82c69e..045e473b 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
@@ -1,10 +1,13 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class MessageFromType : ObjectGraphType<MessageFrom> {
-		public MessageFromType() {
-			Field(o => o.Id);
-			Field(o => o.DisplayName);
-		}
-	}
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class MessageFromType : ObjectGraphType<MessageFrom>
+    {
+        public MessageFromType()
+        {
+            Field(o => o.Id);
+            Field(o => o.DisplayName);
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
index c5172cf3..2636390c 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
@@ -1,17 +1,21 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class MessageType : ObjectGraphType<Message> {
-		public MessageType() {
-			Field(o => o.Content);
-			Field(o => o.SentAt);
-			Field(o => o.Sub);
-			Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
-		}
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class MessageType : ObjectGraphType<Message>
+    {
+        public MessageType()
+        {
+            Field(o => o.Content);
+            Field(o => o.SentAt);
+            Field(o => o.Sub);
+            Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
+        }
 
-		private MessageFrom ResolveFrom(ResolveFieldContext<Message> context) {
-			var message = context.Source;
-			return message.From;
-		}
-	}
+        private MessageFrom ResolveFrom(ResolveFieldContext<Message> context)
+        {
+            var message = context.Source;
+            return message.From;
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
index ab1b05f8..9cf72c9b 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
@@ -1,11 +1,13 @@
 using System;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema {
-	public class ReceivedMessage {
-		public string FromId { get; set; }
+namespace GraphQL.Client.Tests.Common.Chat.Schema
+{
+    public class ReceivedMessage
+    {
+        public string FromId { get; set; }
 
-		public string Content { get; set; }
+        public string Content { get; set; }
 
-		public DateTime SentAt { get; set; }
-	}
+        public DateTime SentAt { get; set; }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
index 05673f23..4056110b 100644
--- a/tests/GraphQL.Client.Tests.Common/Common.cs
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -5,46 +5,51 @@
 
 namespace GraphQL.Client.Tests.Common
 {
-    public static class Common {
-	    public const string StarWarsEndpoint = "/graphql/starwars";
-	    public const string ChatEndpoint = "/graphql/chat";
+    public static class Common
+    {
+        public const string StarWarsEndpoint = "/graphql/starwars";
+        public const string ChatEndpoint = "/graphql/chat";
 
-		public static StarWarsSchema GetStarWarsSchema() {
-			var services = new ServiceCollection();
-			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
-			services.AddStarWarsSchema();
-			return services.BuildServiceProvider().GetRequiredService<StarWarsSchema>();
-		}
-		public static ChatSchema GetChatSchema() {
-			var services = new ServiceCollection();
-			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
-			services.AddChatSchema();
-			return services.BuildServiceProvider().GetRequiredService<ChatSchema>();
-		}
+        public static StarWarsSchema GetStarWarsSchema()
+        {
+            var services = new ServiceCollection();
+            services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
+            services.AddStarWarsSchema();
+            return services.BuildServiceProvider().GetRequiredService<StarWarsSchema>();
+        }
+        public static ChatSchema GetChatSchema()
+        {
+            var services = new ServiceCollection();
+            services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
+            services.AddChatSchema();
+            return services.BuildServiceProvider().GetRequiredService<ChatSchema>();
+        }
 
-		public static void AddStarWarsSchema(this IServiceCollection services) {
-		    services.AddSingleton<StarWarsData>();
-		    services.AddSingleton<StarWarsQuery>();
-		    services.AddSingleton<StarWarsMutation>();
-		    services.AddSingleton<StarWarsSchema>();
-		    services.AddTransient<CharacterInterface>();
-		    services.AddTransient<DroidType>();
-		    services.AddTransient<EpisodeEnum>();
-		    services.AddTransient<HumanType>();
-		    services.AddTransient<HumanInputType>();
-		}
-		
-	    public static void AddChatSchema(this IServiceCollection services) {
-		    var chat = new Chat.Schema.Chat();
-		    services.AddSingleton(chat);
-		    services.AddSingleton<IChat>(chat);
-			services.AddSingleton<ChatSchema>();
-		    services.AddSingleton<ChatQuery>();
-		    services.AddSingleton<ChatMutation>();
-		    services.AddSingleton<ChatSubscriptions>();
-		    services.AddSingleton<MessageType>();
-		    services.AddSingleton<MessageInputType>();
-		    services.AddSingleton<MessageFromType>();
-		}
+        public static void AddStarWarsSchema(this IServiceCollection services)
+        {
+            services.AddSingleton<StarWarsData>();
+            services.AddSingleton<StarWarsQuery>();
+            services.AddSingleton<StarWarsMutation>();
+            services.AddSingleton<StarWarsSchema>();
+            services.AddTransient<CharacterInterface>();
+            services.AddTransient<DroidType>();
+            services.AddTransient<EpisodeEnum>();
+            services.AddTransient<HumanType>();
+            services.AddTransient<HumanInputType>();
+        }
+
+        public static void AddChatSchema(this IServiceCollection services)
+        {
+            var chat = new Chat.Schema.Chat();
+            services.AddSingleton(chat);
+            services.AddSingleton<IChat>(chat);
+            services.AddSingleton<ChatSchema>();
+            services.AddSingleton<ChatQuery>();
+            services.AddSingleton<ChatMutation>();
+            services.AddSingleton<ChatSubscriptions>();
+            services.AddSingleton<MessageType>();
+            services.AddSingleton<MessageInputType>();
+            services.AddSingleton<MessageFromType>();
+        }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
index 637c5861..c8095014 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
@@ -4,21 +4,25 @@
 using System.Linq;
 using GraphQL.Client.Abstractions;
 
-namespace GraphQL.Client.Tests.Common.Helpers {
-	public class AvailableJsonSerializers<TSerializerInterface> : IEnumerable<object[]> where TSerializerInterface : IGraphQLJsonSerializer {
-		public IEnumerator<object[]> GetEnumerator() {
-				// try to find one in the assembly and assign that
-				var type = typeof(TSerializerInterface);
-				return AppDomain.CurrentDomain
-					.GetAssemblies()
-					.SelectMany(s => s.GetTypes())
-					.Where(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract)
-					.Select(serializerType => new object[]{Activator.CreateInstance(serializerType)})
-					.GetEnumerator();
-		}
+namespace GraphQL.Client.Tests.Common.Helpers
+{
+    public class AvailableJsonSerializers<TSerializerInterface> : IEnumerable<object[]> where TSerializerInterface : IGraphQLJsonSerializer
+    {
+        public IEnumerator<object[]> GetEnumerator()
+        {
+            // try to find one in the assembly and assign that
+            var type = typeof(TSerializerInterface);
+            return AppDomain.CurrentDomain
+                .GetAssemblies()
+                .SelectMany(s => s.GetTypes())
+                .Where(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract)
+                .Select(serializerType => new object[] { Activator.CreateInstance(serializerType) })
+                .GetEnumerator();
+        }
 
-		IEnumerator IEnumerable.GetEnumerator() {
-			return GetEnumerator();
-		}
-	}
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index 2a27a259..2e638fc3 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -5,84 +5,94 @@
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 
-namespace GraphQL.Client.Tests.Common.Helpers {
-	public class CallbackMonitor<T> {
-		private readonly ManualResetEventSlim callbackInvoked = new ManualResetEventSlim();
+namespace GraphQL.Client.Tests.Common.Helpers
+{
+    public class CallbackMonitor<T>
+    {
+        private readonly ManualResetEventSlim callbackInvoked = new ManualResetEventSlim();
 
-		/// <summary>
-		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
-		/// </summary>
-		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+        /// <summary>
+        /// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+        /// </summary>
+        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
-		/// <summary>
-		/// Indicates that an update has been received since the last <see cref="Reset"/>
-		/// </summary>
-		public bool CallbackInvoked => callbackInvoked.IsSet;
-		/// <summary>
-		/// The last payload which was received.
-		/// </summary>
-		public T LastPayload { get; private set; }
+        /// <summary>
+        /// Indicates that an update has been received since the last <see cref="Reset"/>
+        /// </summary>
+        public bool CallbackInvoked => callbackInvoked.IsSet;
+        /// <summary>
+        /// The last payload which was received.
+        /// </summary>
+        public T LastPayload { get; private set; }
 
-		public void Invoke(T param) {
-			LastPayload = param;
-			Debug.WriteLine($"CallbackMonitor invoke handler thread id: {Thread.CurrentThread.ManagedThreadId}");
-			callbackInvoked.Set();
-		}
-		
-		/// <summary>
-		/// Resets the tester class. Should be called before triggering the potential update
-		/// </summary>
-		public void Reset() {
-			LastPayload = default(T);
-			callbackInvoked.Reset();
-		}
-		
-		public CallbackAssertions<T> Should() {
-			return new CallbackAssertions<T>(this);
-		}
+        public void Invoke(T param)
+        {
+            LastPayload = param;
+            Debug.WriteLine($"CallbackMonitor invoke handler thread id: {Thread.CurrentThread.ManagedThreadId}");
+            callbackInvoked.Set();
+        }
 
-		public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>> {
-			public CallbackAssertions(CallbackMonitor<TPayload> tester) {
-				Subject = tester;
-			}
+        /// <summary>
+        /// Resets the tester class. Should be called before triggering the potential update
+        /// </summary>
+        public void Reset()
+        {
+            LastPayload = default(T);
+            callbackInvoked.Reset();
+        }
 
-			protected override string Identifier => "callback";
+        public CallbackAssertions<T> Should()
+        {
+            return new CallbackAssertions<T>(this);
+        }
 
-			public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(TimeSpan timeout,
-				string because = "", params object[] becauseArgs) {
-				Execute.Assertion
-					.BecauseOf(because, becauseArgs)
-					.Given(() => {
-						Debug.WriteLine($"HaveBeenInvokedWithPayload thread id: {Thread.CurrentThread.ManagedThreadId}");
-						return Subject.callbackInvoked.Wait(timeout);
-					})
-					.ForCondition(isSet => isSet)
-					.FailWith("Expected {context:callback} to be invoked{reason}, but did not receive a call within {0}", timeout);
+        public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>>
+        {
+            public CallbackAssertions(CallbackMonitor<TPayload> tester)
+            {
+                Subject = tester;
+            }
 
-				Subject.callbackInvoked.Reset();
-				return new AndWhichConstraint<CallbackAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
-			}
-			public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(string because = "", params object[] becauseArgs)
-				=> HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
+            protected override string Identifier => "callback";
 
-			public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(TimeSpan timeout, string because = "", params object[] becauseArgs)
-				=> HaveBeenInvokedWithPayload(timeout, because, becauseArgs);
-			public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(string because = "", params object[] becauseArgs)
-				=> HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
+            public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(TimeSpan timeout,
+                string because = "", params object[] becauseArgs)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .Given(() =>
+                    {
+                        Debug.WriteLine($"HaveBeenInvokedWithPayload thread id: {Thread.CurrentThread.ManagedThreadId}");
+                        return Subject.callbackInvoked.Wait(timeout);
+                    })
+                    .ForCondition(isSet => isSet)
+                    .FailWith("Expected {context:callback} to be invoked{reason}, but did not receive a call within {0}", timeout);
 
-			public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(TimeSpan timeout,
-				string because = "", params object[] becauseArgs) {
-				Execute.Assertion
-					.BecauseOf(because, becauseArgs)
-					.Given(() => Subject.callbackInvoked.Wait(timeout))
-					.ForCondition(isSet => !isSet)
-					.FailWith("Expected {context:callback} to not be invoked{reason}, but did receive a call: {0}", Subject.LastPayload);
+                Subject.callbackInvoked.Reset();
+                return new AndWhichConstraint<CallbackAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
+            }
+            public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(string because = "", params object[] becauseArgs)
+                => HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
 
-				Subject.callbackInvoked.Reset();
-				return new AndConstraint<CallbackAssertions<TPayload>>(this);
-			}
-			public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(string because = "", params object[] becauseArgs)
-				=> NotHaveBeenInvoked(TimeSpan.FromMilliseconds(100), because, becauseArgs);
-		}
-	}
+            public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(TimeSpan timeout, string because = "", params object[] becauseArgs)
+                => HaveBeenInvokedWithPayload(timeout, because, becauseArgs);
+            public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(string because = "", params object[] becauseArgs)
+                => HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
+
+            public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(TimeSpan timeout,
+                string because = "", params object[] becauseArgs)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .Given(() => Subject.callbackInvoked.Wait(timeout))
+                    .ForCondition(isSet => !isSet)
+                    .FailWith("Expected {context:callback} to not be invoked{reason}, but did receive a call: {0}", Subject.LastPayload);
+
+                Subject.callbackInvoked.Reset();
+                return new AndConstraint<CallbackAssertions<TPayload>>(this);
+            }
+            public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(string because = "", params object[] becauseArgs)
+                => NotHaveBeenInvoked(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
index 64ea0554..992ca21e 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
@@ -1,54 +1,65 @@
 using System;
 using System.Threading.Tasks;
 
-namespace GraphQL.Client.Tests.Common.Helpers {
+namespace GraphQL.Client.Tests.Common.Helpers
+{
 
-	public class ConcurrentTaskWrapper {
-		public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) {
-			return  new ConcurrentTaskWrapper<TResult>(createTask);
-		}
+    public class ConcurrentTaskWrapper
+    {
+        public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask)
+        {
+            return new ConcurrentTaskWrapper<TResult>(createTask);
+        }
 
-		private readonly Func<Task> createTask;
-		private Task internalTask = null;
+        private readonly Func<Task> createTask;
+        private Task internalTask = null;
 
-		public ConcurrentTaskWrapper(Func<Task> createTask) {
-			this.createTask = createTask;
-		}
+        public ConcurrentTaskWrapper(Func<Task> createTask)
+        {
+            this.createTask = createTask;
+        }
 
-		public Task Invoke() {
-			if (internalTask != null)
-				return internalTask;
+        public Task Invoke()
+        {
+            if (internalTask != null)
+                return internalTask;
 
-			return internalTask = createTask();
-		}
-	}
+            return internalTask = createTask();
+        }
+    }
 
-	public class ConcurrentTaskWrapper<TResult> {
-		private readonly Func<Task<TResult>> createTask;
-		private Task<TResult> internalTask = null;
+    public class ConcurrentTaskWrapper<TResult>
+    {
+        private readonly Func<Task<TResult>> createTask;
+        private Task<TResult> internalTask = null;
 
-		public ConcurrentTaskWrapper(Func<Task<TResult>> createTask) {
-			this.createTask = createTask;
-		}
+        public ConcurrentTaskWrapper(Func<Task<TResult>> createTask)
+        {
+            this.createTask = createTask;
+        }
 
-		public Task<TResult> Invoke() {
-			if (internalTask != null)
-				return internalTask;
+        public Task<TResult> Invoke()
+        {
+            if (internalTask != null)
+                return internalTask;
 
-			return internalTask = createTask();
-		}
+            return internalTask = createTask();
+        }
 
-		public void Start() {
-			if (internalTask == null)
-				internalTask = createTask();
-		}
+        public void Start()
+        {
+            if (internalTask == null)
+                internalTask = createTask();
+        }
 
-		public Func<Task<TResult>> Invoking() {
-			return Invoke;
-		}
+        public Func<Task<TResult>> Invoking()
+        {
+            return Invoke;
+        }
 
-		public void Clear() {
-			internalTask = null;
-		}
-	}
+        public void Clear()
+        {
+            internalTask = null;
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
index 0e254672..7768d0b2 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
@@ -2,24 +2,29 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
 
-namespace GraphQL.Client.Tests.Common.Helpers {
-	public static class MiscellaneousExtensions {
-		public static string RemoveWhitespace(this string input) {
-			return new string(input.ToCharArray()
-				.Where(c => !char.IsWhiteSpace(c))
-				.ToArray());
-		}
+namespace GraphQL.Client.Tests.Common.Helpers
+{
+    public static class MiscellaneousExtensions
+    {
+        public static string RemoveWhitespace(this string input)
+        {
+            return new string(input.ToCharArray()
+                .Where(c => !char.IsWhiteSpace(c))
+                .ToArray());
+        }
 
-		public static CallbackMonitor<GraphQLHttpClient> ConfigureMonitorForOnWebsocketConnected(
-			this GraphQLHttpClient client) {
-			var tester = new CallbackMonitor<GraphQLHttpClient>();
-			client.Options.OnWebsocketConnected = c => {
-				tester.Invoke(c);
-				return Task.CompletedTask;
-			};
-			return tester;
-		}
+        public static CallbackMonitor<GraphQLHttpClient> ConfigureMonitorForOnWebsocketConnected(
+            this GraphQLHttpClient client)
+        {
+            var tester = new CallbackMonitor<GraphQLHttpClient>();
+            client.Options.OnWebsocketConnected = c =>
+            {
+                tester.Invoke(c);
+                return Task.CompletedTask;
+            };
+            return tester;
+        }
 
 
-	}
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
index ec08de02..c55eed75 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
@@ -1,14 +1,17 @@
 using System.Net;
 using System.Net.Sockets;
 
-namespace GraphQL.Client.Tests.Common.Helpers {
-	public static class NetworkHelpers {
-		public static int GetFreeTcpPortNumber() {
-			var l = new TcpListener(IPAddress.Loopback, 0);
-			l.Start();
-			var port = ((IPEndPoint)l.LocalEndpoint).Port;
-			l.Stop();
-			return port;
-		}
-	}
+namespace GraphQL.Client.Tests.Common.Helpers
+{
+    public static class NetworkHelpers
+    {
+        public static int GetFreeTcpPortNumber()
+        {
+            var l = new TcpListener(IPAddress.Loopback, 0);
+            l.Start();
+            var port = ((IPEndPoint)l.LocalEndpoint).Port;
+            l.Stop();
+            return port;
+        }
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 05ed7e38..a9cd3cd3 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -7,159 +7,178 @@
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 
-namespace GraphQL.Client.Tests.Common.Helpers {
-	public class ObservableTester<TSubscriptionPayload> : IDisposable {
-		private readonly IDisposable subscription;
-		private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
-		private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
-		private readonly ManualResetEventSlim error = new ManualResetEventSlim();
-		private readonly EventLoopScheduler observeScheduler = new EventLoopScheduler();
-
-		/// <summary>
-		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
-		/// </summary>
-		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
-
-		/// <summary>
-		/// Indicates that an update has been received since the last <see cref="_reset"/>
-		/// </summary>
-		public bool UpdateReceived => updateReceived.IsSet;
-		/// <summary>
-		/// The last payload which was received.
-		/// </summary>
-		public TSubscriptionPayload LastPayload { get; private set; }
-
-		public Exception Error { get; private set; }
-
-		/// <summary>
-		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
-		/// </summary>
-		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
-		public ObservableTester(IObservable<TSubscriptionPayload> observable) {
-
-			observeScheduler.Schedule(() =>
-				Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
-
-			subscription = observable.ObserveOn(observeScheduler).Subscribe(
-				obj => {
-					Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
-					LastPayload = obj;
-					updateReceived.Set();
-				},
-				ex => {
-					Debug.WriteLine($"observable tester {GetHashCode()} error received: {ex}");
-					Error = ex;
-					error.Set();
-				},
-				() => {
-					Debug.WriteLine($"observable tester {GetHashCode()}: completed");
-					completed.Set();
-				});
-		}
-
-		/// <summary>
-		/// Resets the tester class. Should be called before triggering the potential update
-		/// </summary>
-		private void Reset() {
-			updateReceived.Reset();
-		}
-
-		/// <inheritdoc />
-		public void Dispose() {
-			subscription?.Dispose();
-			observeScheduler.Dispose();
-		}
-
-		public SubscriptionAssertions<TSubscriptionPayload> Should() {
-			return new SubscriptionAssertions<TSubscriptionPayload>(this);
-		}
-
-		public class SubscriptionAssertions<TPayload> : ReferenceTypeAssertions<ObservableTester<TPayload>, SubscriptionAssertions<TPayload>> {
-			public SubscriptionAssertions(ObservableTester<TPayload> tester) {
-				Subject = tester;
-			}
-
-			protected override string Identifier => "Subscription";
-
-			public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(TimeSpan timeout,
-				string because = "", params object[] becauseArgs) {
-				Execute.Assertion
-					.BecauseOf(because, becauseArgs)
-					.Given(() => {
-						var isSet = Subject.updateReceived.Wait(timeout);
-						if(!isSet)
-							Debug.WriteLine($"waiting for payload on thread {Thread.CurrentThread.ManagedThreadId} timed out!");
-						return isSet;
-					})
-					.ForCondition(isSet => isSet)
-					.FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
-
-				Subject.updateReceived.Reset();
-				return new AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
-			}
-			public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(string because = "", params object[] becauseArgs)
-				=> HaveReceivedPayload(Subject.Timeout, because, becauseArgs);
-
-			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(TimeSpan timeout,
-				string because = "", params object[] becauseArgs) {
-				Execute.Assertion
-					.BecauseOf(because, becauseArgs)
-					.Given(() => Subject.updateReceived.Wait(timeout))
-					.ForCondition(isSet => !isSet)
-					.FailWith("Expected {context:Subscription} to not receive a new payload{reason}, but did receive an update: {0}", Subject.LastPayload);
-
-				Subject.updateReceived.Reset();
-				return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
-			}
-			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(string because = "", params object[] becauseArgs)
-				=> NotHaveReceivedPayload(TimeSpan.FromMilliseconds(100), because, becauseArgs);
-
-			public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(TimeSpan timeout,
-				string because = "", params object[] becauseArgs) {
-				Execute.Assertion
-					.BecauseOf(because, becauseArgs)
-					.Given(() => Subject.error.Wait(timeout))
-					.ForCondition(isSet => isSet)
-					.FailWith("Expected {context:Subscription} to fail{reason}, but did not receive an error within {0}", timeout);
-
-				return new AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception>(this, Subject.Error);
-			}
-			public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(string because = "", params object[] becauseArgs)
-				=> HaveReceivedError(Subject.Timeout, because, becauseArgs);
-
-
-			public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(TimeSpan timeout,
-				string because = "", params object[] becauseArgs) {
-				Execute.Assertion
-					.BecauseOf(because, becauseArgs)
-					.Given(() => Subject.completed.Wait(timeout))
-					.ForCondition(isSet => isSet)
-					.FailWith("Expected {context:Subscription} to complete{reason}, but did not complete within {0}", timeout);
-
-				return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
-			}
-			public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(string because = "", params object[] becauseArgs)
-				=> HaveCompleted(Subject.Timeout, because, becauseArgs);
-
-			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(TimeSpan timeout,
-				string because = "", params object[] becauseArgs) {
-				Execute.Assertion
-					.BecauseOf(because, becauseArgs)
-					.Given(() => Subject.completed.Wait(timeout))
-					.ForCondition(isSet => !isSet)
-					.FailWith("Expected {context:Subscription} not to complete within {0}{reason}, but it did!", timeout);
-
-				return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
-			}
-			public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(string because = "", params object[] becauseArgs)
-				=> NotHaveCompleted(Subject.Timeout, because, becauseArgs);
-		}
-	}
-
-	public static class ObservableExtensions {
-		public static ObservableTester<T> Monitor<T>(this IObservable<T> observable) {
-			return new ObservableTester<T>(observable);
-		}
-	}
+namespace GraphQL.Client.Tests.Common.Helpers
+{
+    public class ObservableTester<TSubscriptionPayload> : IDisposable
+    {
+        private readonly IDisposable subscription;
+        private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim error = new ManualResetEventSlim();
+        private readonly EventLoopScheduler observeScheduler = new EventLoopScheduler();
+
+        /// <summary>
+        /// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+        /// </summary>
+        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
+
+        /// <summary>
+        /// Indicates that an update has been received since the last <see cref="_reset"/>
+        /// </summary>
+        public bool UpdateReceived => updateReceived.IsSet;
+        /// <summary>
+        /// The last payload which was received.
+        /// </summary>
+        public TSubscriptionPayload LastPayload { get; private set; }
+
+        public Exception Error { get; private set; }
+
+        /// <summary>
+        /// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
+        /// </summary>
+        /// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
+        public ObservableTester(IObservable<TSubscriptionPayload> observable)
+        {
+
+            observeScheduler.Schedule(() =>
+                Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
+
+            subscription = observable.ObserveOn(observeScheduler).Subscribe(
+                obj =>
+                {
+                    Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
+                    LastPayload = obj;
+                    updateReceived.Set();
+                },
+                ex =>
+                {
+                    Debug.WriteLine($"observable tester {GetHashCode()} error received: {ex}");
+                    Error = ex;
+                    error.Set();
+                },
+                () =>
+                {
+                    Debug.WriteLine($"observable tester {GetHashCode()}: completed");
+                    completed.Set();
+                });
+        }
+
+        /// <summary>
+        /// Resets the tester class. Should be called before triggering the potential update
+        /// </summary>
+        private void Reset()
+        {
+            updateReceived.Reset();
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            subscription?.Dispose();
+            observeScheduler.Dispose();
+        }
+
+        public SubscriptionAssertions<TSubscriptionPayload> Should()
+        {
+            return new SubscriptionAssertions<TSubscriptionPayload>(this);
+        }
+
+        public class SubscriptionAssertions<TPayload> : ReferenceTypeAssertions<ObservableTester<TPayload>, SubscriptionAssertions<TPayload>>
+        {
+            public SubscriptionAssertions(ObservableTester<TPayload> tester)
+            {
+                Subject = tester;
+            }
+
+            protected override string Identifier => "Subscription";
+
+            public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(TimeSpan timeout,
+                string because = "", params object[] becauseArgs)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .Given(() =>
+                    {
+                        var isSet = Subject.updateReceived.Wait(timeout);
+                        if (!isSet)
+                            Debug.WriteLine($"waiting for payload on thread {Thread.CurrentThread.ManagedThreadId} timed out!");
+                        return isSet;
+                    })
+                    .ForCondition(isSet => isSet)
+                    .FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
+
+                Subject.updateReceived.Reset();
+                return new AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
+            }
+            public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(string because = "", params object[] becauseArgs)
+                => HaveReceivedPayload(Subject.Timeout, because, becauseArgs);
+
+            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(TimeSpan timeout,
+                string because = "", params object[] becauseArgs)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .Given(() => Subject.updateReceived.Wait(timeout))
+                    .ForCondition(isSet => !isSet)
+                    .FailWith("Expected {context:Subscription} to not receive a new payload{reason}, but did receive an update: {0}", Subject.LastPayload);
+
+                Subject.updateReceived.Reset();
+                return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
+            }
+            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(string because = "", params object[] becauseArgs)
+                => NotHaveReceivedPayload(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+
+            public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(TimeSpan timeout,
+                string because = "", params object[] becauseArgs)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .Given(() => Subject.error.Wait(timeout))
+                    .ForCondition(isSet => isSet)
+                    .FailWith("Expected {context:Subscription} to fail{reason}, but did not receive an error within {0}", timeout);
+
+                return new AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception>(this, Subject.Error);
+            }
+            public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(string because = "", params object[] becauseArgs)
+                => HaveReceivedError(Subject.Timeout, because, becauseArgs);
+
+
+            public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(TimeSpan timeout,
+                string because = "", params object[] becauseArgs)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .Given(() => Subject.completed.Wait(timeout))
+                    .ForCondition(isSet => isSet)
+                    .FailWith("Expected {context:Subscription} to complete{reason}, but did not complete within {0}", timeout);
+
+                return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
+            }
+            public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(string because = "", params object[] becauseArgs)
+                => HaveCompleted(Subject.Timeout, because, becauseArgs);
+
+            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(TimeSpan timeout,
+                string because = "", params object[] becauseArgs)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .Given(() => Subject.completed.Wait(timeout))
+                    .ForCondition(isSet => !isSet)
+                    .FailWith("Expected {context:Subscription} not to complete within {0}{reason}, but it did!", timeout);
+
+                return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
+            }
+            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(string because = "", params object[] becauseArgs)
+                => NotHaveCompleted(Subject.Timeout, because, becauseArgs);
+        }
+    }
+
+    public static class ObservableExtensions
+    {
+        public static ObservableTester<T> Monitor<T>(this IObservable<T> observable)
+        {
+            return new ObservableTester<T>(observable);
+        }
+    }
 
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
index 44a9f6bd..9349e813 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
@@ -1,15 +1,19 @@
 using System.Collections;
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Tests.Common.StarWars {
-	public class StarWarsHumans: IEnumerable<object[]> {
-		public IEnumerator<object[]> GetEnumerator() {
-			yield return new object[] { 1, "Luke" };
-			yield return new object[] { 2, "Vader" };
-		}
+namespace GraphQL.Client.Tests.Common.StarWars
+{
+    public class StarWarsHumans : IEnumerable<object[]>
+    {
+        public IEnumerator<object[]> GetEnumerator()
+        {
+            yield return new object[] { 1, "Luke" };
+            yield return new object[] { 2, "Vader" };
+        }
 
-		IEnumerator IEnumerable.GetEnumerator() {
-			return GetEnumerator();
-		}
-	}
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
index de4848fc..546b6a8e 100644
--- a/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
@@ -2,15 +2,18 @@
 using GraphQL.Client.Http;
 using Microsoft.AspNetCore.Mvc.Testing;
 
-namespace GraphQL.Integration.Tests.Extensions {
-	public static class WebApplicationFactoryExtensions {
-		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
-			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint : class {
-			var httpClient = factory.CreateClient();
-			var uriBuilder = new UriBuilder(httpClient.BaseAddress);
-			uriBuilder.Path = graphQlSchemaUrl;
-			uriBuilder.Scheme = urlScheme;
-			return httpClient.AsGraphQLClient(uriBuilder.Uri);
-		}
-	}
+namespace GraphQL.Integration.Tests.Extensions
+{
+    public static class WebApplicationFactoryExtensions
+    {
+        public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
+            this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint : class
+        {
+            var httpClient = factory.CreateClient();
+            var uriBuilder = new UriBuilder(httpClient.BaseAddress);
+            uriBuilder.Path = graphQlSchemaUrl;
+            uriBuilder.Scheme = urlScheme;
+            return httpClient.AsGraphQLClient(uriBuilder.Uri);
+        }
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index e8344a13..9f5b37bb 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -8,49 +8,57 @@
 using GraphQL.Client.Tests.Common.Helpers;
 using Microsoft.AspNetCore.Hosting;
 
-namespace GraphQL.Integration.Tests.Helpers {
-	public abstract class IntegrationServerTestFixture {
-		public int Port { get; private set; }
-		public IWebHost Server { get; private set; }
-		public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
-
-		public IntegrationServerTestFixture()
-		{
-			Port = NetworkHelpers.GetFreeTcpPortNumber();
-		}
-
-		public async Task CreateServer() {
-			if (Server != null) return;
-			Server = await WebHostHelpers.CreateServer(Port);
-		}
-
-		public async Task ShutdownServer() {
-			if (Server == null)
-				return;
-
-			await Server.StopAsync();
-			Server.Dispose();
-			Server = null;
-		}
-
-		public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-			=> GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
-
-		public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-			=> GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
-
-		private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) {
-			if(Serializer == null)
-				throw new InvalidOperationException("JSON serializer not configured");
-			return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer);
-		}
-	}
-
-	public class NewtonsoftIntegrationServerTestFixture: IntegrationServerTestFixture {
-		public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new NewtonsoftJsonSerializer();
-	}
-
-	public class SystemTextJsonIntegrationServerTestFixture : IntegrationServerTestFixture {
-		public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
-	}
+namespace GraphQL.Integration.Tests.Helpers
+{
+    public abstract class IntegrationServerTestFixture
+    {
+        public int Port { get; private set; }
+        public IWebHost Server { get; private set; }
+        public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
+
+        public IntegrationServerTestFixture()
+        {
+            Port = NetworkHelpers.GetFreeTcpPortNumber();
+        }
+
+        public async Task CreateServer()
+        {
+            if (Server != null)
+                return;
+            Server = await WebHostHelpers.CreateServer(Port);
+        }
+
+        public async Task ShutdownServer()
+        {
+            if (Server == null)
+                return;
+
+            await Server.StopAsync();
+            Server.Dispose();
+            Server = null;
+        }
+
+        public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
+            => GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
+
+        public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
+            => GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
+
+        private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false)
+        {
+            if (Serializer == null)
+                throw new InvalidOperationException("JSON serializer not configured");
+            return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer);
+        }
+    }
+
+    public class NewtonsoftIntegrationServerTestFixture : IntegrationServerTestFixture
+    {
+        public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new NewtonsoftJsonSerializer();
+    }
+
+    public class SystemTextJsonIntegrationServerTestFixture : IntegrationServerTestFixture
+    {
+        public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 923c11d1..0fd4349f 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -15,63 +15,67 @@
 
 namespace GraphQL.Integration.Tests.Helpers
 {
-	public static class WebHostHelpers
-	{
-		public static async Task<IWebHost> CreateServer(int port)
-		{
-			var configBuilder = new ConfigurationBuilder();
-			configBuilder.AddInMemoryCollection();
-			var config = configBuilder.Build();
-			config["server.urls"] = $"http://localhost:{port}";
+    public static class WebHostHelpers
+    {
+        public static async Task<IWebHost> CreateServer(int port)
+        {
+            var configBuilder = new ConfigurationBuilder();
+            configBuilder.AddInMemoryCollection();
+            var config = configBuilder.Build();
+            config["server.urls"] = $"http://localhost:{port}";
 
-			var host = new WebHostBuilder()
-				.ConfigureLogging((ctx, logging) => {
-					logging.AddDebug();
-				})
-				.UseConfiguration(config)
-				.UseKestrel()
-				.UseStartup<Startup>()
-				.Build();
+            var host = new WebHostBuilder()
+                .ConfigureLogging((ctx, logging) =>
+                {
+                    logging.AddDebug();
+                })
+                .UseConfiguration(config)
+                .UseKestrel()
+                .UseStartup<Startup>()
+                .Build();
 
-			var tcs = new TaskCompletionSource<bool>();
-			host.Services.GetService<IHostApplicationLifetime>().ApplicationStarted.Register(() => tcs.TrySetResult(true));
-			await host.StartAsync();
-			await tcs.Task;
-			return host;
-		}
-		
-		public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
-			=> new GraphQLHttpClient(new GraphQLHttpClientOptions {
-				EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
-				UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
-				JsonSerializer = serializer ?? new NewtonsoftJsonSerializer()
-			});
-	}
+            var tcs = new TaskCompletionSource<bool>();
+            host.Services.GetService<IHostApplicationLifetime>().ApplicationStarted.Register(() => tcs.TrySetResult(true));
+            await host.StartAsync();
+            await tcs.Task;
+            return host;
+        }
 
-	public class TestServerSetup : IDisposable
-	{
-		public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer) {
-			this.serializer = serializer;
-			Port = NetworkHelpers.GetFreeTcpPortNumber();
-		}
+        public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
+            => new GraphQLHttpClient(new GraphQLHttpClientOptions
+            {
+                EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
+                UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
+                JsonSerializer = serializer ?? new NewtonsoftJsonSerializer()
+            });
+    }
 
-		public int Port { get; }
-		public IWebHost Server { get; set; }
-		public IGraphQLWebsocketJsonSerializer serializer { get; set; }
+    public class TestServerSetup : IDisposable
+    {
+        public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer)
+        {
+            this.serializer = serializer;
+            Port = NetworkHelpers.GetFreeTcpPortNumber();
+        }
 
-		public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-			=> GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
+        public int Port { get; }
+        public IWebHost Server { get; set; }
+        public IGraphQLWebsocketJsonSerializer serializer { get; set; }
 
-		public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-			=> GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
+        public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
+            => GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
 
-		private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) {
-			return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
-		}
+        public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
+            => GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
 
-		public void Dispose()
-		{
-			Server?.Dispose();
-		}
-	}
+        private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false)
+        {
+            return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
+        }
+
+        public void Dispose()
+        {
+            Server?.Dispose();
+        }
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index e55fd2c6..a4f01ee9 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -14,91 +14,101 @@
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.QueryAndMutationTests {
-
-	public abstract class Base: IAsyncLifetime {
-
-		protected IntegrationServerTestFixture Fixture;
-		protected GraphQLHttpClient StarWarsClient;
-		protected GraphQLHttpClient ChatClient;
-
-		protected Base(IntegrationServerTestFixture fixture) {
-			Fixture = fixture;
-		}
-
-		public async Task InitializeAsync() {
-			await Fixture.CreateServer();
-			StarWarsClient = Fixture.GetStarWarsClient();
-			ChatClient = Fixture.GetChatClient();
-		}
-
-		public Task DisposeAsync() {
-			ChatClient?.Dispose();
-			StarWarsClient?.Dispose();
-			return Task.CompletedTask;
-		}
-
-		[Theory]
-		[ClassData(typeof(StarWarsHumans))]
-		public async void QueryTheory(int id, string name) {
-			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty }});
-
-			Assert.Null(response.Errors);
-			Assert.Equal(name, response.Data.Human.Name);
-		}
-
-		[Theory]
-		[ClassData(typeof(StarWarsHumans))]
-		public async void QueryAsHttpResponseTheory(int id, string name) {
-			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
-			var responseType = new {Human = new {Name = string.Empty}};
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => responseType );
-
-			FluentActions.Invoking(() => response.AsGraphQLHttpResponse()).Should()
-				.NotThrow("because the returned object is a GraphQLHttpResponse");
-
-			var httpResponse = response.AsGraphQLHttpResponse();
-
-			httpResponse.Errors.Should().BeNull();
-			httpResponse.Data.Human.Name.Should().Be(name);
-
-			httpResponse.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
-			httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));
-		}
-
-		[Theory]
-		[ClassData(typeof(StarWarsHumans))]
-		public async void QueryWithDynamicReturnTypeTheory(int id, string name) {
-			var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
-
-			var response = await StarWarsClient.SendQueryAsync<dynamic>(graphQLRequest);
-
-			Assert.Null(response.Errors);
-			Assert.Equal(name, response.Data.human.name.ToString());
-		}
-
-		[Theory]
-		[ClassData(typeof(StarWarsHumans))]
-		public async void QueryWitVarsTheory(int id, string name) {
-			var graphQLRequest = new GraphQLRequest(@"
+namespace GraphQL.Integration.Tests.QueryAndMutationTests
+{
+
+    public abstract class Base : IAsyncLifetime
+    {
+
+        protected IntegrationServerTestFixture Fixture;
+        protected GraphQLHttpClient StarWarsClient;
+        protected GraphQLHttpClient ChatClient;
+
+        protected Base(IntegrationServerTestFixture fixture)
+        {
+            Fixture = fixture;
+        }
+
+        public async Task InitializeAsync()
+        {
+            await Fixture.CreateServer();
+            StarWarsClient = Fixture.GetStarWarsClient();
+            ChatClient = Fixture.GetChatClient();
+        }
+
+        public Task DisposeAsync()
+        {
+            ChatClient?.Dispose();
+            StarWarsClient?.Dispose();
+            return Task.CompletedTask;
+        }
+
+        [Theory]
+        [ClassData(typeof(StarWarsHumans))]
+        public async void QueryTheory(int id, string name)
+        {
+            var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+
+            Assert.Null(response.Errors);
+            Assert.Equal(name, response.Data.Human.Name);
+        }
+
+        [Theory]
+        [ClassData(typeof(StarWarsHumans))]
+        public async void QueryAsHttpResponseTheory(int id, string name)
+        {
+            var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+            var responseType = new { Human = new { Name = string.Empty } };
+            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => responseType);
+
+            FluentActions.Invoking(() => response.AsGraphQLHttpResponse()).Should()
+                .NotThrow("because the returned object is a GraphQLHttpResponse");
+
+            var httpResponse = response.AsGraphQLHttpResponse();
+
+            httpResponse.Errors.Should().BeNull();
+            httpResponse.Data.Human.Name.Should().Be(name);
+
+            httpResponse.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
+            httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));
+        }
+
+        [Theory]
+        [ClassData(typeof(StarWarsHumans))]
+        public async void QueryWithDynamicReturnTypeTheory(int id, string name)
+        {
+            var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+
+            var response = await StarWarsClient.SendQueryAsync<dynamic>(graphQLRequest);
+
+            Assert.Null(response.Errors);
+            Assert.Equal(name, response.Data.human.name.ToString());
+        }
+
+        [Theory]
+        [ClassData(typeof(StarWarsHumans))]
+        public async void QueryWitVarsTheory(int id, string name)
+        {
+            var graphQLRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
 					}
 				}",
-				new {id = id.ToString()});
+                new { id = id.ToString() });
 
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
-			Assert.Null(response.Errors);
-			Assert.Equal(name, response.Data.Human.Name);
-		}
+            Assert.Null(response.Errors);
+            Assert.Equal(name, response.Data.Human.Name);
+        }
 
-		[Theory]
-		[ClassData(typeof(StarWarsHumans))]
-		public async void QueryWitVarsAndOperationNameTheory(int id, string name) {
-			var graphQLRequest = new GraphQLRequest(@"
+        [Theory]
+        [ClassData(typeof(StarWarsHumans))]
+        public async void QueryWitVarsAndOperationNameTheory(int id, string name)
+        {
+            var graphQLRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
@@ -110,18 +120,19 @@ query Droid($id: String!) {
 				    name
 				  }
 				}",
-				new { id = id.ToString() },
-				"Human");
+                new { id = id.ToString() },
+                "Human");
 
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
-			Assert.Null(response.Errors);
-			Assert.Equal(name, response.Data.Human.Name);
-		}
+            Assert.Null(response.Errors);
+            Assert.Equal(name, response.Data.Human.Name);
+        }
 
-		[Fact]
-		public async void SendMutationFact() {
-			var mutationRequest = new GraphQLRequest(@"
+        [Fact]
+        public async void SendMutationFact()
+        {
+            var mutationRequest = new GraphQLRequest(@"
 				mutation CreateHuman($human: HumanInput!) {
 				  createHuman(human: $human) {
 				    id
@@ -129,84 +140,89 @@ mutation CreateHuman($human: HumanInput!) {
 				    homePlanet
 				  }
 				}",
-				new { human = new { name = "Han Solo", homePlanet = "Corellia"}});
+                new { human = new { name = "Han Solo", homePlanet = "Corellia" } });
 
-			var queryRequest = new GraphQLRequest(@"
+            var queryRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
 					}
 				}");
 
-			var mutationResponse = await StarWarsClient.SendMutationAsync(mutationRequest, () => new {
-					createHuman = new {
-						Id = "",
-						Name = "",
-						HomePlanet = ""
-					}
-				});
-
-			Assert.Null(mutationResponse.Errors);
-			Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
-			Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
-
-			queryRequest.Variables = new {id = mutationResponse.Data.createHuman.Id};
-			var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } });
-			
-			Assert.Null(queryResponse.Errors);
-			Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
-		}
-
-		[Fact]
-		public async void PreprocessHttpRequestMessageIsCalled() {
-			var callbackTester = new CallbackMonitor<HttpRequestMessage>();
-			var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}") {
-				PreprocessHttpRequestMessage = callbackTester.Invoke
-			};
-
-			var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
-			var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
-			callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
-			Assert.Null(response.Errors);
-			Assert.Equal("Luke", response.Data.Human.Name);
-		}
-
-		[Fact]
-		public void PostRequestCanBeCancelled() {
-			var graphQLRequest = new GraphQLRequest(@"
+            var mutationResponse = await StarWarsClient.SendMutationAsync(mutationRequest, () => new
+            {
+                createHuman = new
+                {
+                    Id = "",
+                    Name = "",
+                    HomePlanet = ""
+                }
+            });
+
+            Assert.Null(mutationResponse.Errors);
+            Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
+            Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
+
+            queryRequest.Variables = new { id = mutationResponse.Data.createHuman.Id };
+            var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } });
+
+            Assert.Null(queryResponse.Errors);
+            Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
+        }
+
+        [Fact]
+        public async void PreprocessHttpRequestMessageIsCalled()
+        {
+            var callbackTester = new CallbackMonitor<HttpRequestMessage>();
+            var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
+            {
+                PreprocessHttpRequestMessage = callbackTester.Invoke
+            };
+
+            var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
+            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+            callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
+            Assert.Null(response.Errors);
+            Assert.Equal("Luke", response.Data.Human.Name);
+        }
+
+        [Fact]
+        public void PostRequestCanBeCancelled()
+        {
+            var graphQLRequest = new GraphQLRequest(@"
 				query Long {
 					longRunning
 				}");
 
-			var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
-			var cts = new CancellationTokenSource();
-
-			var request =
-				ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
-
-			// Test regular request
-			// start request
-			request.Start();
-			// wait until the query has reached the server
-			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-			// unblock the query
-			chatQuery.LongRunningQueryBlocker.Set();
-			// check execution time
-			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
-
-			// reset stuff
-			chatQuery.LongRunningQueryBlocker.Reset();
-			request.Clear();
-
-			// cancellation test
-			request.Start();
-			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-			cts.Cancel();
-			request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
-
-			// let the server finish its query
-			chatQuery.LongRunningQueryBlocker.Set();
-		}
-
-	}
+            var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
+            var cts = new CancellationTokenSource();
+
+            var request =
+                ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
+
+            // Test regular request
+            // start request
+            request.Start();
+            // wait until the query has reached the server
+            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+            // unblock the query
+            chatQuery.LongRunningQueryBlocker.Set();
+            // check execution time
+            request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+
+            // reset stuff
+            chatQuery.LongRunningQueryBlocker.Reset();
+            request.Clear();
+
+            // cancellation test
+            request.Start();
+            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+            cts.Cancel();
+            request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
+
+            // let the server finish its query
+            chatQuery.LongRunningQueryBlocker.Set();
+        }
+
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
index 57f86f64..ecfe9afb 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
@@ -2,10 +2,12 @@
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.QueryAndMutationTests {
-	public class Newtonsoft: Base, IClassFixture<NewtonsoftIntegrationServerTestFixture> {
-		public Newtonsoft(NewtonsoftIntegrationServerTestFixture fixture) : base(fixture)
-		{
-		}
-	}
+namespace GraphQL.Integration.Tests.QueryAndMutationTests
+{
+    public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
+    {
+        public Newtonsoft(NewtonsoftIntegrationServerTestFixture fixture) : base(fixture)
+        {
+        }
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
index e74d5012..e293f044 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
@@ -2,10 +2,12 @@
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.QueryAndMutationTests {
-	public class SystemTextJson: Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture> {
-		public SystemTextJson(SystemTextJsonIntegrationServerTestFixture fixture) : base(fixture)
-		{
-		}
-	}
+namespace GraphQL.Integration.Tests.QueryAndMutationTests
+{
+    public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
+    {
+        public SystemTextJson(SystemTextJsonIntegrationServerTestFixture fixture) : base(fixture)
+        {
+        }
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 59f57ceb..b1dca909 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -17,184 +17,198 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GraphQL.Integration.Tests.WebsocketTests {
-	public abstract class Base: IAsyncLifetime {
-		protected readonly ITestOutputHelper Output;
-		protected readonly IntegrationServerTestFixture Fixture;
-		protected GraphQLHttpClient ChatClient;
-		
-		protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture) {
-			this.Output = output;
-			this.Fixture = fixture;
-		}
-
-		protected static ReceivedMessage InitialMessage = new ReceivedMessage {
-			Content = "initial message",
-			SentAt = DateTime.Now,
-			FromId = "1"
-		};
-
-		public async Task InitializeAsync() {
-			await Fixture.CreateServer();
-			// make sure the buffer always contains the same message
-			Fixture.Server.Services.GetService<Chat>().AddMessage(InitialMessage);
-
-			if (ChatClient == null) {
-				// then create the chat client
-				ChatClient = Fixture.GetChatClient(true);
-			}
-		}
-
-		public Task DisposeAsync() {
-			ChatClient?.Dispose();
-			return Task.CompletedTask;
-		}
-
-		[Fact]
-		public async void CanSendRequestViaWebsocket() {
-			await ChatClient.InitializeWebsocketConnection();
-			const string message = "some random testing message";
-			var response = await ChatClient.AddMessageAsync(message);
-			response.Data.AddMessage.Content.Should().Be(message);
-		}
-
-		[Fact]
-		public async void WebsocketRequestCanBeCancelled() {
-			var graphQLRequest = new GraphQLRequest(@"
+namespace GraphQL.Integration.Tests.WebsocketTests
+{
+    public abstract class Base : IAsyncLifetime
+    {
+        protected readonly ITestOutputHelper Output;
+        protected readonly IntegrationServerTestFixture Fixture;
+        protected GraphQLHttpClient ChatClient;
+
+        protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture)
+        {
+            this.Output = output;
+            this.Fixture = fixture;
+        }
+
+        protected static ReceivedMessage InitialMessage = new ReceivedMessage
+        {
+            Content = "initial message",
+            SentAt = DateTime.Now,
+            FromId = "1"
+        };
+
+        public async Task InitializeAsync()
+        {
+            await Fixture.CreateServer();
+            // make sure the buffer always contains the same message
+            Fixture.Server.Services.GetService<Chat>().AddMessage(InitialMessage);
+
+            if (ChatClient == null)
+            {
+                // then create the chat client
+                ChatClient = Fixture.GetChatClient(true);
+            }
+        }
+
+        public Task DisposeAsync()
+        {
+            ChatClient?.Dispose();
+            return Task.CompletedTask;
+        }
+
+        [Fact]
+        public async void CanSendRequestViaWebsocket()
+        {
+            await ChatClient.InitializeWebsocketConnection();
+            const string message = "some random testing message";
+            var response = await ChatClient.AddMessageAsync(message);
+            response.Data.AddMessage.Content.Should().Be(message);
+        }
+
+        [Fact]
+        public async void WebsocketRequestCanBeCancelled()
+        {
+            var graphQLRequest = new GraphQLRequest(@"
 				query Long {
 					longRunning
 				}");
 
-			var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
-			var cts = new CancellationTokenSource();
-
-			await ChatClient.InitializeWebsocketConnection();
-			var request =
-				ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
-
-			// Test regular request
-			// start request
-			request.Start();
-			// wait until the query has reached the server
-			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-			// unblock the query
-			chatQuery.LongRunningQueryBlocker.Set();
-			// check execution time
-			request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
-
-			// reset stuff
-			chatQuery.LongRunningQueryBlocker.Reset();
-			request.Clear();
-
-			// cancellation test
-			request.Start();
-			chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-			cts.Cancel();
-			request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
-
-			// let the server finish its query
-			chatQuery.LongRunningQueryBlocker.Set();
-		}
-		
-		[Fact]
-		public async void CanHandleRequestErrorViaWebsocket() {
-			await ChatClient.InitializeWebsocketConnection();
-			var response = await ChatClient.SendQueryAsync<object>("this query is formatted quite badly");
-			response.Errors.Should().ContainSingle("because the query is invalid");
-		}
-
-		private const string SubscriptionQuery = @"
+            var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
+            var cts = new CancellationTokenSource();
+
+            await ChatClient.InitializeWebsocketConnection();
+            var request =
+                ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
+
+            // Test regular request
+            // start request
+            request.Start();
+            // wait until the query has reached the server
+            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+            // unblock the query
+            chatQuery.LongRunningQueryBlocker.Set();
+            // check execution time
+            request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+
+            // reset stuff
+            chatQuery.LongRunningQueryBlocker.Reset();
+            request.Clear();
+
+            // cancellation test
+            request.Start();
+            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+            cts.Cancel();
+            request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
+
+            // let the server finish its query
+            chatQuery.LongRunningQueryBlocker.Set();
+        }
+
+        [Fact]
+        public async void CanHandleRequestErrorViaWebsocket()
+        {
+            await ChatClient.InitializeWebsocketConnection();
+            var response = await ChatClient.SendQueryAsync<object>("this query is formatted quite badly");
+            response.Errors.Should().ContainSingle("because the query is invalid");
+        }
+
+        private const string SubscriptionQuery = @"
 			subscription {
 			  messageAdded{
 			    content
 			  }
 			}";
 
-		private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
-
-
-		[Fact]
-		public async void CanCreateObservableSubscription() {
-			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-			await ChatClient.InitializeWebsocketConnection();
-			callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-			Debug.WriteLine("creating subscription stream");
-			var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
-
-			Debug.WriteLine("subscribing...");
-			using var tester = observable.Monitor();
-			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
-
-			const string message1 = "Hello World";
-			var response = await ChatClient.AddMessageAsync(message1);
-			response.Data.AddMessage.Content.Should().Be(message1);
-			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
-
-			const string message2 = "lorem ipsum dolor si amet";
-			response = await ChatClient.AddMessageAsync(message2);
-			response.Data.AddMessage.Content.Should().Be(message2);
-			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
-
-			// disposing the client should throw a TaskCanceledException on the subscription
-			ChatClient.Dispose();
-			tester.Should().HaveCompleted();
-		}
-
-		public class MessageAddedSubscriptionResult {
-			public MessageAddedContent MessageAdded { get; set; }
-
-			public class MessageAddedContent {
-				public string Content { get; set; }
-			}
-		}
-
-
-		[Fact]
-		public async void CanReconnectWithSameObservable() {
-			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-
-			Debug.WriteLine("creating subscription stream");
-			var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
-
-			Debug.WriteLine("subscribing...");
-			var tester = observable.Monitor();
-			callbackMonitor.Should().HaveBeenInvokedWithPayload();
-			await ChatClient.InitializeWebsocketConnection();
-			Debug.WriteLine("websocket connection initialized");
-			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
-
-			const string message1 = "Hello World";
-			Debug.WriteLine($"adding message {message1}");
-			var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(true);
-			response.Data.AddMessage.Content.Should().Be(message1);
-			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
-
-			const string message2 = "How are you?";
-			response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(true);
-			response.Data.AddMessage.Content.Should().Be(message2);
-			tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
-
-			Debug.WriteLine("disposing subscription...");
-			tester.Dispose(); // does not close the websocket connection
-
-			Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
-			var tester2 = observable.Monitor();
-			Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
-			tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
-
-			const string message3 = "lorem ipsum dolor si amet";
-			response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(true);
-			response.Data.AddMessage.Content.Should().Be(message3);
-			tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message3);
-
-			// disposing the client should complete the subscription
-			ChatClient.Dispose();
-			tester2.Should().HaveCompleted();
-			tester2.Dispose();
-		}
-
-		private const string SubscriptionQuery2 = @"
+        private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
+
+
+        [Fact]
+        public async void CanCreateObservableSubscription()
+        {
+            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+            await ChatClient.InitializeWebsocketConnection();
+            callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+            Debug.WriteLine("creating subscription stream");
+            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+
+            Debug.WriteLine("subscribing...");
+            using var tester = observable.Monitor();
+            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
+            const string message1 = "Hello World";
+            var response = await ChatClient.AddMessageAsync(message1);
+            response.Data.AddMessage.Content.Should().Be(message1);
+            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
+
+            const string message2 = "lorem ipsum dolor si amet";
+            response = await ChatClient.AddMessageAsync(message2);
+            response.Data.AddMessage.Content.Should().Be(message2);
+            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
+
+            // disposing the client should throw a TaskCanceledException on the subscription
+            ChatClient.Dispose();
+            tester.Should().HaveCompleted();
+        }
+
+        public class MessageAddedSubscriptionResult
+        {
+            public MessageAddedContent MessageAdded { get; set; }
+
+            public class MessageAddedContent
+            {
+                public string Content { get; set; }
+            }
+        }
+
+
+        [Fact]
+        public async void CanReconnectWithSameObservable()
+        {
+            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+
+            Debug.WriteLine("creating subscription stream");
+            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+
+            Debug.WriteLine("subscribing...");
+            var tester = observable.Monitor();
+            callbackMonitor.Should().HaveBeenInvokedWithPayload();
+            await ChatClient.InitializeWebsocketConnection();
+            Debug.WriteLine("websocket connection initialized");
+            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
+            const string message1 = "Hello World";
+            Debug.WriteLine($"adding message {message1}");
+            var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(true);
+            response.Data.AddMessage.Content.Should().Be(message1);
+            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
+
+            const string message2 = "How are you?";
+            response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(true);
+            response.Data.AddMessage.Content.Should().Be(message2);
+            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
+
+            Debug.WriteLine("disposing subscription...");
+            tester.Dispose(); // does not close the websocket connection
+
+            Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
+            var tester2 = observable.Monitor();
+            Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
+            tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
+
+            const string message3 = "lorem ipsum dolor si amet";
+            response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(true);
+            response.Data.AddMessage.Content.Should().Be(message3);
+            tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message3);
+
+            // disposing the client should complete the subscription
+            ChatClient.Dispose();
+            tester2.Should().HaveCompleted();
+            tester2.Dispose();
+        }
+
+        private const string SubscriptionQuery2 = @"
 			subscription {
 			  userJoined{
 				displayName
@@ -202,188 +216,198 @@ public async void CanReconnectWithSameObservable() {
 			  }
 			}";
 
-		public class UserJoinedSubscriptionResult {
-			public UserJoinedContent UserJoined { get; set; }
-
-			public class UserJoinedContent {
-				public string DisplayName { get; set; }
-				public string Id { get; set; }
-			}
-
-		}
-
-		private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
+        public class UserJoinedSubscriptionResult
+        {
+            public UserJoinedContent UserJoined { get; set; }
+
+            public class UserJoinedContent
+            {
+                public string DisplayName { get; set; }
+                public string Id { get; set; }
+            }
 
+        }
+
+        private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
 
-		[Fact]
-		public async void CanConnectTwoSubscriptionsSimultaneously() {
-			var port = NetworkHelpers.GetFreeTcpPortNumber();
-			var callbackTester = new CallbackMonitor<Exception>();
-			var callbackTester2 = new CallbackMonitor<Exception>();
-
-			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-			await ChatClient.InitializeWebsocketConnection();
-			callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-			Debug.WriteLine("creating subscription stream");
-			var observable1 = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Invoke);
-			var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
-
-			Debug.WriteLine("subscribing...");
-			var messagesMonitor = observable1.Monitor();
-			var joinedMonitor = observable2.Monitor();
-
-			messagesMonitor.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
-
-			const string message1 = "Hello World";
-			var response = await ChatClient.AddMessageAsync(message1);
-			response.Data.AddMessage.Content.Should().Be(message1);
-			messagesMonitor.Should().HaveReceivedPayload()
-				.Which.Data.MessageAdded.Content.Should().Be(message1);
-			joinedMonitor.Should().NotHaveReceivedPayload();
-			
-			var joinResponse = await ChatClient.JoinDeveloperUser();
-			joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
-
-			var payload = joinedMonitor.Should().HaveReceivedPayload().Subject;
-			payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
-			payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
-			messagesMonitor.Should().NotHaveReceivedPayload();
-
-			Debug.WriteLine("disposing subscription...");
-			joinedMonitor.Dispose();
-
-			const string message3 = "lorem ipsum dolor si amet";
-			response = await ChatClient.AddMessageAsync(message3);
-			response.Data.AddMessage.Content.Should().Be(message3);
-			messagesMonitor.Should().HaveReceivedPayload()
-				.Which.Data.MessageAdded.Content.Should().Be(message3);
-
-			// disposing the client should complete the subscription
-			ChatClient.Dispose();
-			messagesMonitor.Should().HaveCompleted();
-		}
-
-
-		[Fact]
-		public async void CanHandleConnectionTimeout() {
-			var errorMonitor = new CallbackMonitor<Exception>();
-			var reconnectBlocker = new ManualResetEventSlim(false);
-
-			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-			// configure back-off strategy to allow it to be controlled from within the unit test
-			ChatClient.Options.BackOffStrategy = i => {
-				Debug.WriteLine("back-off strategy: waiting on reconnect blocker");
-				reconnectBlocker.Wait();
-				Debug.WriteLine("back-off strategy: reconnecting...");
-				return TimeSpan.Zero;
-			};
-
-			var websocketStates = new ConcurrentQueue<GraphQLWebsocketConnectionState>();
-
-			using (ChatClient.WebsocketConnectionState.Subscribe(websocketStates.Enqueue)) {
-				websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
-
-				Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
-				Debug.WriteLine("creating subscription stream");
-				var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, errorMonitor.Invoke);
-
-				Debug.WriteLine("subscribing...");
-				var tester = observable.Monitor();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-				websocketStates.Should().ContainInOrder(
-					GraphQLWebsocketConnectionState.Disconnected,
-					GraphQLWebsocketConnectionState.Connecting,
-					GraphQLWebsocketConnectionState.Connected);
-				// clear the collection so the next tests on the collection work as expected
-				websocketStates.Clear();
-
-				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
-
-				const string message1 = "Hello World";
-				var response = await ChatClient.AddMessageAsync(message1);
-				response.Data.AddMessage.Content.Should().Be(message1);
-				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
-
-				Debug.WriteLine("stopping web host...");
-				await Fixture.ShutdownServer();
-				Debug.WriteLine("web host stopped");
-
-				errorMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds())
-					.Which.Should().BeOfType<WebSocketException>();
-				websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
-
-				Debug.WriteLine("restarting web host...");
-				await InitializeAsync();
-				Debug.WriteLine("web host started");
-				reconnectBlocker.Set();
-				callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
-				tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
-
-				websocketStates.Should().ContainInOrder(
-					GraphQLWebsocketConnectionState.Disconnected,
-					GraphQLWebsocketConnectionState.Connecting,
-					GraphQLWebsocketConnectionState.Connected);
-
-				// disposing the client should complete the subscription
-				ChatClient.Dispose();
-				tester.Should().HaveCompleted(5.Seconds());
-			}
-		}
-
-
-		[Fact]
-		public async void CanHandleSubscriptionError() {
-			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-			await ChatClient.InitializeWebsocketConnection();
-			callbackMonitor.Should().HaveBeenInvokedWithPayload();
-			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
-				new GraphQLRequest(@"
+
+        [Fact]
+        public async void CanConnectTwoSubscriptionsSimultaneously()
+        {
+            var port = NetworkHelpers.GetFreeTcpPortNumber();
+            var callbackTester = new CallbackMonitor<Exception>();
+            var callbackTester2 = new CallbackMonitor<Exception>();
+
+            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+            await ChatClient.InitializeWebsocketConnection();
+            callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+            Debug.WriteLine("creating subscription stream");
+            var observable1 = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Invoke);
+            var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
+
+            Debug.WriteLine("subscribing...");
+            var messagesMonitor = observable1.Monitor();
+            var joinedMonitor = observable2.Monitor();
+
+            messagesMonitor.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
+            const string message1 = "Hello World";
+            var response = await ChatClient.AddMessageAsync(message1);
+            response.Data.AddMessage.Content.Should().Be(message1);
+            messagesMonitor.Should().HaveReceivedPayload()
+                .Which.Data.MessageAdded.Content.Should().Be(message1);
+            joinedMonitor.Should().NotHaveReceivedPayload();
+
+            var joinResponse = await ChatClient.JoinDeveloperUser();
+            joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+
+            var payload = joinedMonitor.Should().HaveReceivedPayload().Subject;
+            payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
+            payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+            messagesMonitor.Should().NotHaveReceivedPayload();
+
+            Debug.WriteLine("disposing subscription...");
+            joinedMonitor.Dispose();
+
+            const string message3 = "lorem ipsum dolor si amet";
+            response = await ChatClient.AddMessageAsync(message3);
+            response.Data.AddMessage.Content.Should().Be(message3);
+            messagesMonitor.Should().HaveReceivedPayload()
+                .Which.Data.MessageAdded.Content.Should().Be(message3);
+
+            // disposing the client should complete the subscription
+            ChatClient.Dispose();
+            messagesMonitor.Should().HaveCompleted();
+        }
+
+
+        [Fact]
+        public async void CanHandleConnectionTimeout()
+        {
+            var errorMonitor = new CallbackMonitor<Exception>();
+            var reconnectBlocker = new ManualResetEventSlim(false);
+
+            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+            // configure back-off strategy to allow it to be controlled from within the unit test
+            ChatClient.Options.BackOffStrategy = i =>
+            {
+                Debug.WriteLine("back-off strategy: waiting on reconnect blocker");
+                reconnectBlocker.Wait();
+                Debug.WriteLine("back-off strategy: reconnecting...");
+                return TimeSpan.Zero;
+            };
+
+            var websocketStates = new ConcurrentQueue<GraphQLWebsocketConnectionState>();
+
+            using (ChatClient.WebsocketConnectionState.Subscribe(websocketStates.Enqueue))
+            {
+                websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
+
+                Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
+                Debug.WriteLine("creating subscription stream");
+                var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, errorMonitor.Invoke);
+
+                Debug.WriteLine("subscribing...");
+                var tester = observable.Monitor();
+                callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+                websocketStates.Should().ContainInOrder(
+                    GraphQLWebsocketConnectionState.Disconnected,
+                    GraphQLWebsocketConnectionState.Connecting,
+                    GraphQLWebsocketConnectionState.Connected);
+                // clear the collection so the next tests on the collection work as expected
+                websocketStates.Clear();
+
+                tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
+                const string message1 = "Hello World";
+                var response = await ChatClient.AddMessageAsync(message1);
+                response.Data.AddMessage.Content.Should().Be(message1);
+                tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
+
+                Debug.WriteLine("stopping web host...");
+                await Fixture.ShutdownServer();
+                Debug.WriteLine("web host stopped");
+
+                errorMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds())
+                    .Which.Should().BeOfType<WebSocketException>();
+                websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
+
+                Debug.WriteLine("restarting web host...");
+                await InitializeAsync();
+                Debug.WriteLine("web host started");
+                reconnectBlocker.Set();
+                callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
+                tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
+                websocketStates.Should().ContainInOrder(
+                    GraphQLWebsocketConnectionState.Disconnected,
+                    GraphQLWebsocketConnectionState.Connecting,
+                    GraphQLWebsocketConnectionState.Connected);
+
+                // disposing the client should complete the subscription
+                ChatClient.Dispose();
+                tester.Should().HaveCompleted(5.Seconds());
+            }
+        }
+
+
+        [Fact]
+        public async void CanHandleSubscriptionError()
+        {
+            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+            await ChatClient.InitializeWebsocketConnection();
+            callbackMonitor.Should().HaveBeenInvokedWithPayload();
+            Debug.WriteLine("creating subscription stream");
+            IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
+                new GraphQLRequest(@"
 					subscription {
 					  failImmediately {
 					    content
 					  }
 					}")
-				);
-
-			Debug.WriteLine("subscribing...");
-			using (var tester = observable.Monitor()) {
-				tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
-					.Which.Errors.Should().ContainSingle();
-				tester.Should().HaveCompleted();
-				ChatClient.Dispose();
-			}
-			
-		}
-
-
-		[Fact]
-		public async void CanHandleQueryErrorInSubscription() {
-			var test = new GraphQLRequest("tset", new { test = "blaa" });
-
-			var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-			await ChatClient.InitializeWebsocketConnection();
-			callbackMonitor.Should().HaveBeenInvokedWithPayload();
-			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
-				new GraphQLRequest(@"
+                );
+
+            Debug.WriteLine("subscribing...");
+            using (var tester = observable.Monitor())
+            {
+                tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
+                    .Which.Errors.Should().ContainSingle();
+                tester.Should().HaveCompleted();
+                ChatClient.Dispose();
+            }
+
+        }
+
+
+        [Fact]
+        public async void CanHandleQueryErrorInSubscription()
+        {
+            var test = new GraphQLRequest("tset", new { test = "blaa" });
+
+            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+            await ChatClient.InitializeWebsocketConnection();
+            callbackMonitor.Should().HaveBeenInvokedWithPayload();
+            Debug.WriteLine("creating subscription stream");
+            IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
+                new GraphQLRequest(@"
 					subscription {
 					  fieldDoesNotExist {
 					    content
 					  }
 					}")
-			);
-
-			Debug.WriteLine("subscribing...");
-			using (var tester = observable.Monitor()) {
-				tester.Should().HaveReceivedPayload()
-					.Which.Errors.Should().ContainSingle();
-				tester.Should().HaveCompleted();
-				ChatClient.Dispose();
-			}
-		}
-
-	}
+            );
+
+            Debug.WriteLine("subscribing...");
+            using (var tester = observable.Monitor())
+            {
+                tester.Should().HaveReceivedPayload()
+                    .Which.Errors.Should().ContainSingle();
+                tester.Should().HaveCompleted();
+                ChatClient.Dispose();
+            }
+        }
+
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
index 76169663..adfb0672 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
@@ -3,9 +3,11 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GraphQL.Integration.Tests.WebsocketTests {
-	public class Newtonsoft: Base, IClassFixture<NewtonsoftIntegrationServerTestFixture> {
-		public Newtonsoft(ITestOutputHelper output, NewtonsoftIntegrationServerTestFixture fixture) : base(output, fixture)
-		{ }
-	}
+namespace GraphQL.Integration.Tests.WebsocketTests
+{
+    public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
+    {
+        public Newtonsoft(ITestOutputHelper output, NewtonsoftIntegrationServerTestFixture fixture) : base(output, fixture)
+        { }
+    }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
index fc7698ed..ab4659a4 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
@@ -2,10 +2,12 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GraphQL.Integration.Tests.WebsocketTests {
-	public class SystemTextJson: Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture> {
-		public SystemTextJson(ITestOutputHelper output, SystemTextJsonIntegrationServerTestFixture fixture) : base(output, fixture)
-		{
-		}
-	}
+namespace GraphQL.Integration.Tests.WebsocketTests
+{
+    public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
+    {
+        public SystemTextJson(ITestOutputHelper output, SystemTextJsonIntegrationServerTestFixture fixture) : base(output, fixture)
+        {
+        }
+    }
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
index 5b144a74..ce34bcc8 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
@@ -1,57 +1,66 @@
 using Xunit;
 
-namespace GraphQL.Primitives.Tests {
-
-	public class GraphQLLocationTest {
-
-		[Fact]
-		public void ConstructorFact() {
-			var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.Equal(1U, graphQLLocation.Column);
-			Assert.Equal(2U, graphQLLocation.Line);
-		}
-
-		[Fact]
-		public void Equality1Fact() {
-			var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.Equal(graphQLLocation, graphQLLocation);
-		}
-
-		[Fact]
-		public void Equality2Fact() {
-			var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-			var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.Equal(graphQLLocation1, graphQLLocation2);
-		}
-
-		[Fact]
-		public void EqualityOperatorFact() {
-			var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-			var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.True(graphQLLocation1 == graphQLLocation2);
-		}
-
-		[Fact]
-		public void InEqualityFact() {
-			var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-			var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
-			Assert.NotEqual(graphQLLocation1, graphQLLocation2);
-		}
-
-		[Fact]
-		public void InEqualityOperatorFact() {
-			var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-			var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
-			Assert.True(graphQLLocation1 != graphQLLocation2);
-		}
-
-		[Fact]
-		public void GetHashCodeFact() {
-			var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-			var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-			Assert.True(graphQLLocation1.GetHashCode() == graphQLLocation2.GetHashCode());
-		}
-
-	}
+namespace GraphQL.Primitives.Tests
+{
+
+    public class GraphQLLocationTest
+    {
+
+        [Fact]
+        public void ConstructorFact()
+        {
+            var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
+            Assert.Equal(1U, graphQLLocation.Column);
+            Assert.Equal(2U, graphQLLocation.Line);
+        }
+
+        [Fact]
+        public void Equality1Fact()
+        {
+            var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
+            Assert.Equal(graphQLLocation, graphQLLocation);
+        }
+
+        [Fact]
+        public void Equality2Fact()
+        {
+            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+            var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
+            Assert.Equal(graphQLLocation1, graphQLLocation2);
+        }
+
+        [Fact]
+        public void EqualityOperatorFact()
+        {
+            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+            var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
+            Assert.True(graphQLLocation1 == graphQLLocation2);
+        }
+
+        [Fact]
+        public void InEqualityFact()
+        {
+            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+            var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
+            Assert.NotEqual(graphQLLocation1, graphQLLocation2);
+        }
+
+        [Fact]
+        public void InEqualityOperatorFact()
+        {
+            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+            var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
+            Assert.True(graphQLLocation1 != graphQLLocation2);
+        }
+
+        [Fact]
+        public void GetHashCodeFact()
+        {
+            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+            var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
+            Assert.True(graphQLLocation1.GetHashCode() == graphQLLocation2.GetHashCode());
+        }
+
+    }
 
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
index f4a22742..8fbda085 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
@@ -1,157 +1,182 @@
 using Xunit;
 
-namespace GraphQL.Primitives.Tests {
-
-	public class GraphQLRequestTest {
-
-		[Fact]
-		public void ConstructorFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}");
-			Assert.NotNull(graphQLRequest.Query);
-			Assert.Null(graphQLRequest.OperationName);
-			Assert.Null(graphQLRequest.Variables);
-		}
-
-		[Fact]
-		public void ConstructorExtendedFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			Assert.NotNull(graphQLRequest.Query);
-			Assert.NotNull(graphQLRequest.OperationName);
-			Assert.NotNull(graphQLRequest.Variables);
-		}
-
-		[Fact]
-		public void Equality1Fact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}");
-			Assert.Equal(graphQLRequest, graphQLRequest);
-		}
-
-		[Fact]
-		public void Equality2Fact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
-			Assert.Equal(graphQLRequest1, graphQLRequest2);
-		}
-
-		[Fact]
-		public void Equality3Fact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			Assert.Equal(graphQLRequest1, graphQLRequest2);
-		}
-
-
-		[Fact]
-		public void Equality4Fact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
-			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
-		}
-
-		[Fact]
-		public void EqualityOperatorFact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			Assert.True(graphQLRequest1 == graphQLRequest2);
-		}
-
-		[Fact]
-		public void InEquality1Fact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
-			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
-		}
-
-		[Fact]
-		public void InEquality2Fact() {
-			GraphQLRequest graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-			GraphQLRequest graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
-			Assert.NotEqual(graphQLRequest1, graphQLRequest2);
-		}
-
-		[Fact]
-		public void InEqualityOperatorFact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
-			Assert.True(graphQLRequest1 != graphQLRequest2);
-		}
-
-		[Fact]
-		public void GetHashCode1Fact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
-			Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
-		}
-
-		[Fact]
-		public void GetHashCode2Fact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
-		}
-
-		[Fact]
-		public void GetHashCode3Fact() {
-			var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-			var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
-			Assert.True(graphQLRequest1.GetHashCode() != graphQLRequest2.GetHashCode());
-		}
-
-		[Fact]
-		public void PropertyQueryGetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-			Assert.Equal("{hero{name}}", graphQLRequest.Query);
-		}
-
-		[Fact]
-		public void PropertyQuerySetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-			graphQLRequest.Query = "{hero{name2}}";
-			Assert.Equal("{hero{name2}}", graphQLRequest.Query);
-		}
-
-		[Fact]
-		public void PropertyOperationNameGetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			Assert.Equal("operationName", graphQLRequest.OperationName);
-		}
-
-		[Fact]
-		public void PropertyOperationNameNullGetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}");
-			Assert.Null(graphQLRequest.OperationName);
-		}
-
-		[Fact]
-		public void PropertyOperationNameSetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1");
-			graphQLRequest.OperationName = "operationName2";
-			Assert.Equal("operationName2", graphQLRequest.OperationName);
-		}
-
-		[Fact]
-		public void PropertyVariableGetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-			Assert.Equal(new { varName = "varValue" }, graphQLRequest.Variables);
-		}
-
-		[Fact]
-		public void PropertyVariableNullGetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}");
-			Assert.Null(graphQLRequest.Variables);
-		}
-
-		[Fact]
-		public void PropertyVariableSetFact() {
-			var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1");
-			graphQLRequest.Variables = new {
-				varName = "varValue2"
-			};
-			Assert.Equal(new {
-				varName = "varValue2"
-			}, graphQLRequest.Variables);
-		}
-
-	}
+namespace GraphQL.Primitives.Tests
+{
+
+    public class GraphQLRequestTest
+    {
+
+        [Fact]
+        public void ConstructorFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}");
+            Assert.NotNull(graphQLRequest.Query);
+            Assert.Null(graphQLRequest.OperationName);
+            Assert.Null(graphQLRequest.Variables);
+        }
+
+        [Fact]
+        public void ConstructorExtendedFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            Assert.NotNull(graphQLRequest.Query);
+            Assert.NotNull(graphQLRequest.OperationName);
+            Assert.NotNull(graphQLRequest.Variables);
+        }
+
+        [Fact]
+        public void Equality1Fact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}");
+            Assert.Equal(graphQLRequest, graphQLRequest);
+        }
+
+        [Fact]
+        public void Equality2Fact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
+            Assert.Equal(graphQLRequest1, graphQLRequest2);
+        }
+
+        [Fact]
+        public void Equality3Fact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            Assert.Equal(graphQLRequest1, graphQLRequest2);
+        }
+
+
+        [Fact]
+        public void Equality4Fact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+            Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+        }
+
+        [Fact]
+        public void EqualityOperatorFact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            Assert.True(graphQLRequest1 == graphQLRequest2);
+        }
+
+        [Fact]
+        public void InEquality1Fact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
+            Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+        }
+
+        [Fact]
+        public void InEquality2Fact()
+        {
+            GraphQLRequest graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+            GraphQLRequest graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+            Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+        }
+
+        [Fact]
+        public void InEqualityOperatorFact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
+            Assert.True(graphQLRequest1 != graphQLRequest2);
+        }
+
+        [Fact]
+        public void GetHashCode1Fact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
+            Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
+        }
+
+        [Fact]
+        public void GetHashCode2Fact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
+        }
+
+        [Fact]
+        public void GetHashCode3Fact()
+        {
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+            Assert.True(graphQLRequest1.GetHashCode() != graphQLRequest2.GetHashCode());
+        }
+
+        [Fact]
+        public void PropertyQueryGetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+            Assert.Equal("{hero{name}}", graphQLRequest.Query);
+        }
+
+        [Fact]
+        public void PropertyQuerySetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+            graphQLRequest.Query = "{hero{name2}}";
+            Assert.Equal("{hero{name2}}", graphQLRequest.Query);
+        }
+
+        [Fact]
+        public void PropertyOperationNameGetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            Assert.Equal("operationName", graphQLRequest.OperationName);
+        }
+
+        [Fact]
+        public void PropertyOperationNameNullGetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}");
+            Assert.Null(graphQLRequest.OperationName);
+        }
+
+        [Fact]
+        public void PropertyOperationNameSetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1");
+            graphQLRequest.OperationName = "operationName2";
+            Assert.Equal("operationName2", graphQLRequest.OperationName);
+        }
+
+        [Fact]
+        public void PropertyVariableGetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+            Assert.Equal(new { varName = "varValue" }, graphQLRequest.Variables);
+        }
+
+        [Fact]
+        public void PropertyVariableNullGetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}");
+            Assert.Null(graphQLRequest.Variables);
+        }
+
+        [Fact]
+        public void PropertyVariableSetFact()
+        {
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1");
+            graphQLRequest.Variables = new
+            {
+                varName = "varValue2"
+            };
+            Assert.Equal(new
+            {
+                varName = "varValue2"
+            }, graphQLRequest.Variables);
+        }
+
+    }
 
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
index 07c4063c..ed23f3fd 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
@@ -1,98 +1,118 @@
 using Xunit;
 
-namespace GraphQL.Primitives.Tests {
+namespace GraphQL.Primitives.Tests
+{
 
-	public class GraphQLResponseTest {
+    public class GraphQLResponseTest
+    {
 
-		[Fact]
-		public void Constructor1Fact() {
-			var graphQLResponse = new GraphQLResponse<object>();
-			Assert.Null(graphQLResponse.Data);
-			Assert.Null(graphQLResponse.Errors);
-		}
+        [Fact]
+        public void Constructor1Fact()
+        {
+            var graphQLResponse = new GraphQLResponse<object>();
+            Assert.Null(graphQLResponse.Data);
+            Assert.Null(graphQLResponse.Errors);
+        }
 
-		[Fact]
-		public void Constructor2Fact() {
-			var graphQLResponse = new GraphQLResponse<object> {
-				Data = new { a = 1 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			Assert.NotNull(graphQLResponse.Data);
-			Assert.NotNull(graphQLResponse.Errors);
-		}
+        [Fact]
+        public void Constructor2Fact()
+        {
+            var graphQLResponse = new GraphQLResponse<object>
+            {
+                Data = new { a = 1 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            Assert.NotNull(graphQLResponse.Data);
+            Assert.NotNull(graphQLResponse.Errors);
+        }
 
-		[Fact]
-		public void Equality1Fact() {
-			var graphQLResponse = new GraphQLResponse<object>();
-			Assert.Equal(graphQLResponse, graphQLResponse);
-		}
+        [Fact]
+        public void Equality1Fact()
+        {
+            var graphQLResponse = new GraphQLResponse<object>();
+            Assert.Equal(graphQLResponse, graphQLResponse);
+        }
 
-		[Fact]
-		public void Equality2Fact() {
-			var graphQLResponse1 = new GraphQLResponse<object>();
-			var graphQLResponse2 = new GraphQLResponse<object>();
-			Assert.Equal(graphQLResponse1, graphQLResponse2);
-		}
+        [Fact]
+        public void Equality2Fact()
+        {
+            var graphQLResponse1 = new GraphQLResponse<object>();
+            var graphQLResponse2 = new GraphQLResponse<object>();
+            Assert.Equal(graphQLResponse1, graphQLResponse2);
+        }
 
-		[Fact]
-		public void Equality3Fact() {
-			var graphQLResponse1 = new GraphQLResponse<object> {
-				Data = new { a = 1 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			var graphQLResponse2 = new GraphQLResponse<object> {
-				Data = new { a = 1 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			Assert.Equal(graphQLResponse1, graphQLResponse2);
-		}
+        [Fact]
+        public void Equality3Fact()
+        {
+            var graphQLResponse1 = new GraphQLResponse<object>
+            {
+                Data = new { a = 1 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            var graphQLResponse2 = new GraphQLResponse<object>
+            {
+                Data = new { a = 1 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            Assert.Equal(graphQLResponse1, graphQLResponse2);
+        }
 
-		[Fact]
-		public void EqualityOperatorFact() {
-			var graphQLResponse1 = new GraphQLResponse<object>();
-			var graphQLResponse2 = new GraphQLResponse<object>();
-			Assert.True(graphQLResponse1 == graphQLResponse2);
-		}
+        [Fact]
+        public void EqualityOperatorFact()
+        {
+            var graphQLResponse1 = new GraphQLResponse<object>();
+            var graphQLResponse2 = new GraphQLResponse<object>();
+            Assert.True(graphQLResponse1 == graphQLResponse2);
+        }
 
-		[Fact]
-		public void InEqualityFact() {
-			var graphQLResponse1 = new GraphQLResponse<object> {
-				Data = new { a = 1 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			var graphQLResponse2 = new GraphQLResponse<object> {
-				Data = new { a = 2 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			Assert.NotEqual(graphQLResponse1, graphQLResponse2);
-		}
+        [Fact]
+        public void InEqualityFact()
+        {
+            var graphQLResponse1 = new GraphQLResponse<object>
+            {
+                Data = new { a = 1 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            var graphQLResponse2 = new GraphQLResponse<object>
+            {
+                Data = new { a = 2 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            Assert.NotEqual(graphQLResponse1, graphQLResponse2);
+        }
 
-		[Fact]
-		public void InEqualityOperatorFact() {
-			var graphQLResponse1 = new GraphQLResponse<object> {
-				Data = new { a = 1 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			var graphQLResponse2 = new GraphQLResponse<object> {
-				Data = new { a = 2 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			Assert.True(graphQLResponse1 != graphQLResponse2);
-		}
+        [Fact]
+        public void InEqualityOperatorFact()
+        {
+            var graphQLResponse1 = new GraphQLResponse<object>
+            {
+                Data = new { a = 1 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            var graphQLResponse2 = new GraphQLResponse<object>
+            {
+                Data = new { a = 2 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            Assert.True(graphQLResponse1 != graphQLResponse2);
+        }
 
-		[Fact]
-		public void GetHashCodeFact() {
-			var graphQLResponse1 = new GraphQLResponse<object> {
-				Data = new { a = 1 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			var graphQLResponse2 = new GraphQLResponse<object> {
-				Data = new { a = 1 },
-				Errors = new[] { new GraphQLError { Message = "message" } }
-			};
-			Assert.True(graphQLResponse1.GetHashCode() == graphQLResponse2.GetHashCode());
-		}
+        [Fact]
+        public void GetHashCodeFact()
+        {
+            var graphQLResponse1 = new GraphQLResponse<object>
+            {
+                Data = new { a = 1 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            var graphQLResponse2 = new GraphQLResponse<object>
+            {
+                Data = new { a = 1 },
+                Errors = new[] { new GraphQLError { Message = "message" } }
+            };
+            Assert.True(graphQLResponse1.GetHashCode() == graphQLResponse2.GetHashCode());
+        }
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
index 3dbdb828..da1ccf02 100644
--- a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
@@ -3,28 +3,33 @@
 using FluentAssertions;
 using Xunit;
 
-namespace GraphQL.Primitives.Tests {
-	public class JsonSerializationTests {
+namespace GraphQL.Primitives.Tests
+{
+    public class JsonSerializationTests
+    {
 
-		[Fact]
-		public void WebSocketResponseDeserialization() {
-			var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff" };
-			var json = JsonSerializer.Serialize(testObject);
-			var deserialized = JsonSerializer.Deserialize<TestObject>(json);
-			var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
-			var childObject = (JsonElement) dict["ChildObject"];
-			childObject.GetProperty("Id").GetString().Should().Be(testObject.ChildObject.Id);
-		}
+        [Fact]
+        public void WebSocketResponseDeserialization()
+        {
+            var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff" };
+            var json = JsonSerializer.Serialize(testObject);
+            var deserialized = JsonSerializer.Deserialize<TestObject>(json);
+            var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
+            var childObject = (JsonElement)dict["ChildObject"];
+            childObject.GetProperty("Id").GetString().Should().Be(testObject.ChildObject.Id);
+        }
 
-		public class TestObject {
-			public string Id { get; set; }
+        public class TestObject
+        {
+            public string Id { get; set; }
 
-		}
+        }
 
-		public class ExtendedTestObject : TestObject {
-			public string OtherData { get; set; }
+        public class ExtendedTestObject : TestObject
+        {
+            public string OtherData { get; set; }
 
-			public TestObject ChildObject{ get; set; } = new TestObject {Id = "1337"};
-		}
-	}
+            public TestObject ChildObject { get; set; } = new TestObject { Id = "1337" };
+        }
+    }
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
index 15889373..50f49186 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
@@ -1,27 +1,31 @@
 using System;
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL.Models {
+namespace GraphQL.Server.Test.GraphQL.Models
+{
 
-	public class Repository {
-		public int DatabaseId { get; set; }
-		public string Id { get; set; }
-		public string Name { get; set; }
-		public object Owner { get; set; }
-		public Uri Url { get; set; }
-	}
+    public class Repository
+    {
+        public int DatabaseId { get; set; }
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public object Owner { get; set; }
+        public Uri Url { get; set; }
+    }
 
-	public class RepositoryGraphType : ObjectGraphType<Repository> {
+    public class RepositoryGraphType : ObjectGraphType<Repository>
+    {
 
-		public RepositoryGraphType() {
-			this.Name = nameof(Repository);
-			this.Field(expression => expression.DatabaseId);
-			this.Field<NonNullGraphType<IdGraphType>>("id");
-			this.Field(expression => expression.Name);
-			//this.Field(expression => expression.Owner);
-			this.Field<NonNullGraphType<UriGraphType>>("url");
-		}
+        public RepositoryGraphType()
+        {
+            this.Name = nameof(Repository);
+            this.Field(expression => expression.DatabaseId);
+            this.Field<NonNullGraphType<IdGraphType>>("id");
+            this.Field(expression => expression.Name);
+            //this.Field(expression => expression.Owner);
+            this.Field<NonNullGraphType<UriGraphType>>("url");
+        }
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/Storage.cs b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
index 175390db..613a537a 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Storage.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
@@ -3,20 +3,23 @@
 using System.Linq;
 using GraphQL.Server.Test.GraphQL.Models;
 
-namespace GraphQL.Server.Test.GraphQL {
+namespace GraphQL.Server.Test.GraphQL
+{
 
-	public static class Storage {
+    public static class Storage
+    {
 
-		public static IQueryable<Repository> Repositories { get; } = new List<Repository>()
-			.Append(new Repository {
-				DatabaseId = 113196300,
-				Id = "MDEwOlJlcG9zaXRvcnkxMTMxOTYzMDA=",
-				Name = "graphql-client",
-				Owner = null,
-				Url = new Uri("https://github.com/graphql-dotnet/graphql-client")
-			})
-			.AsQueryable();
+        public static IQueryable<Repository> Repositories { get; } = new List<Repository>()
+            .Append(new Repository
+            {
+                DatabaseId = 113196300,
+                Id = "MDEwOlJlcG9zaXRvcnkxMTMxOTYzMDA=",
+                Name = "graphql-client",
+                Owner = null,
+                Url = new Uri("https://github.com/graphql-dotnet/graphql-client")
+            })
+            .AsQueryable();
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
index 07e801e4..a1077dc6 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
@@ -1,12 +1,15 @@
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL {
+namespace GraphQL.Server.Test.GraphQL
+{
 
-	public class TestMutation : ObjectGraphType {
+    public class TestMutation : ObjectGraphType
+    {
 
-		public TestMutation() {
-		}
+        public TestMutation()
+        {
+        }
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index 1950c967..630e793e 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -2,18 +2,22 @@
 using GraphQL.Server.Test.GraphQL.Models;
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL {
+namespace GraphQL.Server.Test.GraphQL
+{
 
-	public class TestQuery : ObjectGraphType {
+    public class TestQuery : ObjectGraphType
+    {
 
-		public TestQuery() {
-			this.Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context => {
-				var owner = context.GetArgument<string>("owner");
-				var name = context.GetArgument<string>("name");
-				return Storage.Repositories.FirstOrDefault(predicate => predicate.Name == name);
-			});
-		}
+        public TestQuery()
+        {
+            this.Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context =>
+            {
+                var owner = context.GetArgument<string>("owner");
+                var name = context.GetArgument<string>("name");
+                return Storage.Repositories.FirstOrDefault(predicate => predicate.Name == name);
+            });
+        }
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
index 1457cf03..efdfebb9 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
@@ -1,15 +1,18 @@
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL {
+namespace GraphQL.Server.Test.GraphQL
+{
 
-	public class TestSchema : Schema {
+    public class TestSchema : Schema
+    {
 
-		public TestSchema() {
-			this.Query = new TestQuery();
-			//this.Mutation = new TestMutation();
-			//this.Subscription = new TestSubscription();
-		}
+        public TestSchema()
+        {
+            this.Query = new TestQuery();
+            //this.Mutation = new TestMutation();
+            //this.Subscription = new TestSubscription();
+        }
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
index c85a14ce..f6d50470 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
@@ -1,12 +1,15 @@
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL {
+namespace GraphQL.Server.Test.GraphQL
+{
 
-	public class TestSubscription : ObjectGraphType {
+    public class TestSubscription : ObjectGraphType
+    {
 
-		public TestSubscription() {
-		}
+        public TestSubscription()
+        {
+        }
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Server.Test/Program.cs b/tests/GraphQL.Server.Test/Program.cs
index 29155449..2b5c329a 100644
--- a/tests/GraphQL.Server.Test/Program.cs
+++ b/tests/GraphQL.Server.Test/Program.cs
@@ -2,18 +2,20 @@
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 
-namespace GraphQL.Server.Test {
+namespace GraphQL.Server.Test
+{
 
-	public class Program {
+    public class Program
+    {
 
-		public static async Task Main(string[] args) =>
-			await CreateHostBuilder(args).Build().RunAsync();
+        public static async Task Main(string[] args) =>
+            await CreateHostBuilder(args).Build().RunAsync();
 
-		public static IWebHostBuilder CreateHostBuilder(string[] args = null) =>
-			WebHost.CreateDefaultBuilder(args)
-				.UseKestrel(options => { options.AllowSynchronousIO = true; })
-				.UseStartup<Startup>();
+        public static IWebHostBuilder CreateHostBuilder(string[] args = null) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseKestrel(options => { options.AllowSynchronousIO = true; })
+                .UseStartup<Startup>();
 
-	}
+    }
 
 }
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index f2b257c1..cc1180ab 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -6,37 +6,44 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
-namespace GraphQL.Server.Test {
-
-	public class Startup {
-
-		public IConfiguration Configuration { get; }
-
-		public Startup(IConfiguration configuration) {
-			this.Configuration = configuration;
-		}
-
-		public void Configure(IApplicationBuilder app) {
-			var webHostEnvironment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
-			if (webHostEnvironment.IsDevelopment()) {
-				app.UseDeveloperExceptionPage();
-			}
-			app.UseHttpsRedirection();
-
-			app.UseWebSockets();
-			app.UseGraphQLWebSockets<TestSchema>();
-			app.UseGraphQL<TestSchema>();
-			app.UseGraphiQLServer(new GraphiQLOptions { });
-		}
-
-		public void ConfigureServices(IServiceCollection services) {
-			services.AddSingleton<TestSchema>();
-			services.AddGraphQL(options => {
-				options.EnableMetrics = true;
-				options.ExposeExceptions = true;
-			}).AddWebSockets();
-		}
-
-	}
+namespace GraphQL.Server.Test
+{
+
+    public class Startup
+    {
+
+        public IConfiguration Configuration { get; }
+
+        public Startup(IConfiguration configuration)
+        {
+            this.Configuration = configuration;
+        }
+
+        public void Configure(IApplicationBuilder app)
+        {
+            var webHostEnvironment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
+            if (webHostEnvironment.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+            app.UseHttpsRedirection();
+
+            app.UseWebSockets();
+            app.UseGraphQLWebSockets<TestSchema>();
+            app.UseGraphQL<TestSchema>();
+            app.UseGraphiQLServer(new GraphiQLOptions { });
+        }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddSingleton<TestSchema>();
+            services.AddGraphQL(options =>
+            {
+                options.EnableMetrics = true;
+                options.ExposeExceptions = true;
+            }).AddWebSockets();
+        }
+
+    }
 
 }
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index ec3530e1..c6ab7df6 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -2,15 +2,18 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Logging;
 
-namespace IntegrationTestServer {
-	public class Program {
-		public static void Main(string[] args) {
-			CreateWebHostBuilder(args).Build().Run();
-		}
+namespace IntegrationTestServer
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            CreateWebHostBuilder(args).Build().Run();
+        }
 
-		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
-			WebHost.CreateDefaultBuilder(args)
-				.UseStartup<Startup>()
-				.ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
-	}
+        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseStartup<Startup>()
+                .ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
+    }
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 2f25f733..1fad77cb 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -13,59 +13,68 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
-namespace IntegrationTestServer {
-	public class Startup {
-		public Startup(IConfiguration configuration, IWebHostEnvironment environment) {
-			Configuration = configuration;
-			Environment = environment;
-		}
+namespace IntegrationTestServer
+{
+    public class Startup
+    {
+        public Startup(IConfiguration configuration, IWebHostEnvironment environment)
+        {
+            Configuration = configuration;
+            Environment = environment;
+        }
 
-		public IConfiguration Configuration { get; }
-		public IWebHostEnvironment Environment { get; }
+        public IConfiguration Configuration { get; }
+        public IWebHostEnvironment Environment { get; }
 
-		// This method gets called by the runtime. Use this method to add services to the container.
-		// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
-		public void ConfigureServices(IServiceCollection services) {
-			services.Configure<KestrelServerOptions>(options =>
-			{
-				options.AllowSynchronousIO = true;
-			});
+        // This method gets called by the runtime. Use this method to add services to the container.
+        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.Configure<KestrelServerOptions>(options =>
+            {
+                options.AllowSynchronousIO = true;
+            });
 
-			services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
-			services.AddChatSchema();
-			services.AddStarWarsSchema();
-			services.AddGraphQL(options => {
-				options.EnableMetrics = true;
-				options.ExposeExceptions = Environment.IsDevelopment();
-			})
-				.AddWebSockets();
-		}
+            services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
+            services.AddChatSchema();
+            services.AddStarWarsSchema();
+            services.AddGraphQL(options =>
+            {
+                options.EnableMetrics = true;
+                options.ExposeExceptions = Environment.IsDevelopment();
+            })
+                .AddWebSockets();
+        }
 
-		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
-		public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
-			if (env.IsDevelopment()) {
-				app.UseDeveloperExceptionPage();
-			}
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
 
-			app.UseWebSockets();
+            app.UseWebSockets();
 
-			ConfigureGraphQLSchema<ChatSchema>(app, Common.ChatEndpoint);
-			ConfigureGraphQLSchema<StarWarsSchema>(app, Common.StarWarsEndpoint);
+            ConfigureGraphQLSchema<ChatSchema>(app, Common.ChatEndpoint);
+            ConfigureGraphQLSchema<StarWarsSchema>(app, Common.StarWarsEndpoint);
 
-			app.UseGraphiQLServer(new GraphiQLOptions {
-				GraphiQLPath = "/ui/graphiql",
-				GraphQLEndPoint = Common.StarWarsEndpoint
-			});
-			app.UseGraphQLPlayground(new GraphQLPlaygroundOptions {
-				Path = "/ui/playground",
-				GraphQLEndPoint = Common.ChatEndpoint
-			});
-		}
+            app.UseGraphiQLServer(new GraphiQLOptions
+            {
+                GraphiQLPath = "/ui/graphiql",
+                GraphQLEndPoint = Common.StarWarsEndpoint
+            });
+            app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
+            {
+                Path = "/ui/playground",
+                GraphQLEndPoint = Common.ChatEndpoint
+            });
+        }
 
-		private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema: Schema
-		{
-			app.UseGraphQLWebSockets<TSchema>(endpoint);
-			app.UseGraphQL<TSchema>(endpoint);
-		}
-	}
+        private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema : Schema
+        {
+            app.UseGraphQLWebSockets<TSchema>(endpoint);
+            app.UseGraphQL<TSchema>(endpoint);
+        }
+    }
 }

From 755bd98a2cb7dc855c32742684f31c03a1b1c914 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 20 Mar 2020 22:51:43 +0100
Subject: [PATCH 220/455] fix remaining conde style issues

---
 .../PersonAndFilmsResponse.cs                 |   2 +-
 examples/GraphQL.Client.Example/Program.cs    |   6 +-
 .../GraphQLWebSocketRequest.cs                |  35 +-
 .../GraphQLWebSocketResponse.cs               |  16 +-
 .../GraphQLClientExtensions.cs                |  29 +-
 .../GraphQLJsonSerializerExtensions.cs        |   1 -
 .../GraphQLLocalExecutionClient.cs            |  18 +-
 .../GraphQLExtensionsConverter.cs             |  18 +-
 .../NewtonsoftJsonSerializer.cs               |  34 +-
 .../ImmutableConverter.cs                     |  24 +-
 .../SystemTextJsonSerializer.cs               |  27 +-
 src/GraphQL.Client/GraphQLHttpClient.cs       |  69 ++-
 .../GraphQLHttpClientExtensions.cs            |  11 +-
 src/GraphQL.Client/GraphQLHttpException.cs    |   2 +-
 src/GraphQL.Client/GraphQLHttpResponse.cs     |  10 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 577 +++++++++---------
 src/GraphQL.Primitives/GraphQLError.cs        |  32 +-
 src/GraphQL.Primitives/GraphQLLocation.cs     |  10 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |  29 +-
 src/GraphQL.Primitives/GraphQLResponse.cs     |  30 +-
 .../BaseSerializeNoCamelCaseTest.cs           |   2 -
 .../BaseSerializerTest.cs                     |   2 -
 .../NewtonsoftSerializerTest.cs               |   1 -
 .../TestData/DeserializeResponseTestData.cs   |   8 +-
 .../TestData/SerializeToBytesTestData.cs      |   6 +-
 .../TestData/SerializeToStringTestData.cs     |   6 +-
 .../Chat/AddMessageVariables.cs               |   2 -
 .../Chat/GraphQLClientChatExtensions.cs       |   4 +-
 .../Chat/Schema/ChatQuery.cs                  |   1 -
 .../Chat/Schema/IChat.cs                      |  24 +-
 tests/GraphQL.Client.Tests.Common/Common.cs   |   4 +-
 .../Helpers/AvailableJsonSerializers.cs       |   5 +-
 .../Helpers/CallbackMonitor.cs                |  21 +-
 .../Helpers/ConcurrentTaskWrapper.cs          |  43 +-
 .../Helpers/MiscellaneousExtensions.cs        |   6 +-
 .../Helpers/ObservableTester.cs               |  55 +-
 .../StarWars/StarWarsHumans.cs                |   5 +-
 .../Helpers/IntegrationServerTestFixture.cs   |   4 +-
 .../Helpers/WebHostHelpers.cs                 |  24 +-
 .../QueryAndMutationTests/Base.cs             |   1 -
 .../QueryAndMutationTests/Newtonsoft.cs       |   1 -
 .../QueryAndMutationTests/SystemTextJson.cs   |   1 -
 .../WebsocketTests/Base.cs                    |  22 +-
 .../WebsocketTests/Newtonsoft.cs              |   1 -
 .../GraphQL/Models/Repository.cs              |  10 +-
 .../GraphQL.Server.Test/GraphQL/TestQuery.cs  |   2 +-
 .../GraphQL.Server.Test/GraphQL/TestSchema.cs |   2 +-
 tests/GraphQL.Server.Test/Startup.cs          |   2 +-
 tests/IntegrationTestServer/Program.cs        |   5 +-
 tests/IntegrationTestServer/Startup.cs        |   8 +-
 50 files changed, 567 insertions(+), 691 deletions(-)

diff --git a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
index 59ab316f..ea3d7de5 100644
--- a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
+++ b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Http.Examples
+namespace GraphQL.Client.Example
 {
     public class PersonAndFilmsResponse
     {
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index 2a9f4a2f..5dd2b1d6 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -2,9 +2,9 @@
 using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
-using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Client.Http;
 
-namespace GraphQL.Client.Http.Examples
+namespace GraphQL.Client.Example
 {
 
     public class Program
@@ -12,7 +12,7 @@ public class Program
 
         public static async Task Main(string[] args)
         {
-
+            _ = args;
             using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
 
             var personAndFilmsRequest = new GraphQLRequest
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index 1a2a6fb6..7c986acc 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Runtime.Serialization;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client.Abstractions.Websocket
@@ -11,17 +10,17 @@ namespace GraphQL.Client.Abstractions.Websocket
     /// </summary>
     public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<GraphQLWebSocketRequest>
     {
-        public const string IdKey = "id";
-        public const string TypeKey = "type";
-        public const string PayloadKey = "payload";
+        public const string ID_KEY = "id";
+        public const string TYPE_KEY = "type";
+        public const string PAYLOAD_KEY = "payload";
 
         /// <summary>
         /// The Identifier of the Response
         /// </summary>
         public string Id
         {
-            get => ContainsKey(IdKey) ? (string)this[IdKey] : null;
-            set => this[IdKey] = value;
+            get => ContainsKey(ID_KEY) ? (string)this[ID_KEY] : null;
+            set => this[ID_KEY] = value;
         }
 
         /// <summary>
@@ -29,8 +28,8 @@ public string Id
         /// </summary>
         public string Type
         {
-            get => ContainsKey(TypeKey) ? (string)this[TypeKey] : null;
-            set => this[TypeKey] = value;
+            get => ContainsKey(TYPE_KEY) ? (string)this[TYPE_KEY] : null;
+            set => this[TYPE_KEY] = value;
         }
 
         /// <summary>
@@ -38,11 +37,11 @@ public string Type
         /// </summary>
         public GraphQLRequest Payload
         {
-            get => ContainsKey(PayloadKey) ? (GraphQLRequest)this[PayloadKey] : null;
-            set => this[PayloadKey] = value;
+            get => ContainsKey(PAYLOAD_KEY) ? (GraphQLRequest)this[PAYLOAD_KEY] : null;
+            set => this[PAYLOAD_KEY] = value;
         }
 
-        private TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
+        private readonly TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
 
         /// <summary>
         /// Task used to await the actual send operation and to convey potential exceptions
@@ -67,7 +66,7 @@ public GraphQLRequest Payload
         public void SendCanceled() => _tcs.SetCanceled();
 
         /// <inheritdoc />
-        public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketRequest);
+        public override bool Equals(object obj) => Equals(obj as GraphQLWebSocketRequest);
 
         /// <inheritdoc />
         public bool Equals(GraphQLWebSocketRequest other)
@@ -80,15 +79,15 @@ public bool Equals(GraphQLWebSocketRequest other)
             {
                 return true;
             }
-            if (!Equals(this.Id, other.Id))
+            if (!Equals(Id, other.Id))
             {
                 return false;
             }
-            if (!Equals(this.Type, other.Type))
+            if (!Equals(Type, other.Type))
             {
                 return false;
             }
-            if (!Equals(this.Payload, other.Payload))
+            if (!Equals(Payload, other.Payload))
             {
                 return false;
             }
@@ -99,9 +98,9 @@ public bool Equals(GraphQLWebSocketRequest other)
         public override int GetHashCode()
         {
             var hashCode = 9958074;
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
-            hashCode = hashCode * -1521134295 + EqualityComparer<object>.Default.GetHashCode(this.Payload);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Id);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Type);
+            hashCode = hashCode * -1521134295 + EqualityComparer<object>.Default.GetHashCode(Payload);
             return hashCode;
         }
 
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
index 1ab40d70..d6c69a70 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
@@ -21,7 +21,7 @@ public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse>
         public string Type { get; set; }
 
         /// <inheritdoc />
-        public override bool Equals(object obj) => this.Equals(obj as GraphQLWebSocketResponse);
+        public override bool Equals(object obj) => Equals(obj as GraphQLWebSocketResponse);
 
         /// <inheritdoc />
         public bool Equals(GraphQLWebSocketResponse other)
@@ -36,12 +36,12 @@ public bool Equals(GraphQLWebSocketResponse other)
                 return true;
             }
 
-            if (!Equals(this.Id, other.Id))
+            if (!Equals(Id, other.Id))
             {
                 return false;
             }
 
-            if (!Equals(this.Type, other.Type))
+            if (!Equals(Type, other.Type))
             {
                 return false;
             }
@@ -53,8 +53,8 @@ public bool Equals(GraphQLWebSocketResponse other)
         public override int GetHashCode()
         {
             var hashCode = 9958074;
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Id);
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.Type);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Id);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Type);
             return hashCode;
         }
 
@@ -74,7 +74,7 @@ public class GraphQLWebSocketResponse<TPayload> : GraphQLWebSocketResponse, IEqu
 
         public bool Equals(GraphQLWebSocketResponse<TPayload>? other)
         {
-            if (ReferenceEquals(null, other))
+            if (other is null)
                 return false;
             if (ReferenceEquals(this, other))
                 return true;
@@ -83,11 +83,11 @@ public bool Equals(GraphQLWebSocketResponse<TPayload>? other)
 
         public override bool Equals(object? obj)
         {
-            if (ReferenceEquals(null, obj))
+            if (obj is null)
                 return false;
             if (ReferenceEquals(this, obj))
                 return true;
-            if (obj.GetType() != this.GetType())
+            if (obj.GetType() != GetType())
                 return false;
             return Equals((GraphQLWebSocketResponse<TPayload>)obj);
         }
diff --git a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index 44abd469..0c891bf7 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -10,29 +10,46 @@ public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IG
             string query, object? variables = null,
             string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
         {
-            return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
+            _ = defineResponseType;
+            return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
+                cancellationToken: cancellationToken);
         }
+
         public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
             string query, object? variables = null,
             string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
         {
-            return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName), cancellationToken: cancellationToken);
+            _ = defineResponseType;
+            return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
+                cancellationToken: cancellationToken);
         }
 
         public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
             GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-            => client.SendQueryAsync<TResponse>(request, cancellationToken);
+        {
+            _ = defineResponseType;
+            return client.SendQueryAsync<TResponse>(request, cancellationToken);
+        }
 
         public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
             GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-            => client.SendMutationAsync<TResponse>(request, cancellationToken);
+        {
+            _ = defineResponseType;
+            return client.SendMutationAsync<TResponse>(request, cancellationToken);
+        }
 
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
             this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
-            => client.CreateSubscriptionStream<TResponse>(request);
+        {
+            _ = defineResponseType;
+            return client.CreateSubscriptionStream<TResponse>(request);
+        }
 
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
             this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<Exception> exceptionHandler)
-            => client.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+        {
+            _ = defineResponseType;
+            return client.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+        }
     }
 }
diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index d56b847d..ded17d39 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics;
 using System.Linq;
 
 namespace GraphQL.Client.Abstractions
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index c9d00c9a..574cd226 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -29,7 +29,7 @@ public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema,
     public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
     {
 
-        private static readonly JsonSerializerSettings VariablesSerializerSettings = new JsonSerializerSettings
+        private static readonly JsonSerializerSettings _variablesSerializerSettings = new JsonSerializerSettings
         {
             Formatting = Formatting.Indented,
             DateTimeZoneHandling = DateTimeZoneHandling.Local,
@@ -44,7 +44,7 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
         public IGraphQLJsonSerializer Serializer { get; }
 
 
-        private readonly DocumentExecuter documentExecuter;
+        private readonly DocumentExecuter _documentExecuter;
 
         public GraphQLLocalExecutionClient(TSchema schema)
         {
@@ -52,7 +52,7 @@ public GraphQLLocalExecutionClient(TSchema schema)
             Schema = schema;
             if (!Schema.Initialized)
                 Schema.Initialize();
-            documentExecuter = new DocumentExecuter();
+            _documentExecuter = new DocumentExecuter();
         }
 
         public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer) : this(schema)
@@ -68,13 +68,11 @@ public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest
         public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
             => ExecuteQueryAsync<TResponse>(request, cancellationToken);
 
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request)
-        {
-            return Observable.Defer(() => ExecuteSubscriptionAsync<TResponse>(request).ToObservable())
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) =>
+            Observable.Defer(() => ExecuteSubscriptionAsync<TResponse>(request).ToObservable())
                 .Concat()
                 .Publish()
                 .RefCount();
-        }
 
         public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request,
             Action<Exception> exceptionHandler)
@@ -100,11 +98,11 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
 
             var deserializedRequest = JsonConvert.DeserializeObject<GraphQLRequest>(serializedRequest);
             var inputs = deserializedRequest.Variables != null
-                ? (JObject.FromObject(request.Variables, JsonSerializer.Create(VariablesSerializerSettings)) as JObject)
+                ? (JObject.FromObject(request.Variables, JsonSerializer.Create(_variablesSerializerSettings)) as JObject)
                 .ToInputs()
                 : null;
 
-            var result = await documentExecuter.ExecuteAsync(options =>
+            var result = await _documentExecuter.ExecuteAsync(options =>
             {
                 options.Schema = Schema;
                 options.OperationName = request.OperationName;
@@ -119,7 +117,7 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
         private Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponse<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
         {
             // serialize result into utf8 byte stream
-            var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(executionResult, VariablesSerializerSettings)));
+            var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(executionResult, _variablesSerializerSettings)));
             // deserialize using the provided serializer
             return Serializer.DeserializeFromUtf8StreamAsync<TResponse>(resultStream, cancellationToken);
         }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
index ccca9970..6ff25eb3 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
@@ -1,8 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
@@ -10,11 +7,9 @@ namespace GraphQL.Client.Serializer.Newtonsoft
 {
     public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType>
     {
-        public override void WriteJson(JsonWriter writer, GraphQLExtensionsType value, JsonSerializer serializer)
-        {
+        public override void WriteJson(JsonWriter writer, GraphQLExtensionsType value, JsonSerializer serializer) =>
             throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
-        }
 
         public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectType, GraphQLExtensionsType existingValue,
             bool hasExistingValue, JsonSerializer serializer)
@@ -28,9 +23,8 @@ public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectTyp
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
         }
 
-        private object ReadToken(JToken? token)
-        {
-            return token.Type switch
+        private object ReadToken(JToken? token) =>
+            token.Type switch
             {
                 JTokenType.Undefined => null,
                 JTokenType.None => null,
@@ -52,7 +46,6 @@ private object ReadToken(JToken? token)
                 JTokenType.Comment => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON comment"),
                 _ => throw new ArgumentOutOfRangeException(nameof(token.Type))
             };
-        }
 
         private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionary : Dictionary<string, object>
         {
@@ -76,9 +69,6 @@ private IEnumerable<object> ReadArray(JToken element)
             }
         }
 
-        private bool IsUnsupportedJTokenType(JTokenType type)
-        {
-            return type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
-        }
+        private bool IsUnsupportedJTokenType(JTokenType type) => type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
     }
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index ca30e64c..3c6d6c5d 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -30,45 +30,31 @@ public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
             ConfigureMandatorySerializerOptions();
         }
 
-        private void ConfigureMandatorySerializerOptions()
-        {
-            // deserialize extensions to Dictionary<string, object>
-            JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
-        }
+        // deserialize extensions to Dictionary<string, object>
+        private void ConfigureMandatorySerializerOptions() => JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
 
-        public string SerializeToString(GraphQL.GraphQLRequest request)
-        {
-            return JsonConvert.SerializeObject(request, JsonSerializerSettings);
-        }
+        public string SerializeToString(GraphQLRequest request) => JsonConvert.SerializeObject(request, JsonSerializerSettings);
 
-        public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request)
+        public byte[] SerializeToBytes(GraphQLWebSocketRequest request)
         {
             var json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
             return Encoding.UTF8.GetBytes(json);
         }
 
-        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream)
-        {
-            return DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
-        }
+        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
 
-        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes)
-        {
-            return JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
+        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
+            JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
                 JsonSerializerSettings);
-        }
 
-        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken)
-        {
-            return DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
-        }
+        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
 
 
         private Task<T> DeserializeFromUtf8Stream<T>(Stream stream)
         {
-            using StreamReader sr = new StreamReader(stream);
+            using var sr = new StreamReader(stream);
             using JsonReader reader = new JsonTextReader(sr);
-            JsonSerializer serializer = JsonSerializer.Create(JsonSerializerSettings);
+            var serializer = JsonSerializer.Create(JsonSerializerSettings);
             return Task.FromResult(serializer.Deserialize<T>(reader));
         }
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index c87eb4cd..78b5811b 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -117,10 +117,7 @@ public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOp
             JsonSerializer.Serialize(writer, value, strippedOptions);
         }
 
-        private static PropertyInfo[] GetProperties(IReflect typeToConvert)
-        {
-            return typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
-        }
+        private static PropertyInfo[] GetProperties(IReflect typeToConvert) => typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 
         private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(JsonSerializerOptions options, IEnumerable<PropertyInfo> properties)
         {
@@ -151,10 +148,7 @@ private static string ConvertAndNormalizeName(string name, JsonSerializerOptions
             return options.PropertyNameCaseInsensitive ? convertedName.ToLowerInvariant() : convertedName;
         }
 
-        private static string NormalizeName(string name, JsonSerializerOptions options)
-        {
-            return options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
-        }
+        private static string NormalizeName(string name, JsonSerializerOptions options) => options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
     }
 
     internal static class NameOfPropertyAndParameter
@@ -187,13 +181,11 @@ public static bool Matches(string propertyName, string parameterName, bool anony
     internal static class TypeExtensions
     {
         // copied from https://github.com/dahomey-technologies/Dahomey.Json/blob/master/src/Dahomey.Json/Util/TypeExtensions.cs
-        public static bool IsAnonymous(this Type type)
-        {
-            return type.Namespace == null
-                   && type.IsSealed
-                   && type.BaseType == typeof(object)
-                   && !type.IsPublic
-                   && type.IsDefined(typeof(CompilerGeneratedAttribute), false);
-        }
+        public static bool IsAnonymous(this Type type) =>
+            type.Namespace == null
+            && type.IsSealed
+            && type.BaseType == typeof(object)
+            && !type.IsPublic
+            && type.IsDefined(typeof(CompilerGeneratedAttribute), false);
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index de7be686..047c7572 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -35,31 +35,16 @@ private void ConfigureMandatorySerializerOptions()
             Options.PropertyNameCaseInsensitive = true;
         }
 
-        public string SerializeToString(GraphQL.GraphQLRequest request)
-        {
-            return JsonSerializer.Serialize(request, Options);
-        }
+        public string SerializeToString(GraphQLRequest request) => JsonSerializer.Serialize(request, Options);
 
-        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken)
-        {
-            return JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options, cancellationToken).AsTask();
-        }
+        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options, cancellationToken).AsTask();
 
-        public byte[] SerializeToBytes(Abstractions.Websocket.GraphQLWebSocketRequest request)
-        {
-            return JsonSerializer.SerializeToUtf8Bytes(request, Options);
-        }
+        public byte[] SerializeToBytes(GraphQLWebSocketRequest request) => JsonSerializer.SerializeToUtf8Bytes(request, Options);
 
-        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream)
-        {
-            return JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
-        }
+        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
 
-        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes)
-        {
-            return JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
+        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
+            JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
                 Options);
-        }
-
     }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 2734e3e3..a6a7a763 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -2,7 +2,6 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Net.Http;
-using System.Net.Http.Headers;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,9 +16,9 @@ namespace GraphQL.Client.Http
     public class GraphQLHttpClient : IGraphQLClient
     {
 
-        private readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
-        private readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-        private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
+        private readonly GraphQLHttpWebSocket _graphQlHttpWebSocket;
+        private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+        private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
         private IGraphQLWebsocketJsonSerializer JsonSerializer => Options.JsonSerializer;
 
         /// <summary>
@@ -35,13 +34,13 @@ public class GraphQLHttpClient : IGraphQLClient
         /// <summary>
         /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
         /// </summary>
-        public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
+        public IObservable<Exception> WebSocketReceiveErrors => _graphQlHttpWebSocket.ReceiveErrors;
 
         /// <summary>
         /// the websocket connection state
         /// </summary>
         public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState =>
-            graphQlHttpWebSocket.ConnectionState;
+            _graphQlHttpWebSocket.ConnectionState;
 
         #region Constructors
 
@@ -59,8 +58,8 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
         {
             Options = options ?? throw new ArgumentNullException(nameof(options));
             Options.JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
-            this.HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
-            this.graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
+            HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
+            _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
         }
 
         #endregion
@@ -71,9 +70,9 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient
         public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             if (Options.UseWebSocketForQueriesAndMutations)
-                return await this.graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
+                return await _graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
 
-            return await this.SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
+            return await SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
         }
 
         /// <inheritdoc />
@@ -84,33 +83,33 @@ public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequ
         /// <inheritdoc />
         public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request)
         {
-            if (disposed)
+            if (_disposed)
                 throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
             var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
 
-            if (subscriptionStreams.ContainsKey(key))
-                return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
+            if (_subscriptionStreams.ContainsKey(key))
+                return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
+            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
 
-            subscriptionStreams.TryAdd(key, observable);
+            _subscriptionStreams.TryAdd(key, observable);
             return observable;
         }
 
         /// <inheritdoc />
         public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler)
         {
-            if (disposed)
+            if (_disposed)
                 throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
             var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
 
-            if (subscriptionStreams.ContainsKey(key))
-                return (IObservable<GraphQLResponse<TResponse>>)subscriptionStreams[key];
+            if (_subscriptionStreams.ContainsKey(key))
+                return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
-            subscriptionStreams.TryAdd(key, observable);
+            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+            _subscriptionStreams.TryAdd(key, observable);
             return observable;
         }
 
@@ -120,15 +119,15 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         /// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
         /// </summary>
         /// <returns></returns>
-        public Task InitializeWebsocketConnection() => graphQlHttpWebSocket.InitializeWebSocket();
+        public Task InitializeWebsocketConnection() => _graphQlHttpWebSocket.InitializeWebSocket();
 
         #region Private Methods
 
         private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var preprocessedRequest = await Options.PreprocessRequest(request, this);
-            using var httpRequestMessage = this.GenerateHttpRequestMessage(preprocessedRequest);
-            using var httpResponseMessage = await this.HttpClient.SendAsync(httpRequestMessage, cancellationToken);
+            using var httpRequestMessage = GenerateHttpRequestMessage(preprocessedRequest);
+            using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, cancellationToken);
             if (!httpResponseMessage.IsSuccessStatusCode)
             {
                 throw new GraphQLHttpException(httpResponseMessage);
@@ -141,7 +140,7 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TRes
 
         private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request)
         {
-            var message = new HttpRequestMessage(HttpMethod.Post, this.Options.EndPoint)
+            var message = new HttpRequestMessage(HttpMethod.Post, Options.EndPoint)
             {
                 Content = new StringContent(JsonSerializer.SerializeToString(request), Encoding.UTF8, Options.MediaType)
             };
@@ -154,8 +153,8 @@ private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request)
 
         private Uri GetWebSocketUri()
         {
-            var webSocketSchema = this.Options.EndPoint.Scheme == "https" ? "wss" : "ws";
-            return new Uri($"{webSocketSchema}://{this.Options.EndPoint.Host}:{this.Options.EndPoint.Port}{this.Options.EndPoint.AbsolutePath}");
+            var webSocketSchema = Options.EndPoint.Scheme == "https" ? "wss" : "ws";
+            return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}");
         }
 
         #endregion
@@ -168,26 +167,26 @@ private Uri GetWebSocketUri()
         /// </summary>
         public void Dispose()
         {
-            lock (disposeLocker)
+            lock (_disposeLocker)
             {
-                if (!disposed)
+                if (!_disposed)
                 {
                     _dispose();
                 }
             }
         }
 
-        private bool disposed = false;
-        private readonly object disposeLocker = new object();
+        private bool _disposed = false;
+        private readonly object _disposeLocker = new object();
 
         private void _dispose()
         {
-            disposed = true;
+            _disposed = true;
             Debug.WriteLine($"disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
-            cancellationTokenSource.Cancel();
-            this.HttpClient.Dispose();
-            this.graphQlHttpWebSocket.Dispose();
-            cancellationTokenSource.Dispose();
+            _cancellationTokenSource.Cancel();
+            HttpClient.Dispose();
+            _graphQlHttpWebSocket.Dispose();
+            _cancellationTokenSource.Dispose();
         }
 
         #endregion
diff --git a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index 99409d12..99886c0c 100644
--- a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -18,19 +18,20 @@ public static class GraphQLHttpClientExtensions
         /// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
         /// <returns>an observable stream for the specified subscription</returns>
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(this IGraphQLClient client,
-            GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
-        {
-            return client.CreateSubscriptionStream<TResponse>(request, e =>
+            GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) =>
+            client.CreateSubscriptionStream<TResponse>(request, e =>
             {
                 if (e is WebSocketException webSocketException)
                     webSocketExceptionHandler(webSocketException);
                 else
                     throw e;
             });
-        }
 
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
             this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
-            => client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
+        {
+            _ = defineResponseType;
+            return client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
+        }
     }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpException.cs b/src/GraphQL.Client/GraphQLHttpException.cs
index 4a606507..d30bd759 100644
--- a/src/GraphQL.Client/GraphQLHttpException.cs
+++ b/src/GraphQL.Client/GraphQLHttpException.cs
@@ -21,7 +21,7 @@ public class GraphQLHttpException : Exception
         /// <param name="httpResponseMessage">The unexpected <see cref="System.Net.Http.HttpResponseMessage"/></param>
         public GraphQLHttpException(HttpResponseMessage httpResponseMessage) : base($"Unexpected {nameof(System.Net.Http.HttpResponseMessage)} with code: {httpResponseMessage?.StatusCode}")
         {
-            this.HttpResponseMessage = httpResponseMessage ?? throw new ArgumentNullException(nameof(httpResponseMessage));
+            HttpResponseMessage = httpResponseMessage ?? throw new ArgumentNullException(nameof(httpResponseMessage));
         }
 
     }
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index 06669984..73a4cea8 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -22,10 +22,7 @@ public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders resp
 
     public static class GraphQLResponseExtensions
     {
-        public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode)
-        {
-            return new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
-        }
+        public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) => new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
 
         /// <summary>
         /// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws ig the cast fails.
@@ -34,9 +31,6 @@ public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLRespon
         /// <param name="response"></param>
         /// <exception cref="InvalidCastException"><paramref name="response"/> is not a <see cref="GraphQLHttpResponse{T}"/></exception>
         /// <returns></returns>
-        public static GraphQLHttpResponse<T> AsGraphQLHttpResponse<T>(this GraphQLResponse<T> response)
-        {
-            return (GraphQLHttpResponse<T>)response;
-        }
+        public static GraphQLHttpResponse<T> AsGraphQLHttpResponse<T>(this GraphQLResponse<T> response) => (GraphQLHttpResponse<T>)response;
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index cab0f1d2..50351075 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -19,31 +19,31 @@ internal class GraphQLHttpWebSocket : IDisposable
 
         #region Private fields
 
-        private readonly Uri webSocketUri;
-        private readonly GraphQLHttpClient client;
-        private readonly ArraySegment<byte> buffer;
-        private readonly CancellationTokenSource internalCancellationTokenSource = new CancellationTokenSource();
-        private readonly CancellationToken internalCancellationToken;
-        private readonly Subject<GraphQLWebSocketRequest> requestSubject = new Subject<GraphQLWebSocketRequest>();
-        private readonly Subject<Exception> exceptionSubject = new Subject<Exception>();
-        private readonly BehaviorSubject<GraphQLWebsocketConnectionState> stateSubject =
+        private readonly Uri _webSocketUri;
+        private readonly GraphQLHttpClient _client;
+        private readonly ArraySegment<byte> _buffer;
+        private readonly CancellationTokenSource _internalCancellationTokenSource = new CancellationTokenSource();
+        private readonly CancellationToken _internalCancellationToken;
+        private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+        private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
+        private readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject =
             new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
-        private readonly IDisposable requestSubscription;
-        private readonly EventLoopScheduler receiveLoopScheduler = new EventLoopScheduler();
-        private readonly EventLoopScheduler sendLoopScheduler = new EventLoopScheduler();
+        private readonly IDisposable _requestSubscription;
+        private readonly EventLoopScheduler _receiveLoopScheduler = new EventLoopScheduler();
+        private readonly EventLoopScheduler _sendLoopScheduler = new EventLoopScheduler();
 
-        private int connectionAttempt = 0;
-        private IConnectableObservable<WebsocketMessageWrapper> incomingMessages;
-        private IDisposable incomingMessagesConnection;
-        private GraphQLHttpClientOptions Options => client.Options;
+        private int _connectionAttempt = 0;
+        private IConnectableObservable<WebsocketMessageWrapper> _incomingMessages;
+        private IDisposable _incomingMessagesConnection;
+        private GraphQLHttpClientOptions Options => _client.Options;
 
-        private Task initializeWebSocketTask = Task.CompletedTask;
-        private readonly object initializeLock = new object();
+        private Task _initializeWebSocketTask = Task.CompletedTask;
+        private readonly object _initializeLock = new object();
 
 #if NETFRAMEWORK
-		private WebSocket clientWebSocket = null;
+		private WebSocket _clientWebSocket = null;
 #else
-        private ClientWebSocket clientWebSocket = null;
+        private ClientWebSocket _clientWebSocket = null;
 #endif
 
         #endregion
@@ -54,17 +54,17 @@ internal class GraphQLHttpWebSocket : IDisposable
         /// <summary>
         /// The current websocket state
         /// </summary>
-        public WebSocketState WebSocketState => clientWebSocket?.State ?? WebSocketState.None;
+        public WebSocketState WebSocketState => _clientWebSocket?.State ?? WebSocketState.None;
 
         /// <summary>
         /// Publishes all errors which occur within the receive pipeline
         /// </summary>
-        public IObservable<Exception> ReceiveErrors => exceptionSubject.AsObservable();
+        public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
 
         /// <summary>
         /// Publishes the connection state of the <see cref="GraphQLHttpWebSocket"/>
         /// </summary>
-        public IObservable<GraphQLWebsocketConnectionState> ConnectionState => stateSubject.DistinctUntilChanged();
+        public IObservable<GraphQLWebsocketConnectionState> ConnectionState => _stateSubject.DistinctUntilChanged();
 
         /// <summary>
         /// Publishes all messages which are received on the websocket
@@ -76,17 +76,17 @@ internal class GraphQLHttpWebSocket : IDisposable
 
         public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
         {
-            internalCancellationToken = internalCancellationTokenSource.Token;
-            this.webSocketUri = webSocketUri;
-            this.client = client;
-            buffer = new ArraySegment<byte>(new byte[8192]);
+            _internalCancellationToken = _internalCancellationTokenSource.Token;
+            _webSocketUri = webSocketUri;
+            _client = client;
+            _buffer = new ArraySegment<byte>(new byte[8192]);
             IncomingMessageStream = GetMessageStream();
-            receiveLoopScheduler.Schedule(() =>
+            _receiveLoopScheduler.Schedule(() =>
                 Debug.WriteLine($"receive loop scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
-            requestSubscription = requestSubject
-                .ObserveOn(sendLoopScheduler)
-                .Subscribe(async request => await SendWebSocketRequest(request));
+            _requestSubscription = _requestSubject
+                .ObserveOn(_sendLoopScheduler)
+                .Subscribe(async request => await SendWebSocketRequestAsync(request));
         }
 
 
@@ -99,125 +99,124 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
         /// <param name="request">the <see cref="GraphQLRequest"/> to start the subscription</param>
         /// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
         /// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler = null)
-        {
-            return Observable.Defer(() =>
-                Observable.Create<GraphQLResponse<TResponse>>(async observer =>
-                {
-                    Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
-                    await client.Options.PreprocessRequest(request, client);
-                    var startRequest = new GraphQLWebSocketRequest
-                    {
-                        Id = Guid.NewGuid().ToString("N"),
-                        Type = GraphQLWebSocketMessageType.GQL_START,
-                        Payload = request
-                    };
-                    var closeRequest = new GraphQLWebSocketRequest
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler = null) =>
+            Observable.Defer(() =>
+                    Observable.Create<GraphQLResponse<TResponse>>(async observer =>
                     {
-                        Id = startRequest.Id,
-                        Type = GraphQLWebSocketMessageType.GQL_STOP
-                    };
-                    var initRequest = new GraphQLWebSocketRequest
-                    {
-                        Id = startRequest.Id,
-                        Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                    };
+                        Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
+                        await _client.Options.PreprocessRequest(request, _client);
+                        var startRequest = new GraphQLWebSocketRequest
+                        {
+                            Id = Guid.NewGuid().ToString("N"),
+                            Type = GraphQLWebSocketMessageType.GQL_START,
+                            Payload = request
+                        };
+                        var closeRequest = new GraphQLWebSocketRequest
+                        {
+                            Id = startRequest.Id,
+                            Type = GraphQLWebSocketMessageType.GQL_STOP
+                        };
+                        var initRequest = new GraphQLWebSocketRequest
+                        {
+                            Id = startRequest.Id,
+                            Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+                        };
+
+                        var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
+                            IncomingMessageStream
+                                // ignore null values and messages for other requests
+                                .Where(response => response != null && response.Id == startRequest.Id)
+                                .Subscribe(response =>
+                                    {
+                                        // terminate the sequence when a 'complete' message is received
+                                        if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                                        {
+                                            Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+                                            o.OnCompleted();
+                                            return;
+                                        }
+
+                                        // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+                                        Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+                                        var typedResponse =
+                                            _client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                                response.MessageBytes);
+                                        o.OnNext(typedResponse.Payload);
+
+                                        // in case of a GraphQL error, terminate the sequence after the response has been posted
+                                        if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
+                                        {
+                                            Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+                                            o.OnCompleted();
+                                        }
+                                    },
+                                    e =>
+                                    {
+                                        Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
+                                        o.OnError(e);
+                                    },
+                                    () =>
+                                    {
+                                        Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+                                        o.OnCompleted();
+                                    })
+                        );
+
+                        try
+                        {
+                            // initialize websocket (completes immediately if socket is already open)
+                            await InitializeWebSocket();
+                        }
+                        catch (Exception e)
+                        {
+                            // subscribe observer to failed observable
+                            return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+                        }
 
-                    var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
-                        IncomingMessageStream
-                            // ignore null values and messages for other requests
-                            .Where(response => response != null && response.Id == startRequest.Id)
-                            .Subscribe(response =>
+                        var disposable = new CompositeDisposable(
+                            observable.Subscribe(observer),
+                            Disposable.Create(async () =>
                             {
-                                // terminate the sequence when a 'complete' message is received
-                                if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-                                {
-                                    Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-                                    o.OnCompleted();
+                                // only try to send close request on open websocket
+                                if (WebSocketState != WebSocketState.Open)
                                     return;
-                                }
 
-                                // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-                                Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
-                                var typedResponse =
-                                    client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-                                        response.MessageBytes);
-                                o.OnNext(typedResponse.Payload);
-
-                                // in case of a GraphQL error, terminate the sequence after the response has been posted
-                                if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
+                                try
                                 {
-                                    Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
-                                    o.OnCompleted();
+                                    Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
+                                    await QueueWebSocketRequest(closeRequest);
                                 }
-                            },
-                                e =>
-                                {
-                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
-                                    o.OnError(e);
-                                },
-                                () =>
-                                {
-                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
-                                    o.OnCompleted();
-                                })
-                    );
-
-                    try
-                    {
-                        // initialize websocket (completes immediately if socket is already open)
-                        await InitializeWebSocket();
-                    }
-                    catch (Exception e)
-                    {
-                        // subscribe observer to failed observable
-                        return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-                    }
-
-                    var disposable = new CompositeDisposable(
-                        observable.Subscribe(observer),
-                        Disposable.Create(async () =>
+                                // do not break on disposing
+                                catch (OperationCanceledException) { }
+                            })
+                        );
+
+                        // send connection init
+                        Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
+                        try
                         {
-                            // only try to send close request on open websocket
-                            if (WebSocketState != WebSocketState.Open)
-                                return;
-
-                            try
-                            {
-                                Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-                                await QueueWebSocketRequest(closeRequest);
-                            }
-                            // do not break on disposing
-                            catch (OperationCanceledException) { }
-                        })
-                    );
-
-                    // send connection init
-                    Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
-                    try
-                    {
-                        await QueueWebSocketRequest(initRequest);
-                    }
-                    catch (Exception e)
-                    {
-                        Console.WriteLine(e);
-                        throw;
-                    }
+                            await QueueWebSocketRequest(initRequest);
+                        }
+                        catch (Exception e)
+                        {
+                            Console.WriteLine(e);
+                            throw;
+                        }
 
-                    Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
-                    // send subscription request
-                    try
-                    {
-                        await QueueWebSocketRequest(startRequest);
-                    }
-                    catch (Exception e)
-                    {
-                        Console.WriteLine(e);
-                        throw;
-                    }
+                        Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+                        // send subscription request
+                        try
+                        {
+                            await QueueWebSocketRequest(startRequest);
+                        }
+                        catch (Exception e)
+                        {
+                            Console.WriteLine(e);
+                            throw;
+                        }
 
-                    return disposable;
-                }))
+                        return disposable;
+                    }))
                 // complete sequence on OperationCanceledException, this is triggered by the cancellation token
                 .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
                     Observable.Empty<GraphQLResponse<TResponse>>())
@@ -242,7 +241,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         }
 
                         // throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-                        if (internalCancellationToken.IsCancellationRequested)
+                        if (_internalCancellationToken.IsCancellationRequested)
                             return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
                         else
                         {
@@ -272,7 +271,6 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                 })
                 // transform to hot observable and auto-connect
                 .Publish().RefCount();
-        }
 
         /// <summary>
         /// Send a regular GraphQL request (query, mutation) via websocket
@@ -281,76 +279,74 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         /// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
         /// <param name="cancellationToken">the token to cancel the request</param>
         /// <returns></returns>
-        public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-        {
-            return Observable.Create<GraphQLResponse<TResponse>>(async observer =>
-            {
-                await client.Options.PreprocessRequest(request, client);
-                var websocketRequest = new GraphQLWebSocketRequest
+        public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) =>
+            Observable.Create<GraphQLResponse<TResponse>>(async observer =>
                 {
-                    Id = Guid.NewGuid().ToString("N"),
-                    Type = GraphQLWebSocketMessageType.GQL_START,
-                    Payload = request
-                };
-                var observable = IncomingMessageStream
-                    .Where(response => response != null && response.Id == websocketRequest.Id)
-                    .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-                    .Select(response =>
+                    await _client.Options.PreprocessRequest(request, _client);
+                    var websocketRequest = new GraphQLWebSocketRequest
                     {
-                        Debug.WriteLine($"received response for request {websocketRequest.Id}");
-                        var typedResponse =
-                            client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-                                response.MessageBytes);
-                        return typedResponse.Payload;
-                    });
+                        Id = Guid.NewGuid().ToString("N"),
+                        Type = GraphQLWebSocketMessageType.GQL_START,
+                        Payload = request
+                    };
+                    var observable = IncomingMessageStream
+                        .Where(response => response != null && response.Id == websocketRequest.Id)
+                        .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                        .Select(response =>
+                        {
+                            Debug.WriteLine($"received response for request {websocketRequest.Id}");
+                            var typedResponse =
+                                _client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                    response.MessageBytes);
+                            return typedResponse.Payload;
+                        });
 
-                try
-                {
-                    // initialize websocket (completes immediately if socket is already open)
-                    await InitializeWebSocket();
-                }
-                catch (Exception e)
-                {
-                    // subscribe observer to failed observable
-                    return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-                }
+                    try
+                    {
+                        // initialize websocket (completes immediately if socket is already open)
+                        await InitializeWebSocket();
+                    }
+                    catch (Exception e)
+                    {
+                        // subscribe observer to failed observable
+                        return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+                    }
 
-                var disposable = new CompositeDisposable(
-                    observable.Subscribe(observer)
-                );
+                    var disposable = new CompositeDisposable(
+                        observable.Subscribe(observer)
+                    );
 
-                Debug.WriteLine($"submitting request {websocketRequest.Id}");
-                // send request
-                try
-                {
-                    await QueueWebSocketRequest(websocketRequest);
-                }
-                catch (Exception e)
-                {
-                    Console.WriteLine(e);
-                    throw;
-                }
+                    Debug.WriteLine($"submitting request {websocketRequest.Id}");
+                    // send request
+                    try
+                    {
+                        await QueueWebSocketRequest(websocketRequest);
+                    }
+                    catch (Exception e)
+                    {
+                        Console.WriteLine(e);
+                        throw;
+                    }
 
-                return disposable;
-            })
-            // complete sequence on OperationCanceledException, this is triggered by the cancellation token
-            .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-                Observable.Empty<GraphQLResponse<TResponse>>())
-            .FirstAsync()
-            .ToTask(cancellationToken);
-        }
+                    return disposable;
+                })
+                // complete sequence on OperationCanceledException, this is triggered by the cancellation token
+                .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+                    Observable.Empty<GraphQLResponse<TResponse>>())
+                .FirstAsync()
+                .ToTask(cancellationToken);
 
         private Task QueueWebSocketRequest(GraphQLWebSocketRequest request)
         {
-            requestSubject.OnNext(request);
+            _requestSubject.OnNext(request);
             return request.SendTask();
         }
 
-        private async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
+        private async Task SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
         {
             try
             {
-                if (internalCancellationToken.IsCancellationRequested)
+                if (_internalCancellationToken.IsCancellationRequested)
                 {
                     request.SendCanceled();
                     return;
@@ -358,11 +354,11 @@ private async Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 
                 await InitializeWebSocket();
                 var requestBytes = Options.JsonSerializer.SerializeToBytes(request);
-                await this.clientWebSocket.SendAsync(
+                await _clientWebSocket.SendAsync(
                     new ArraySegment<byte>(requestBytes),
                     WebSocketMessageType.Text,
                     true,
-                    internalCancellationToken);
+                    _internalCancellationToken);
                 request.SendCompleted();
             }
             catch (Exception e)
@@ -379,26 +375,26 @@ public Task InitializeWebSocket()
             if (Completion != null)
                 throw new OperationCanceledException();
 
-            lock (initializeLock)
+            lock (_initializeLock)
             {
                 // if an initialization task is already running, return that
-                if (initializeWebSocketTask != null &&
-                   !initializeWebSocketTask.IsFaulted &&
-                   !initializeWebSocketTask.IsCompleted)
-                    return initializeWebSocketTask;
+                if (_initializeWebSocketTask != null &&
+                   !_initializeWebSocketTask.IsFaulted &&
+                   !_initializeWebSocketTask.IsCompleted)
+                    return _initializeWebSocketTask;
 
                 // if the websocket is open, return a completed task
-                if (clientWebSocket != null && clientWebSocket.State == WebSocketState.Open)
+                if (_clientWebSocket != null && _clientWebSocket.State == WebSocketState.Open)
                     return Task.CompletedTask;
 
                 // else (re-)create websocket and connect
-                clientWebSocket?.Dispose();
+                _clientWebSocket?.Dispose();
 
 #if NETFRAMEWORK
 				// fix websocket not supported on win 7 using
 				// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
-				clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
-				switch (clientWebSocket) {
+				_clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+				switch (_clientWebSocket) {
 					case ClientWebSocket nativeWebSocket:
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
 						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
@@ -410,15 +406,15 @@ public Task InitializeWebSocket()
 						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 						break;
 					default:
-						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+						throw new NotSupportedException($"unknown websocket type {_clientWebSocket.GetType().Name}");
 				}
 #else
-                clientWebSocket = new ClientWebSocket();
-                clientWebSocket.Options.AddSubProtocol("graphql-ws");
-                clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
-                clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+                _clientWebSocket = new ClientWebSocket();
+                _clientWebSocket.Options.AddSubProtocol("graphql-ws");
+                _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
 #endif
-                return initializeWebSocketTask = ConnectAsync(internalCancellationToken);
+                return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);
             }
         }
 
@@ -427,49 +423,49 @@ private async Task ConnectAsync(CancellationToken token)
             try
             {
                 await BackOff();
-                stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
-                Debug.WriteLine($"opening websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
-                await clientWebSocket.ConnectAsync(webSocketUri, token);
-                stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
-                Debug.WriteLine($"connection established on websocket {clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
-                await (Options.OnWebsocketConnected?.Invoke(client) ?? Task.CompletedTask);
-                Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {clientWebSocket.GetHashCode()}");
-                connectionAttempt = 1;
+                _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
+                Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
+                await _clientWebSocket.ConnectAsync(_webSocketUri, token);
+                _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
+                Debug.WriteLine($"connection established on websocket {_clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
+                await (Options.OnWebsocketConnected?.Invoke(_client) ?? Task.CompletedTask);
+                Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {_clientWebSocket.GetHashCode()}");
+                _connectionAttempt = 1;
 
                 // create receiving observable
-                incomingMessages = Observable
-                    .Defer(() => GetReceiveTask().ToObservable().ObserveOn(receiveLoopScheduler))
+                _incomingMessages = Observable
+                    .Defer(() => GetReceiveTask().ToObservable().ObserveOn(_receiveLoopScheduler))
                     .Repeat()
                     // complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
                     .Catch<WebsocketMessageWrapper, OperationCanceledException>(exception => Observable.Empty<WebsocketMessageWrapper>())
                     .Publish();
 
                 // subscribe maintenance
-                var maintenanceSubscription = incomingMessages.Subscribe(_ => { }, ex =>
+                var maintenanceSubscription = _incomingMessages.Subscribe(_ => { }, ex =>
                 {
-                    Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} received an error: {ex}");
-                    exceptionSubject.OnNext(ex);
-                    incomingMessagesConnection?.Dispose();
-                    stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+                    Debug.WriteLine($"incoming message stream {_incomingMessages.GetHashCode()} received an error: {ex}");
+                    _exceptionSubject.OnNext(ex);
+                    _incomingMessagesConnection?.Dispose();
+                    _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
                 },
                     () =>
                     {
-                        Debug.WriteLine($"incoming message stream {incomingMessages.GetHashCode()} completed");
-                        incomingMessagesConnection?.Dispose();
-                        stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+                        Debug.WriteLine($"incoming message stream {_incomingMessages.GetHashCode()} completed");
+                        _incomingMessagesConnection?.Dispose();
+                        _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
                     });
 
 
                 // connect observable
-                var connection = incomingMessages.Connect();
-                Debug.WriteLine($"new incoming message stream {incomingMessages.GetHashCode()} created");
+                var connection = _incomingMessages.Connect();
+                Debug.WriteLine($"new incoming message stream {_incomingMessages.GetHashCode()} created");
 
-                incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
+                _incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
             }
             catch (Exception e)
             {
-                stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-                exceptionSubject.OnNext(e);
+                _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+                _exceptionSubject.OnNext(e);
                 throw;
             }
         }
@@ -480,58 +476,55 @@ private async Task ConnectAsync(CancellationToken token)
         /// <returns></returns>
         private Task BackOff()
         {
-            connectionAttempt++;
+            _connectionAttempt++;
 
-            if (connectionAttempt == 1)
+            if (_connectionAttempt == 1)
                 return Task.CompletedTask;
 
-            var delay = Options.BackOffStrategy?.Invoke(connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
-            Debug.WriteLine($"connection attempt #{connectionAttempt}, backing off for {delay.TotalSeconds} s");
-            return Task.Delay(delay, internalCancellationToken);
+            var delay = Options.BackOffStrategy?.Invoke(_connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
+            Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
+            return Task.Delay(delay, _internalCancellationToken);
         }
 
-        private IObservable<WebsocketMessageWrapper> GetMessageStream()
-        {
-            return Observable.Using(() => new EventLoopScheduler(), scheduler =>
+        private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
+            Observable.Using(() => new EventLoopScheduler(), scheduler =>
                 Observable.Create<WebsocketMessageWrapper>(async observer =>
                 {
                     // make sure the websocket ist connected
                     await InitializeWebSocket();
                     // subscribe observer to message stream
-                    var subscription = new CompositeDisposable(incomingMessages.ObserveOn(scheduler).Subscribe(observer));
-                    // register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
-                    subscription.Add(internalCancellationTokenSource.Token.Register(observer.OnCompleted));
+                    var subscription = new CompositeDisposable(_incomingMessages.ObserveOn(scheduler).Subscribe(observer))
+                    {
+                        // register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
+                        _internalCancellationTokenSource.Token.Register(observer.OnCompleted)
+                    };
 
                     // add some debug output
                     var hashCode = subscription.GetHashCode();
-                    subscription.Add(Disposable.Create(() =>
-                    {
-                        Debug.WriteLine($"incoming message subscription {hashCode} disposed");
-                    }));
+                    subscription.Add(Disposable.Create(() => Debug.WriteLine($"incoming message subscription {hashCode} disposed")));
                     Debug.WriteLine($"new incoming message subscription {hashCode} created");
 
                     return subscription;
                 }));
-        }
 
-        private Task<WebsocketMessageWrapper> receiveAsyncTask = null;
-        private readonly object receiveTaskLocker = new object();
+        private Task<WebsocketMessageWrapper> _receiveAsyncTask = null;
+        private readonly object _receiveTaskLocker = new object();
         /// <summary>
         /// wrapper method to pick up the existing request task if already running
         /// </summary>
         /// <returns></returns>
         private Task<WebsocketMessageWrapper> GetReceiveTask()
         {
-            lock (receiveTaskLocker)
+            lock (_receiveTaskLocker)
             {
-                internalCancellationToken.ThrowIfCancellationRequested();
-                if (receiveAsyncTask == null ||
-                    receiveAsyncTask.IsFaulted ||
-                    receiveAsyncTask.IsCompleted)
-                    receiveAsyncTask = ReceiveWebsocketMessagesAsync();
+                _internalCancellationToken.ThrowIfCancellationRequested();
+                if (_receiveAsyncTask == null ||
+                    _receiveAsyncTask.IsFaulted ||
+                    _receiveAsyncTask.IsCompleted)
+                    _receiveAsyncTask = ReceiveWebsocketMessagesAsync();
             }
 
-            return receiveAsyncTask;
+            return _receiveAsyncTask;
         }
 
         /// <summary>
@@ -540,30 +533,30 @@ private Task<WebsocketMessageWrapper> GetReceiveTask()
         /// <returns></returns>
         private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
         {
-            internalCancellationToken.ThrowIfCancellationRequested();
+            _internalCancellationToken.ThrowIfCancellationRequested();
 
             try
             {
-                Debug.WriteLine($"waiting for data on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+                Debug.WriteLine($"waiting for data on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
 
                 using var ms = new MemoryStream();
                 WebSocketReceiveResult webSocketReceiveResult = null;
                 do
                 {
                     // cancellation is done implicitly via the close method
-                    webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
-                    ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+                    webSocketReceiveResult = await _clientWebSocket.ReceiveAsync(_buffer, CancellationToken.None);
+                    ms.Write(_buffer.Array, _buffer.Offset, webSocketReceiveResult.Count);
                 }
-                while (!webSocketReceiveResult.EndOfMessage && !internalCancellationToken.IsCancellationRequested);
+                while (!webSocketReceiveResult.EndOfMessage && !_internalCancellationToken.IsCancellationRequested);
 
-                internalCancellationToken.ThrowIfCancellationRequested();
+                _internalCancellationToken.ThrowIfCancellationRequested();
                 ms.Seek(0, SeekOrigin.Begin);
 
                 if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
                 {
                     var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
                     response.MessageBytes = ms.ToArray();
-                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
                     return response;
                 }
                 else
@@ -580,21 +573,21 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
 
         private async Task CloseAsync()
         {
-            if (clientWebSocket == null)
+            if (_clientWebSocket == null)
                 return;
 
             // don't attempt to close the websocket if it is in a failed state
-            if (this.clientWebSocket.State != WebSocketState.Open &&
-                this.clientWebSocket.State != WebSocketState.CloseReceived &&
-                this.clientWebSocket.State != WebSocketState.CloseSent)
+            if (_clientWebSocket.State != WebSocketState.Open &&
+                _clientWebSocket.State != WebSocketState.CloseReceived &&
+                _clientWebSocket.State != WebSocketState.CloseSent)
             {
-                Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
+                Debug.WriteLine($"websocket {_clientWebSocket.GetHashCode()} state = {_clientWebSocket.State}");
                 return;
             }
 
-            Debug.WriteLine($"closing websocket {clientWebSocket.GetHashCode()}");
-            await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
-            stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+            Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
+            await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
+            _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
         }
 
         #region IDisposable
@@ -605,7 +598,7 @@ private async Task CloseAsync()
         /// </summary>
         public void Complete()
         {
-            lock (completedLocker)
+            lock (_completedLocker)
             {
                 if (Completion == null)
                     Completion = CompleteAsync();
@@ -618,30 +611,30 @@ public void Complete()
         /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
         public Task Completion { get; private set; }
 
-        private readonly object completedLocker = new object();
+        private readonly object _completedLocker = new object();
         private async Task CompleteAsync()
         {
-            Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
-            incomingMessagesConnection?.Dispose();
+            Debug.WriteLine($"disposing websocket {_clientWebSocket.GetHashCode()}...");
+            _incomingMessagesConnection?.Dispose();
 
-            if (!internalCancellationTokenSource.IsCancellationRequested)
-                internalCancellationTokenSource.Cancel();
+            if (!_internalCancellationTokenSource.IsCancellationRequested)
+                _internalCancellationTokenSource.Cancel();
 
             await CloseAsync();
-            requestSubscription?.Dispose();
-            clientWebSocket?.Dispose();
+            _requestSubscription?.Dispose();
+            _clientWebSocket?.Dispose();
 
-            stateSubject?.OnCompleted();
-            stateSubject?.Dispose();
+            _stateSubject?.OnCompleted();
+            _stateSubject?.Dispose();
 
-            exceptionSubject?.OnCompleted();
-            exceptionSubject?.Dispose();
-            internalCancellationTokenSource.Dispose();
+            _exceptionSubject?.OnCompleted();
+            _exceptionSubject?.Dispose();
+            _internalCancellationTokenSource.Dispose();
 
-            sendLoopScheduler?.Dispose();
-            receiveLoopScheduler?.Dispose();
+            _sendLoopScheduler?.Dispose();
+            _receiveLoopScheduler?.Dispose();
 
-            Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
+            Debug.WriteLine($"websocket {_clientWebSocket.GetHashCode()} disposed");
         }
         #endregion
     }
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index c7935675..a1b0d455 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -42,7 +42,7 @@ public class GraphQLError : IEquatable<GraphQLError?>
         /// <param name="obj">The object to compare with this instance</param>
         /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
         public override bool Equals(object? obj) =>
-            this.Equals(obj as GraphQLError);
+            Equals(obj as GraphQLError);
 
         /// <summary>
         /// Returns a value that indicates whether this instance is equal to a specified object
@@ -56,46 +56,46 @@ public bool Equals(GraphQLError? other)
             if (ReferenceEquals(this, other))
             { return true; }
             {
-                if (this.Locations != null && other.Locations != null)
+                if (Locations != null && other.Locations != null)
                 {
-                    if (!this.Locations.SequenceEqual(other.Locations))
+                    if (!Locations.SequenceEqual(other.Locations))
                     { return false; }
                 }
-                else if (this.Locations != null && other.Locations == null)
+                else if (Locations != null && other.Locations == null)
                 { return false; }
-                else if (this.Locations == null && other.Locations != null)
+                else if (Locations == null && other.Locations != null)
                 { return false; }
             }
-            if (!EqualityComparer<string>.Default.Equals(this.Message, other.Message))
+            if (!EqualityComparer<string>.Default.Equals(Message, other.Message))
             { return false; }
             {
-                if (this.Path != null && other.Path != null)
+                if (Path != null && other.Path != null)
                 {
-                    if (!this.Path.SequenceEqual(other.Path))
+                    if (!Path.SequenceEqual(other.Path))
                     { return false; }
                 }
-                else if (this.Path != null && other.Path == null)
+                else if (Path != null && other.Path == null)
                 { return false; }
-                else if (this.Path == null && other.Path != null)
+                else if (Path == null && other.Path != null)
                 { return false; }
             }
             return true;
         }
 
         /// <summary>
-        /// <inheritdoc cref="Object.GetHashCode"/>
+        /// <inheritdoc cref="object.GetHashCode"/>
         /// </summary>
         public override int GetHashCode()
         {
             var hashCode = 0;
-            if (this.Locations != null)
+            if (Locations != null)
             {
-                hashCode = hashCode ^ EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(this.Locations);
+                hashCode ^= EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(Locations);
             }
-            hashCode = hashCode ^ EqualityComparer<string>.Default.GetHashCode(this.Message);
-            if (this.Path != null)
+            hashCode ^= EqualityComparer<string>.Default.GetHashCode(Message);
+            if (Path != null)
             {
-                hashCode = hashCode ^ EqualityComparer<dynamic>.Default.GetHashCode(this.Path);
+                hashCode ^= EqualityComparer<dynamic>.Default.GetHashCode(Path);
             }
             return hashCode;
         }
diff --git a/src/GraphQL.Primitives/GraphQLLocation.cs b/src/GraphQL.Primitives/GraphQLLocation.cs
index 335f28b8..c1fe6cee 100644
--- a/src/GraphQL.Primitives/GraphQLLocation.cs
+++ b/src/GraphQL.Primitives/GraphQLLocation.cs
@@ -25,7 +25,7 @@ public sealed class GraphQLLocation : IEquatable<GraphQLLocation?>
         /// </summary>
         /// <param name="obj">The object to compare with this instance</param>
         /// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
-        public override bool Equals(object obj) => this.Equals(obj as GraphQLLocation);
+        public override bool Equals(object obj) => Equals(obj as GraphQLLocation);
 
         /// <summary>
         /// Returns a value that indicates whether this instance is equal to a specified object
@@ -38,15 +38,15 @@ public bool Equals(GraphQLLocation? other)
             { return false; }
             if (ReferenceEquals(this, other))
             { return true; }
-            return EqualityComparer<uint>.Default.Equals(this.Column, other.Column) &&
-                EqualityComparer<uint>.Default.Equals(this.Line, other.Line);
+            return EqualityComparer<uint>.Default.Equals(Column, other.Column) &&
+                EqualityComparer<uint>.Default.Equals(Line, other.Line);
         }
 
         /// <summary>
-        /// <inheritdoc cref="Object.GetHashCode"/>
+        /// <inheritdoc cref="object.GetHashCode"/>
         /// </summary>
         public override int GetHashCode() =>
-            this.Column.GetHashCode() ^ this.Line.GetHashCode();
+            Column.GetHashCode() ^ Line.GetHashCode();
 
         /// <summary>
         /// Tests whether two specified <see cref="GraphQLLocation"/> instances are equivalent
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 27681ed8..a36dae38 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.Serialization;
 
 namespace GraphQL
 {
@@ -11,17 +10,17 @@ namespace GraphQL
     /// </summary>
     public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequest?>
     {
-        public const string OperationNameKey = "operationName";
-        public const string QueryKey = "query";
-        public const string VariablesKey = "variables";
+        public const string OPERATION_NAME_KEY = "operationName";
+        public const string QUERY_KEY = "query";
+        public const string VARIABLES_KEY = "variables";
 
         /// <summary>
         /// The Query
         /// </summary>
         public string Query
         {
-            get => ContainsKey(QueryKey) ? (string)this[QueryKey] : null;
-            set => this[QueryKey] = value;
+            get => ContainsKey(QUERY_KEY) ? (string)this[QUERY_KEY] : null;
+            set => this[QUERY_KEY] = value;
         }
 
         /// <summary>
@@ -29,8 +28,8 @@ public string Query
         /// </summary>
         public string? OperationName
         {
-            get => ContainsKey(OperationNameKey) ? (string)this[OperationNameKey] : null;
-            set => this[OperationNameKey] = value;
+            get => ContainsKey(OPERATION_NAME_KEY) ? (string)this[OPERATION_NAME_KEY] : null;
+            set => this[OPERATION_NAME_KEY] = value;
         }
 
         /// <summary>
@@ -38,8 +37,8 @@ public string? OperationName
         /// </summary>
         public object? Variables
         {
-            get => ContainsKey(VariablesKey) ? this[VariablesKey] : null;
-            set => this[VariablesKey] = value;
+            get => ContainsKey(VARIABLES_KEY) ? this[VARIABLES_KEY] : null;
+            set => this[VARIABLES_KEY] = value;
         }
 
         public GraphQLRequest() { }
@@ -58,11 +57,11 @@ public GraphQLRequest(string query, object? variables = null, string? operationN
         /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
         public override bool Equals(object? obj)
         {
-            if (ReferenceEquals(null, obj))
+            if (obj is null)
                 return false;
             if (ReferenceEquals(this, obj))
                 return true;
-            if (obj.GetType() != this.GetType())
+            if (obj.GetType() != GetType())
                 return false;
             return Equals((GraphQLRequest)obj);
         }
@@ -74,15 +73,15 @@ public override bool Equals(object? obj)
         /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
         public virtual bool Equals(GraphQLRequest? other)
         {
-            if (ReferenceEquals(null, other))
+            if (other is null)
                 return false;
             if (ReferenceEquals(this, other))
                 return true;
-            return this.Count == other.Count && !this.Except(other).Any();
+            return Count == other.Count && !this.Except(other).Any();
         }
 
         /// <summary>
-        /// <inheritdoc cref="Object.GetHashCode"/>
+        /// <inheritdoc cref="object.GetHashCode"/>
         /// </summary>
         public override int GetHashCode()
         {
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index fbe90e99..ca14feac 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -18,7 +18,7 @@ public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?>
         [DataMember(Name = "extensions")]
         public GraphQLExtensionsType? Extensions { get; set; }
 
-        public override bool Equals(object? obj) => this.Equals(obj as GraphQLResponse<T>);
+        public override bool Equals(object? obj) => Equals(obj as GraphQLResponse<T>);
 
         public bool Equals(GraphQLResponse<T>? other)
         {
@@ -26,27 +26,27 @@ public bool Equals(GraphQLResponse<T>? other)
             { return false; }
             if (ReferenceEquals(this, other))
             { return true; }
-            if (!EqualityComparer<T>.Default.Equals(this.Data, other.Data))
+            if (!EqualityComparer<T>.Default.Equals(Data, other.Data))
             { return false; }
 
-            if (this.Errors != null && other.Errors != null)
+            if (Errors != null && other.Errors != null)
             {
-                if (!Enumerable.SequenceEqual(this.Errors, other.Errors))
+                if (!Enumerable.SequenceEqual(Errors, other.Errors))
                 { return false; }
             }
-            else if (this.Errors != null && other.Errors == null)
+            else if (Errors != null && other.Errors == null)
             { return false; }
-            else if (this.Errors == null && other.Errors != null)
+            else if (Errors == null && other.Errors != null)
             { return false; }
 
-            if (this.Extensions != null && other.Extensions != null)
+            if (Extensions != null && other.Extensions != null)
             {
-                if (!Enumerable.SequenceEqual(this.Extensions, other.Extensions))
+                if (!Enumerable.SequenceEqual(Extensions, other.Extensions))
                 { return false; }
             }
-            else if (this.Extensions != null && other.Extensions == null)
+            else if (Extensions != null && other.Extensions == null)
             { return false; }
-            else if (this.Extensions == null && other.Extensions != null)
+            else if (Extensions == null && other.Extensions != null)
             { return false; }
 
             return true;
@@ -56,11 +56,11 @@ public override int GetHashCode()
         {
             unchecked
             {
-                var hashCode = EqualityComparer<T>.Default.GetHashCode(this.Data);
+                var hashCode = EqualityComparer<T>.Default.GetHashCode(Data);
                 {
-                    if (this.Errors != null)
+                    if (Errors != null)
                     {
-                        foreach (var element in this.Errors)
+                        foreach (var element in Errors)
                         {
                             hashCode = (hashCode * 397) ^ EqualityComparer<GraphQLError?>.Default.GetHashCode(element);
                         }
@@ -70,9 +70,9 @@ public override int GetHashCode()
                         hashCode = (hashCode * 397) ^ 0;
                     }
 
-                    if (this.Extensions != null)
+                    if (Extensions != null)
                     {
-                        foreach (var element in this.Extensions)
+                        foreach (var element in Extensions)
                         {
                             hashCode = (hashCode * 397) ^ EqualityComparer<KeyValuePair<string, object>>.Default.GetHashCode(element);
                         }
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index 40244aac..5547e136 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Text;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
@@ -8,7 +7,6 @@
 using GraphQL.Client.Serializer.Tests.TestData;
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Helpers;
-using Newtonsoft.Json;
 using Xunit;
 
 namespace GraphQL.Client.Serializer.Tests
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index ab86dbdf..940b7392 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Text;
 using System.Threading;
 using FluentAssertions;
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index b7e4b2d8..00b6d03b 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using GraphQL.Client.Serializer.Newtonsoft;
 using Newtonsoft.Json;
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
index 0711780b..166414a2 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -1,7 +1,5 @@
-using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Text;
 
 namespace GraphQL.Client.Serializer.Tests.TestData
 {
@@ -41,10 +39,6 @@ public IEnumerator<object[]> GetEnumerator()
             };
         }
 
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
index 3a9e7369..de76f5d8 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
@@ -1,7 +1,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using GraphQL.Client.Abstractions.Websocket;
-using GraphQL.Client.Tests.Common.Chat;
 
 namespace GraphQL.Client.Serializer.Tests.TestData
 {
@@ -28,9 +27,6 @@ public IEnumerator<object[]> GetEnumerator()
             };
         }
 
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 55a94fdc..06208c21 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -1,6 +1,5 @@
 using System.Collections;
 using System.Collections.Generic;
-using GraphQL.Client.Tests.Common.Chat;
 
 namespace GraphQL.Client.Serializer.Tests.TestData
 {
@@ -22,9 +21,6 @@ public IEnumerator<object[]> GetEnumerator()
             };
         }
 
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
index 7bf021be..3a6ae10c 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace GraphQL.Client.Tests.Common.Chat
 {
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index 5e21b479..261f5722 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -6,7 +6,7 @@ namespace GraphQL.Client.Tests.Common.Chat
 {
     public static class GraphQLClientChatExtensions
     {
-        public const string AddMessageQuery =
+        public const string ADD_MESSAGE_QUERY =
 @"mutation($input: MessageInputType){
   addMessage(message: $input){
     content
@@ -25,7 +25,7 @@ public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(th
                 }
             };
 
-            var graphQLRequest = new GraphQLRequest(AddMessageQuery, variables);
+            var graphQLRequest = new GraphQLRequest(ADD_MESSAGE_QUERY, variables);
             return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
         }
 
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 1e86e125..c058e066 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index c01810a8..ba9a97ab 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -21,8 +21,8 @@ public interface IChat
 
     public class Chat : IChat
     {
-        private readonly ISubject<Message> messageStream = new ReplaySubject<Message>(1);
-        private readonly ISubject<MessageFrom> userJoined = new Subject<MessageFrom>();
+        private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+        private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
         public Chat()
         {
@@ -60,7 +60,7 @@ public Message AddMessage(ReceivedMessage message)
         public Message AddMessage(Message message)
         {
             AllMessages.Push(message);
-            messageStream.OnNext(message);
+            _messageStream.OnNext(message);
             return message;
         }
 
@@ -77,30 +77,22 @@ public MessageFrom Join(string userId)
                 DisplayName = displayName
             };
 
-            userJoined.OnNext(joinedUser);
+            _userJoined.OnNext(joinedUser);
             return joinedUser;
         }
 
-        public IObservable<Message> Messages(string user)
-        {
-            return messageStream
+        public IObservable<Message> Messages(string user) =>
+            _messageStream
                 .Select(message =>
                 {
                     message.Sub = user;
                     return message;
                 })
                 .AsObservable();
-        }
 
-        public void AddError(Exception exception)
-        {
-            messageStream.OnError(exception);
-        }
+        public void AddError(Exception exception) => _messageStream.OnError(exception);
 
-        public IObservable<MessageFrom> UserJoined()
-        {
-            return userJoined.AsObservable();
-        }
+        public IObservable<MessageFrom> UserJoined() => _userJoined.AsObservable();
     }
 
     public class User
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
index 4056110b..3bfd2409 100644
--- a/tests/GraphQL.Client.Tests.Common/Common.cs
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -7,8 +7,8 @@ namespace GraphQL.Client.Tests.Common
 {
     public static class Common
     {
-        public const string StarWarsEndpoint = "/graphql/starwars";
-        public const string ChatEndpoint = "/graphql/chat";
+        public const string STAR_WARS_ENDPOINT = "/graphql/starwars";
+        public const string CHAT_ENDPOINT = "/graphql/chat";
 
         public static StarWarsSchema GetStarWarsSchema()
         {
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
index c8095014..4104fd20 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
@@ -20,9 +20,6 @@ public IEnumerator<object[]> GetEnumerator()
                 .GetEnumerator();
         }
 
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index 2e638fc3..a6a4e50f 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -9,7 +9,7 @@ namespace GraphQL.Client.Tests.Common.Helpers
 {
     public class CallbackMonitor<T>
     {
-        private readonly ManualResetEventSlim callbackInvoked = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim _callbackInvoked = new ManualResetEventSlim();
 
         /// <summary>
         /// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
@@ -19,7 +19,7 @@ public class CallbackMonitor<T>
         /// <summary>
         /// Indicates that an update has been received since the last <see cref="Reset"/>
         /// </summary>
-        public bool CallbackInvoked => callbackInvoked.IsSet;
+        public bool CallbackInvoked => _callbackInvoked.IsSet;
         /// <summary>
         /// The last payload which was received.
         /// </summary>
@@ -29,7 +29,7 @@ public void Invoke(T param)
         {
             LastPayload = param;
             Debug.WriteLine($"CallbackMonitor invoke handler thread id: {Thread.CurrentThread.ManagedThreadId}");
-            callbackInvoked.Set();
+            _callbackInvoked.Set();
         }
 
         /// <summary>
@@ -38,13 +38,10 @@ public void Invoke(T param)
         public void Reset()
         {
             LastPayload = default(T);
-            callbackInvoked.Reset();
+            _callbackInvoked.Reset();
         }
 
-        public CallbackAssertions<T> Should()
-        {
-            return new CallbackAssertions<T>(this);
-        }
+        public CallbackAssertions<T> Should() => new CallbackAssertions<T>(this);
 
         public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>>
         {
@@ -63,12 +60,12 @@ public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvoke
                     .Given(() =>
                     {
                         Debug.WriteLine($"HaveBeenInvokedWithPayload thread id: {Thread.CurrentThread.ManagedThreadId}");
-                        return Subject.callbackInvoked.Wait(timeout);
+                        return Subject._callbackInvoked.Wait(timeout);
                     })
                     .ForCondition(isSet => isSet)
                     .FailWith("Expected {context:callback} to be invoked{reason}, but did not receive a call within {0}", timeout);
 
-                Subject.callbackInvoked.Reset();
+                Subject._callbackInvoked.Reset();
                 return new AndWhichConstraint<CallbackAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
             }
             public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(string because = "", params object[] becauseArgs)
@@ -84,11 +81,11 @@ public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(TimeSpan t
             {
                 Execute.Assertion
                     .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject.callbackInvoked.Wait(timeout))
+                    .Given(() => Subject._callbackInvoked.Wait(timeout))
                     .ForCondition(isSet => !isSet)
                     .FailWith("Expected {context:callback} to not be invoked{reason}, but did receive a call: {0}", Subject.LastPayload);
 
-                Subject.callbackInvoked.Reset();
+                Subject._callbackInvoked.Reset();
                 return new AndConstraint<CallbackAssertions<TPayload>>(this);
             }
             public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(string because = "", params object[] becauseArgs)
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
index 992ca21e..6af84092 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
@@ -6,60 +6,51 @@ namespace GraphQL.Client.Tests.Common.Helpers
 
     public class ConcurrentTaskWrapper
     {
-        public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask)
-        {
-            return new ConcurrentTaskWrapper<TResult>(createTask);
-        }
+        public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) => new ConcurrentTaskWrapper<TResult>(createTask);
 
-        private readonly Func<Task> createTask;
-        private Task internalTask = null;
+        private readonly Func<Task> _createTask;
+        private Task _internalTask = null;
 
         public ConcurrentTaskWrapper(Func<Task> createTask)
         {
-            this.createTask = createTask;
+            _createTask = createTask;
         }
 
         public Task Invoke()
         {
-            if (internalTask != null)
-                return internalTask;
+            if (_internalTask != null)
+                return _internalTask;
 
-            return internalTask = createTask();
+            return _internalTask = _createTask();
         }
     }
 
     public class ConcurrentTaskWrapper<TResult>
     {
-        private readonly Func<Task<TResult>> createTask;
-        private Task<TResult> internalTask = null;
+        private readonly Func<Task<TResult>> _createTask;
+        private Task<TResult> _internalTask = null;
 
         public ConcurrentTaskWrapper(Func<Task<TResult>> createTask)
         {
-            this.createTask = createTask;
+            _createTask = createTask;
         }
 
         public Task<TResult> Invoke()
         {
-            if (internalTask != null)
-                return internalTask;
+            if (_internalTask != null)
+                return _internalTask;
 
-            return internalTask = createTask();
+            return _internalTask = _createTask();
         }
 
         public void Start()
         {
-            if (internalTask == null)
-                internalTask = createTask();
+            if (_internalTask == null)
+                _internalTask = _createTask();
         }
 
-        public Func<Task<TResult>> Invoking()
-        {
-            return Invoke;
-        }
+        public Func<Task<TResult>> Invoking() => Invoke;
 
-        public void Clear()
-        {
-            internalTask = null;
-        }
+        public void Clear() => _internalTask = null;
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
index 7768d0b2..b769399b 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
@@ -6,12 +6,10 @@ namespace GraphQL.Client.Tests.Common.Helpers
 {
     public static class MiscellaneousExtensions
     {
-        public static string RemoveWhitespace(this string input)
-        {
-            return new string(input.ToCharArray()
+        public static string RemoveWhitespace(this string input) =>
+            new string(input.ToCharArray()
                 .Where(c => !char.IsWhiteSpace(c))
                 .ToArray());
-        }
 
         public static CallbackMonitor<GraphQLHttpClient> ConfigureMonitorForOnWebsocketConnected(
             this GraphQLHttpClient client)
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index a9cd3cd3..dad65ff1 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -11,11 +11,11 @@ namespace GraphQL.Client.Tests.Common.Helpers
 {
     public class ObservableTester<TSubscriptionPayload> : IDisposable
     {
-        private readonly IDisposable subscription;
-        private readonly ManualResetEventSlim updateReceived = new ManualResetEventSlim();
-        private readonly ManualResetEventSlim completed = new ManualResetEventSlim();
-        private readonly ManualResetEventSlim error = new ManualResetEventSlim();
-        private readonly EventLoopScheduler observeScheduler = new EventLoopScheduler();
+        private readonly IDisposable _subscription;
+        private readonly ManualResetEventSlim _updateReceived = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim _completed = new ManualResetEventSlim();
+        private readonly ManualResetEventSlim _error = new ManualResetEventSlim();
+        private readonly EventLoopScheduler _observeScheduler = new EventLoopScheduler();
 
         /// <summary>
         /// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
@@ -25,7 +25,7 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable
         /// <summary>
         /// Indicates that an update has been received since the last <see cref="_reset"/>
         /// </summary>
-        public bool UpdateReceived => updateReceived.IsSet;
+        public bool UpdateReceived => _updateReceived.IsSet;
         /// <summary>
         /// The last payload which was received.
         /// </summary>
@@ -40,48 +40,42 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable
         public ObservableTester(IObservable<TSubscriptionPayload> observable)
         {
 
-            observeScheduler.Schedule(() =>
+            _observeScheduler.Schedule(() =>
                 Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
-            subscription = observable.ObserveOn(observeScheduler).Subscribe(
+            _subscription = observable.ObserveOn(_observeScheduler).Subscribe(
                 obj =>
                 {
                     Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
                     LastPayload = obj;
-                    updateReceived.Set();
+                    _updateReceived.Set();
                 },
                 ex =>
                 {
                     Debug.WriteLine($"observable tester {GetHashCode()} error received: {ex}");
                     Error = ex;
-                    error.Set();
+                    _error.Set();
                 },
                 () =>
                 {
                     Debug.WriteLine($"observable tester {GetHashCode()}: completed");
-                    completed.Set();
+                    _completed.Set();
                 });
         }
 
         /// <summary>
         /// Resets the tester class. Should be called before triggering the potential update
         /// </summary>
-        private void Reset()
-        {
-            updateReceived.Reset();
-        }
+        private void Reset() => _updateReceived.Reset();
 
         /// <inheritdoc />
         public void Dispose()
         {
-            subscription?.Dispose();
-            observeScheduler.Dispose();
+            _subscription?.Dispose();
+            _observeScheduler.Dispose();
         }
 
-        public SubscriptionAssertions<TSubscriptionPayload> Should()
-        {
-            return new SubscriptionAssertions<TSubscriptionPayload>(this);
-        }
+        public SubscriptionAssertions<TSubscriptionPayload> Should() => new SubscriptionAssertions<TSubscriptionPayload>(this);
 
         public class SubscriptionAssertions<TPayload> : ReferenceTypeAssertions<ObservableTester<TPayload>, SubscriptionAssertions<TPayload>>
         {
@@ -99,7 +93,7 @@ public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceiv
                     .BecauseOf(because, becauseArgs)
                     .Given(() =>
                     {
-                        var isSet = Subject.updateReceived.Wait(timeout);
+                        var isSet = Subject._updateReceived.Wait(timeout);
                         if (!isSet)
                             Debug.WriteLine($"waiting for payload on thread {Thread.CurrentThread.ManagedThreadId} timed out!");
                         return isSet;
@@ -107,7 +101,7 @@ public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceiv
                     .ForCondition(isSet => isSet)
                     .FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
 
-                Subject.updateReceived.Reset();
+                Subject._updateReceived.Reset();
                 return new AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
             }
             public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(string because = "", params object[] becauseArgs)
@@ -118,11 +112,11 @@ public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(Ti
             {
                 Execute.Assertion
                     .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject.updateReceived.Wait(timeout))
+                    .Given(() => Subject._updateReceived.Wait(timeout))
                     .ForCondition(isSet => !isSet)
                     .FailWith("Expected {context:Subscription} to not receive a new payload{reason}, but did receive an update: {0}", Subject.LastPayload);
 
-                Subject.updateReceived.Reset();
+                Subject._updateReceived.Reset();
                 return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
             }
             public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(string because = "", params object[] becauseArgs)
@@ -133,7 +127,7 @@ public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveRecei
             {
                 Execute.Assertion
                     .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject.error.Wait(timeout))
+                    .Given(() => Subject._error.Wait(timeout))
                     .ForCondition(isSet => isSet)
                     .FailWith("Expected {context:Subscription} to fail{reason}, but did not receive an error within {0}", timeout);
 
@@ -148,7 +142,7 @@ public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(TimeSpan ti
             {
                 Execute.Assertion
                     .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject.completed.Wait(timeout))
+                    .Given(() => Subject._completed.Wait(timeout))
                     .ForCondition(isSet => isSet)
                     .FailWith("Expected {context:Subscription} to complete{reason}, but did not complete within {0}", timeout);
 
@@ -162,7 +156,7 @@ public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(TimeSpan
             {
                 Execute.Assertion
                     .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject.completed.Wait(timeout))
+                    .Given(() => Subject._completed.Wait(timeout))
                     .ForCondition(isSet => !isSet)
                     .FailWith("Expected {context:Subscription} not to complete within {0}{reason}, but it did!", timeout);
 
@@ -175,10 +169,7 @@ public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(string b
 
     public static class ObservableExtensions
     {
-        public static ObservableTester<T> Monitor<T>(this IObservable<T> observable)
-        {
-            return new ObservableTester<T>(observable);
-        }
+        public static ObservableTester<T> Monitor<T>(this IObservable<T> observable) => new ObservableTester<T>(observable);
     }
 
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
index 9349e813..88c64759 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
@@ -11,9 +11,6 @@ public IEnumerator<object[]> GetEnumerator()
             yield return new object[] { 2, "Vader" };
         }
 
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index 9f5b37bb..e70751b7 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -39,10 +39,10 @@ public async Task ShutdownServer()
         }
 
         public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
+            => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
 
         public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
+            => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
 
         private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false)
         {
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 0fd4349f..38704066 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Reactive.Disposables;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
@@ -25,10 +24,7 @@ public static async Task<IWebHost> CreateServer(int port)
             config["server.urls"] = $"http://localhost:{port}";
 
             var host = new WebHostBuilder()
-                .ConfigureLogging((ctx, logging) =>
-                {
-                    logging.AddDebug();
-                })
+                .ConfigureLogging((ctx, logging) => logging.AddDebug())
                 .UseConfiguration(config)
                 .UseKestrel()
                 .UseStartup<Startup>()
@@ -54,28 +50,22 @@ public class TestServerSetup : IDisposable
     {
         public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer)
         {
-            this.serializer = serializer;
+            Serializer = serializer;
             Port = NetworkHelpers.GetFreeTcpPortNumber();
         }
 
         public int Port { get; }
         public IWebHost Server { get; set; }
-        public IGraphQLWebsocketJsonSerializer serializer { get; set; }
+        public IGraphQLWebsocketJsonSerializer Serializer { get; set; }
 
         public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.StarWarsEndpoint, requestsViaWebsocket);
+            => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
 
         public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.ChatEndpoint, requestsViaWebsocket);
+            => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
 
-        private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false)
-        {
-            return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
-        }
+        private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) => WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
 
-        public void Dispose()
-        {
-            Server?.Dispose();
-        }
+        public void Dispose() => Server?.Dispose();
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index a4f01ee9..72a28d60 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -4,7 +4,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
-using FluentAssertions.Extensions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http;
 using GraphQL.Client.Tests.Common.Chat.Schema;
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
index ecfe9afb..7ffcdc11 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
@@ -1,4 +1,3 @@
-using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
index e293f044..e129cfed 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
@@ -1,4 +1,3 @@
-using GraphQL.Client.Serializer.SystemTextJson;
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index b1dca909..1a0a273e 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -27,8 +27,8 @@ public abstract class Base : IAsyncLifetime
 
         protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture)
         {
-            this.Output = output;
-            this.Fixture = fixture;
+            Output = output;
+            Fixture = fixture;
         }
 
         protected static ReceivedMessage InitialMessage = new ReceivedMessage
@@ -113,14 +113,14 @@ public async void CanHandleRequestErrorViaWebsocket()
             response.Errors.Should().ContainSingle("because the query is invalid");
         }
 
-        private const string SubscriptionQuery = @"
+        private const string SUBSCRIPTION_QUERY = @"
 			subscription {
 			  messageAdded{
 			    content
 			  }
 			}";
 
-        private readonly GraphQLRequest SubscriptionRequest = new GraphQLRequest(SubscriptionQuery);
+        private readonly GraphQLRequest _subscriptionRequest = new GraphQLRequest(SUBSCRIPTION_QUERY);
 
 
         [Fact]
@@ -131,7 +131,7 @@ public async void CanCreateObservableSubscription()
             callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
             Debug.WriteLine("creating subscription stream");
-            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
 
             Debug.WriteLine("subscribing...");
             using var tester = observable.Monitor();
@@ -169,7 +169,7 @@ public async void CanReconnectWithSameObservable()
             var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
 
             Debug.WriteLine("creating subscription stream");
-            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest);
+            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
 
             Debug.WriteLine("subscribing...");
             var tester = observable.Monitor();
@@ -208,7 +208,7 @@ public async void CanReconnectWithSameObservable()
             tester2.Dispose();
         }
 
-        private const string SubscriptionQuery2 = @"
+        private const string SUBSCRIPTION_QUERY2 = @"
 			subscription {
 			  userJoined{
 				displayName
@@ -228,7 +228,7 @@ public class UserJoinedContent
 
         }
 
-        private readonly GraphQLRequest SubscriptionRequest2 = new GraphQLRequest(SubscriptionQuery2);
+        private readonly GraphQLRequest _subscriptionRequest2 = new GraphQLRequest(SUBSCRIPTION_QUERY2);
 
 
         [Fact]
@@ -243,8 +243,8 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
             Debug.WriteLine("creating subscription stream");
-            var observable1 = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Invoke);
-            var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
+            var observable1 = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, callbackTester.Invoke);
+            var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(_subscriptionRequest2, callbackTester2.Invoke);
 
             Debug.WriteLine("subscribing...");
             var messagesMonitor = observable1.Monitor();
@@ -306,7 +306,7 @@ public async void CanHandleConnectionTimeout()
 
                 Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
                 Debug.WriteLine("creating subscription stream");
-                var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(SubscriptionRequest, errorMonitor.Invoke);
+                var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, errorMonitor.Invoke);
 
                 Debug.WriteLine("subscribing...");
                 var tester = observable.Monitor();
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
index adfb0672..aa6cb945 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
@@ -1,4 +1,3 @@
-using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 using Xunit.Abstractions;
diff --git a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
index 50f49186..e387d32b 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
@@ -18,12 +18,12 @@ public class RepositoryGraphType : ObjectGraphType<Repository>
 
         public RepositoryGraphType()
         {
-            this.Name = nameof(Repository);
-            this.Field(expression => expression.DatabaseId);
-            this.Field<NonNullGraphType<IdGraphType>>("id");
-            this.Field(expression => expression.Name);
+            Name = nameof(Repository);
+            Field(expression => expression.DatabaseId);
+            Field<NonNullGraphType<IdGraphType>>("id");
+            Field(expression => expression.Name);
             //this.Field(expression => expression.Owner);
-            this.Field<NonNullGraphType<UriGraphType>>("url");
+            Field<NonNullGraphType<UriGraphType>>("url");
         }
 
     }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index 630e793e..2fb39ab3 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -10,7 +10,7 @@ public class TestQuery : ObjectGraphType
 
         public TestQuery()
         {
-            this.Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context =>
+            Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context =>
             {
                 var owner = context.GetArgument<string>("owner");
                 var name = context.GetArgument<string>("name");
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
index efdfebb9..a61d3558 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
@@ -8,7 +8,7 @@ public class TestSchema : Schema
 
         public TestSchema()
         {
-            this.Query = new TestQuery();
+            Query = new TestQuery();
             //this.Mutation = new TestMutation();
             //this.Subscription = new TestSubscription();
         }
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index cc1180ab..d330ed5d 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -16,7 +16,7 @@ public class Startup
 
         public Startup(IConfiguration configuration)
         {
-            this.Configuration = configuration;
+            Configuration = configuration;
         }
 
         public void Configure(IApplicationBuilder app)
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index c6ab7df6..09269167 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -6,10 +6,7 @@ namespace IntegrationTestServer
 {
     public class Program
     {
-        public static void Main(string[] args)
-        {
-            CreateWebHostBuilder(args).Build().Run();
-        }
+        public static void Main(string[] args) => CreateWebHostBuilder(args).Build().Run();
 
         public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
             WebHost.CreateDefaultBuilder(args)
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 1fad77cb..71a76d67 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -56,18 +56,18 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
 
             app.UseWebSockets();
 
-            ConfigureGraphQLSchema<ChatSchema>(app, Common.ChatEndpoint);
-            ConfigureGraphQLSchema<StarWarsSchema>(app, Common.StarWarsEndpoint);
+            ConfigureGraphQLSchema<ChatSchema>(app, Common.CHAT_ENDPOINT);
+            ConfigureGraphQLSchema<StarWarsSchema>(app, Common.STAR_WARS_ENDPOINT);
 
             app.UseGraphiQLServer(new GraphiQLOptions
             {
                 GraphiQLPath = "/ui/graphiql",
-                GraphQLEndPoint = Common.StarWarsEndpoint
+                GraphQLEndPoint = Common.STAR_WARS_ENDPOINT
             });
             app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
             {
                 Path = "/ui/playground",
-                GraphQLEndPoint = Common.ChatEndpoint
+                GraphQLEndPoint = Common.CHAT_ENDPOINT
             });
         }
 

From 8d4613f03037e01e4752c621402d53963eeb5587 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 20 Mar 2020 23:44:56 +0100
Subject: [PATCH 221/455] fix ReadToken in GraphQLExtensionsConverter for
 Newtonsoft

---
 .../GraphQLExtensionsConverter.cs             | 31 +++++++------------
 .../Chat/Schema/ChatQuery.cs                  |  3 +-
 2 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
index 6ff25eb3..77c7e101 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
@@ -24,26 +24,17 @@ public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectTyp
         }
 
         private object ReadToken(JToken? token) =>
-            token.Type switch
+            token switch
             {
-                JTokenType.Undefined => null,
-                JTokenType.None => null,
-                JTokenType.Null => null,
-                JTokenType.Object => ReadDictionary<Dictionary<string, object>>(token),
-                JTokenType.Array => ReadArray(token),
-                JTokenType.Integer => token.Value<int>(),
-                JTokenType.Float => token.Value<double>(),
-                JTokenType.Raw => token.Value<string>(),
-                JTokenType.String => token.Value<string>(),
-                JTokenType.Uri => token.Value<string>(),
-                JTokenType.Boolean => token.Value<bool>(),
-                JTokenType.Date => token.Value<DateTime>(),
-                JTokenType.Bytes => token.Value<byte[]>(),
-                JTokenType.Guid => token.Value<Guid>(),
-                JTokenType.TimeSpan => token.Value<TimeSpan>(),
-                JTokenType.Constructor => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON constructor"),
-                JTokenType.Property => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON property"),
-                JTokenType.Comment => throw new ArgumentOutOfRangeException(nameof(token.Type), "cannot deserialize a JSON comment"),
+                JObject jObject => ReadDictionary<Dictionary<string, object>>(jObject),
+                JArray jArray => ReadArray(jArray),
+                JValue jValue => jValue.Value,
+                JConstructor _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                    "cannot deserialize a JSON constructor"),
+                JProperty _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                    "cannot deserialize a JSON property"),
+                JContainer _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                    "cannot deserialize a JSON comment"),
                 _ => throw new ArgumentOutOfRangeException(nameof(token.Type))
             };
 
@@ -69,6 +60,8 @@ private IEnumerable<object> ReadArray(JToken element)
             }
         }
 
+        private object ReadNumber(JToken token) => ((JValue) token).Value;
+
         private bool IsUnsupportedJTokenType(JTokenType type) => type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index c058e066..0eb335ef 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -10,7 +10,8 @@ public class ChatQuery : ObjectGraphType
 
         public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
             {"extension1", "hello world"},
-            {"another extension", 4711}
+            {"another extension", 4711},
+            {"long", 19942590700}
         };
 
         // properties for unit testing

From 2c79e45a61d8dd849c2c69a7127b59462db7989a Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 20 Mar 2020 23:48:43 +0100
Subject: [PATCH 222/455] Rename GraphQLExtensionsType to Map

---
 .../{GraphQLExtensionsConverter.cs => MapConverter.cs} |  9 +++++----
 .../NewtonsoftJsonSerializer.cs                        |  2 +-
 .../{GraphQLExtensionsConverter.cs => MapConverter.cs} |  8 ++++----
 .../SystemTextJsonSerializer.cs                        |  2 +-
 src/GraphQL.Primitives/GraphQLError.cs                 |  2 +-
 src/GraphQL.Primitives/GraphQLExtensionsType.cs        | 10 ----------
 src/GraphQL.Primitives/GraphQLResponse.cs              |  2 +-
 src/GraphQL.Primitives/Map.cs                          | 10 ++++++++++
 .../TestData/DeserializeResponseTestData.cs            |  4 ++--
 9 files changed, 25 insertions(+), 24 deletions(-)
 rename src/GraphQL.Client.Serializer.Newtonsoft/{GraphQLExtensionsConverter.cs => MapConverter.cs} (86%)
 rename src/GraphQL.Client.Serializer.SystemTextJson/{GraphQLExtensionsConverter.cs => MapConverter.cs} (87%)
 delete mode 100644 src/GraphQL.Primitives/GraphQLExtensionsType.cs
 create mode 100644 src/GraphQL.Primitives/Map.cs

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
similarity index 86%
rename from src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
rename to src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index 77c7e101..5d4510d6 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQLExtensionsConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -1,23 +1,24 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Serializer.Newtonsoft
 {
-    public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType>
+    public class MapConverter : JsonConverter<Map>
     {
-        public override void WriteJson(JsonWriter writer, GraphQLExtensionsType value, JsonSerializer serializer) =>
+        public override void WriteJson(JsonWriter writer, Map value, JsonSerializer serializer) =>
             throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-        public override GraphQLExtensionsType ReadJson(JsonReader reader, Type objectType, GraphQLExtensionsType existingValue,
+        public override Map ReadJson(JsonReader reader, Type objectType, Map existingValue,
             bool hasExistingValue, JsonSerializer serializer)
         {
             var rootToken = JToken.ReadFrom(reader);
             if (rootToken is JObject)
             {
-                return ReadDictionary<GraphQLExtensionsType>(rootToken);
+                return ReadDictionary<Map>(rootToken);
             }
             else
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 3c6d6c5d..99936421 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -31,7 +31,7 @@ public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
         }
 
         // deserialize extensions to Dictionary<string, object>
-        private void ConfigureMandatorySerializerOptions() => JsonSerializerSettings.Converters.Insert(0, new GraphQLExtensionsConverter());
+        private void ConfigureMandatorySerializerOptions() => JsonSerializerSettings.Converters.Insert(0, new MapConverter());
 
         public string SerializeToString(GraphQLRequest request) => JsonConvert.SerializeObject(request, JsonSerializerSettings);
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
similarity index 87%
rename from src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
rename to src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
index 111f9804..bbaa2fe9 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQLExtensionsConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
@@ -13,9 +13,9 @@ namespace GraphQL.Client.Serializer.SystemTextJson
     /// <remarks>
     /// Taken and modified from GraphQL.SystemTextJson.ObjectDictionaryConverter (GraphQL.NET)
     /// </remarks>
-    public class GraphQLExtensionsConverter : JsonConverter<GraphQLExtensionsType>
+    public class MapConverter : JsonConverter<Map>
     {
-        public override GraphQLExtensionsType Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        public override Map Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
             using var doc = JsonDocument.ParseValue(ref reader);
 
@@ -24,10 +24,10 @@ public override GraphQLExtensionsType Read(ref Utf8JsonReader reader, Type typeT
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
             }
 
-            return ReadDictionary<GraphQLExtensionsType>(doc.RootElement);
+            return ReadDictionary<Map>(doc.RootElement);
         }
 
-        public override void Write(Utf8JsonWriter writer, GraphQLExtensionsType value, JsonSerializerOptions options)
+        public override void Write(Utf8JsonWriter writer, Map value, JsonSerializerOptions options)
             => throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 047c7572..f5b2e7f4 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -30,7 +30,7 @@ public SystemTextJsonSerializer(JsonSerializerOptions options)
         private void ConfigureMandatorySerializerOptions()
         {
             // deserialize extensions to Dictionary<string, object>
-            Options.Converters.Insert(0, new GraphQLExtensionsConverter());
+            Options.Converters.Insert(0, new MapConverter());
             // allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
             Options.PropertyNameCaseInsensitive = true;
         }
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index a1b0d455..0bfe834c 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -34,7 +34,7 @@ public class GraphQLError : IEquatable<GraphQLError?>
         /// The extensions of the error
         /// </summary> 
         [DataMember(Name = "extensions")]
-        public GraphQLExtensionsType? Extensions { get; set; }
+        public Map? Extensions { get; set; }
 
         /// <summary>
         /// Returns a value that indicates whether this instance is equal to a specified object
diff --git a/src/GraphQL.Primitives/GraphQLExtensionsType.cs b/src/GraphQL.Primitives/GraphQLExtensionsType.cs
deleted file mode 100644
index 76599121..00000000
--- a/src/GraphQL.Primitives/GraphQLExtensionsType.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-using System.Collections.Generic;
-
-namespace GraphQL
-{
-
-    /// <summary>
-    /// The GraphQL extensions type. Create a custom json converter for this class to customize your serializers behaviour
-    /// </summary>
-    public class GraphQLExtensionsType : Dictionary<string, object> { }
-}
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index ca14feac..0b2781fd 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -16,7 +16,7 @@ public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?>
         public GraphQLError[]? Errors { get; set; }
 
         [DataMember(Name = "extensions")]
-        public GraphQLExtensionsType? Extensions { get; set; }
+        public Map? Extensions { get; set; }
 
         public override bool Equals(object? obj) => Equals(obj as GraphQLResponse<T>);
 
diff --git a/src/GraphQL.Primitives/Map.cs b/src/GraphQL.Primitives/Map.cs
new file mode 100644
index 00000000..cba91bee
--- /dev/null
+++ b/src/GraphQL.Primitives/Map.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace GraphQL
+{
+
+    /// <summary>
+    /// A type equivalent to a javascript map. Create a custom json converter for this class to customize your serializers behaviour
+    /// </summary>
+    public class Map : Dictionary<string, object> { }
+}
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
index 166414a2..0c6844cf 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -18,13 +18,13 @@ public IEnumerator<object[]> GetEnumerator()
                     Errors = new[] {
                         new GraphQLError {
                             Message = "Throttled",
-                            Extensions = new GraphQLExtensionsType {
+                            Extensions = new Map {
                                 {"code", "THROTTLED" },
                                 {"documentation", "https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits" }
                             }
                         }
                     },
-                    Extensions = new GraphQLExtensionsType {
+                    Extensions = new Map {
                         {"cost", new Dictionary<string, object> {
                             {"requestedQueryCost", 992},
                             {"actualQueryCost", null},

From 305d917d1c1810659a1311e483b2861fa0d201f1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 21 Mar 2020 00:01:44 +0100
Subject: [PATCH 223/455] remove default serializer

---
 README.md                                     |  2 +-
 examples/GraphQL.Client.Example/Program.cs    |  3 ++-
 src/GraphQL.Client/GraphQL.Client.csproj      |  1 -
 src/GraphQL.Client/GraphQLHttpClient.cs       | 22 ++++++++++---------
 .../GraphQLHttpClientOptions.cs               |  6 -----
 src/GraphQL.Client/HttpClientExtensions.cs    | 20 -----------------
 .../Websocket/GraphQLHttpWebSocket.cs         |  8 +++----
 .../WebApplicationFactoryExtensions.cs        | 19 ----------------
 .../GraphQL.Integration.Tests.csproj          |  4 ++++
 .../Helpers/WebHostHelpers.cs                 |  6 ++---
 10 files changed, 26 insertions(+), 65 deletions(-)
 delete mode 100644 src/GraphQL.Client/HttpClientExtensions.cs
 delete mode 100644 tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs

diff --git a/README.md b/README.md
index 02f6dee7..60fd2bd1 100644
--- a/README.md
+++ b/README.md
@@ -51,7 +51,7 @@ Be careful when using `byte[]` in your variables object, as most JSON serializer
 ### Execute Query/Mutation:
 
 ```csharp
-var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
+var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
 
 public class PersonAndFilmsResponse {
     public PersonContent Person { get; set; }
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index 5dd2b1d6..2ef597ec 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -3,6 +3,7 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using GraphQL.Client.Http;
+using GraphQL.Client.Serializer.Newtonsoft;
 
 namespace GraphQL.Client.Example
 {
@@ -13,7 +14,7 @@ public class Program
         public static async Task Main(string[] args)
         {
             _ = args;
-            using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/");
+            using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
 
             var personAndFilmsRequest = new GraphQLRequest
             {
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 3b11e942..d1d723f9 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -36,7 +36,6 @@
 	<ItemGroup>
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
-	  <ProjectReference Include="..\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
 	</ItemGroup>
 
 	
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index a6a7a763..74ec0b46 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -19,7 +19,11 @@ public class GraphQLHttpClient : IGraphQLClient
         private readonly GraphQLHttpWebSocket _graphQlHttpWebSocket;
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
-        private IGraphQLWebsocketJsonSerializer JsonSerializer => Options.JsonSerializer;
+
+        /// <summary>
+        /// the json serializer
+        /// </summary>
+        public IGraphQLWebsocketJsonSerializer JsonSerializer { get; }
 
         /// <summary>
         /// the instance of <see cref="HttpClient"/> which is used internally
@@ -44,20 +48,18 @@ public class GraphQLHttpClient : IGraphQLClient
 
         #region Constructors
 
-        public GraphQLHttpClient(string endPoint) : this(new Uri(endPoint)) { }
-
-        public GraphQLHttpClient(Uri endPoint) : this(o => o.EndPoint = endPoint) { }
-
-        public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure) : this(configure.New()) { }
+        public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serializer) : this(new Uri(endPoint), serializer) { }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options) : this(options, new HttpClient(options.HttpMessageHandler)) { }
+        public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serializer) : this(o => o.EndPoint = endPoint, serializer) { }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient) : this(options, httpClient, new NewtonsoftJsonSerializer()) { }
+        public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer) : this(configure.New(), serializer) { }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options, HttpClient httpClient, IGraphQLWebsocketJsonSerializer serializer)
+        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer) : this(options, serializer, new HttpClient(options.HttpMessageHandler)) { }
+        
+        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
         {
             Options = options ?? throw new ArgumentNullException(nameof(options));
-            Options.JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
+            JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
             HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
             _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
         }
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 915ad967..6b93cb7b 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -2,7 +2,6 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Threading.Tasks;
-using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Http
 {
@@ -18,11 +17,6 @@ public class GraphQLHttpClientOptions
         /// </summary>
         public Uri EndPoint { get; set; }
 
-        /// <summary>
-        /// the json serializer
-        /// </summary>
-        public IGraphQLWebsocketJsonSerializer JsonSerializer { get; set; }
-
         /// <summary>
         /// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
         /// </summary>
diff --git a/src/GraphQL.Client/HttpClientExtensions.cs b/src/GraphQL.Client/HttpClientExtensions.cs
deleted file mode 100644
index 06315817..00000000
--- a/src/GraphQL.Client/HttpClientExtensions.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using System;
-using System.Net.Http;
-
-namespace GraphQL.Client.Http
-{
-
-    public static class HttpClientExtensions
-    {
-
-        public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, string endPoint) =>
-            httpClient.AsGraphQLClient(new Uri(endPoint));
-
-        public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
-            new GraphQLHttpClient(new GraphQLHttpClientOptions { EndPoint = endPoint }, httpClient);
-
-        public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
-            new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
-    }
-
-}
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 50351075..f0156030 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -139,7 +139,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                                         // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
                                         Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
                                         var typedResponse =
-                                            _client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                            _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
                                                 response.MessageBytes);
                                         o.OnNext(typedResponse.Payload);
 
@@ -296,7 +296,7 @@ public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest re
                         {
                             Debug.WriteLine($"received response for request {websocketRequest.Id}");
                             var typedResponse =
-                                _client.Options.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
                                     response.MessageBytes);
                             return typedResponse.Payload;
                         });
@@ -353,7 +353,7 @@ private async Task SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
                 }
 
                 await InitializeWebSocket();
-                var requestBytes = Options.JsonSerializer.SerializeToBytes(request);
+                var requestBytes = _client.JsonSerializer.SerializeToBytes(request);
                 await _clientWebSocket.SendAsync(
                     new ArraySegment<byte>(requestBytes),
                     WebSocketMessageType.Text,
@@ -554,7 +554,7 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
 
                 if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
                 {
-                    var response = await Options.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+                    var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
                     response.MessageBytes = ms.ToArray();
                     Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
                     return response;
diff --git a/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
deleted file mode 100644
index 546b6a8e..00000000
--- a/tests/GraphQL.Integration.Tests/Extensions/WebApplicationFactoryExtensions.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-using System;
-using GraphQL.Client.Http;
-using Microsoft.AspNetCore.Mvc.Testing;
-
-namespace GraphQL.Integration.Tests.Extensions
-{
-    public static class WebApplicationFactoryExtensions
-    {
-        public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
-            this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint : class
-        {
-            var httpClient = factory.CreateClient();
-            var uriBuilder = new UriBuilder(httpClient.BaseAddress);
-            uriBuilder.Path = graphQlSchemaUrl;
-            uriBuilder.Scheme = urlScheme;
-            return httpClient.AsGraphQLClient(uriBuilder.Uri);
-        }
-    }
-}
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index e2e2d726..23c1c85d 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -28,4 +28,8 @@
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Extensions\" />
+  </ItemGroup>
+
 </Project>
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 38704066..81ff2248 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -41,9 +41,9 @@ public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool
             => new GraphQLHttpClient(new GraphQLHttpClientOptions
             {
                 EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
-                UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
-                JsonSerializer = serializer ?? new NewtonsoftJsonSerializer()
-            });
+                UseWebSocketForQueriesAndMutations = requestsViaWebsocket
+            },
+                serializer ?? new NewtonsoftJsonSerializer());
     }
 
     public class TestServerSetup : IDisposable

From b5817f3e91108d7608706eaac3e579651684eddb Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 21 Mar 2020 00:09:14 +0100
Subject: [PATCH 224/455] fix references

---
 examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj | 1 +
 src/GraphQL.Client/GraphQLHttpClient.cs                       | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index d9680f86..54506df0 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -7,6 +7,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
+		<ProjectReference Include="..\..\src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
 		<ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
 	</ItemGroup>
 
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 74ec0b46..36f24198 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -8,7 +8,6 @@
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
-using GraphQL.Client.Serializer.Newtonsoft;
 
 namespace GraphQL.Client.Http
 {

From 435fe58635c19de2567a0c015556fb0c84be5b1f Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 21 Mar 2020 00:13:59 +0100
Subject: [PATCH 225/455] skip test with dynamic response type

---
 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 72a28d60..550eb6a0 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -73,7 +73,7 @@ public async void QueryAsHttpResponseTheory(int id, string name)
             httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));
         }
 
-        [Theory]
+        [Theory(Skip = "System.Json.Net deserializes 'dynamic' as JsonElement.")]
         [ClassData(typeof(StarWarsHumans))]
         public async void QueryWithDynamicReturnTypeTheory(int id, string name)
         {

From 3d3211d4fd8ef5e507480c0043db569caf106a90 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 21 Mar 2020 14:55:28 +0100
Subject: [PATCH 226/455] Update
 tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj

Co-Authored-By: Ivan Maximov <sungam3r@yandex.ru>
---
 .../GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 23c1c85d..777bd6ed 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -28,8 +28,5 @@
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Folder Include="Extensions\" />
-  </ItemGroup>
 
 </Project>

From 19382ad153961493fa8360da762554f285a28173 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 21 Mar 2020 15:17:53 +0100
Subject: [PATCH 227/455] remove unused method in map converter

---
 src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index 5d4510d6..f15787e8 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -61,8 +61,6 @@ private IEnumerable<object> ReadArray(JToken element)
             }
         }
 
-        private object ReadNumber(JToken token) => ((JValue) token).Value;
-
         private bool IsUnsupportedJTokenType(JTokenType type) => type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
     }
 }

From 7fb6dca36009ae08655b95d2d6dd2dd8b077594b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 26 Mar 2020 11:37:18 +0100
Subject: [PATCH 228/455] fix constructor parameter checks, add message to
 argument exception

---
 .../GraphQLJsonSerializerExtensions.cs        | 21 -------------------
 .../GraphQLLocalExecutionClient.cs            | 17 +++++----------
 src/GraphQL.Client/GraphQLHttpClient.cs       |  2 +-
 3 files changed, 6 insertions(+), 34 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index ded17d39..9222690c 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -1,30 +1,9 @@
 using System;
-using System.Linq;
 
 namespace GraphQL.Client.Abstractions
 {
     public static class GraphQLJsonSerializerExtensions
     {
-        public static TSerializerInterface EnsureAssigned<TSerializerInterface>(this TSerializerInterface jsonSerializer) where TSerializerInterface : IGraphQLJsonSerializer
-        {
-            // if no serializer was assigned
-            if (jsonSerializer == null)
-            {
-                // try to find one in the assembly and assign that
-                var type = typeof(TSerializerInterface);
-                var serializerType = AppDomain.CurrentDomain
-                    .GetAssemblies()
-                    .SelectMany(s => s.GetTypes())
-                    .FirstOrDefault(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract);
-                if (serializerType == null)
-                    throw new InvalidOperationException($"no implementation of \"{type}\" found");
-
-                jsonSerializer = (TSerializerInterface)Activator.CreateInstance(serializerType);
-            }
-
-            return jsonSerializer;
-        }
-
         public static TOptions New<TOptions>(this Action<TOptions> configure) =>
             configure.AndReturn(Activator.CreateInstance<TOptions>());
 
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 574cd226..c055cecb 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -18,9 +18,6 @@ namespace GraphQL.Client.LocalExecution
 {
     public static class GraphQLLocalExecutionClient
     {
-        public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema) where TSchema : ISchema
-            => new GraphQLLocalExecutionClient<TSchema>(schema);
-
         public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer serializer) where TSchema : ISchema
             => new GraphQLLocalExecutionClient<TSchema>(schema, serializer);
     }
@@ -46,20 +43,16 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
 
         private readonly DocumentExecuter _documentExecuter;
 
-        public GraphQLLocalExecutionClient(TSchema schema)
+        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer)
         {
-            Serializer.EnsureAssigned();
-            Schema = schema;
+            Schema = schema ?? throw new ArgumentNullException(nameof(schema), "no schema configured");
+            Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
+
             if (!Schema.Initialized)
                 Schema.Initialize();
             _documentExecuter = new DocumentExecuter();
         }
-
-        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer) : this(schema)
-        {
-            Serializer = serializer;
-        }
-
+        
         public void Dispose() { }
 
         public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 36f24198..72b4b907 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -58,7 +58,7 @@ public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWeb
         public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
         {
             Options = options ?? throw new ArgumentNullException(nameof(options));
-            JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
+            JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
             HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
             _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
         }

From f40c77adf0e4d0ed12af5867d90a765dded417eb Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 26 Mar 2020 11:38:11 +0100
Subject: [PATCH 229/455] remove Newtonsoft.Json nuget from GraphQL.Client

---
 src/GraphQL.Client/GraphQL.Client.csproj | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index d1d723f9..0e0119ba 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -25,7 +25,6 @@
 
 
 	<ItemGroup>
-		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
 		<PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
 	</ItemGroup>
 

From f2a6954b2da6e367e8943f5cabdafd6949759181 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 26 Mar 2020 11:43:19 +0100
Subject: [PATCH 230/455] fix package descriptions

---
 .../GraphQL.Client.Abstractions.Websocket.csproj               | 3 ++-
 .../GraphQL.Client.Abstractions.csproj                         | 2 +-
 .../GraphQL.Client.LocalExecution.csproj                       | 2 +-
 .../GraphQL.Client.Serializer.Newtonsoft.csproj                | 1 +
 .../GraphQL.Client.Serializer.SystemTextJson.csproj            | 1 +
 5 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index 8623791f..c191671f 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -2,7 +2,8 @@
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
-	<TargetFramework>netstandard2.0</TargetFramework>
+    <Description>Abstractions for the Websocket transport used in GraphQL.Client</Description>
+	  <TargetFramework>netstandard2.0</TargetFramework>
 	  <LangVersion>8.0</LangVersion>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 78972572..63e9aa89 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -3,7 +3,7 @@
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
-		<Description>A GraphQL Client</Description>
+		<Description>Abstractions for GraphQL.Client</Description>
 		<RootNamespace>GraphQL.Client.Abstractions</RootNamespace>
 		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 3cd19e04..927c3470 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -3,7 +3,7 @@
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
-		<Description>A GraphQL Client which executes the queries directly on a provided C# schema</Description>
+		<Description>A GraphQL Client which executes the queries directly on a provided GraphQL schema using graphql-dotnet</Description>
 		<TargetFramework>netstandard2.0</TargetFramework>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index 4c6e0e77..c492b1ed 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -2,6 +2,7 @@
 	<Import Project="../src.props" />
 
   <PropertyGroup>
+    <Description>A serializer implementation for GraphQL.Client using Newtonsoft.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
 	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index 8f8bc66a..e8be48d7 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -2,6 +2,7 @@
 	<Import Project="../src.props" />
 
   <PropertyGroup>
+    <Description>A serializer implementation for GraphQL.Client using System.Text.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
 	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>

From a4a6cd32d20639b8f730a0047ab05e9c667734d4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 2 Apr 2020 14:24:24 +0200
Subject: [PATCH 231/455] use FluentTestObserver to test subscriptions

---
 .../FluentTestObserver.cs                     |  88 +++++++++
 .../NoSynchronizationContextScope.cs          |  40 ++++
 .../ObservableAssertions.cs                   | 183 ++++++++++++++++++
 .../ObservableExtensions.cs                   |  86 ++++++++
 .../RollingReplaySubject.cs                   |  64 ++++++
 .../GraphQL.Client.Tests.Common.csproj        |   1 +
 .../Helpers/ObservableTester.cs               | 175 -----------------
 .../WebsocketTests/Base.cs                    |  99 +++++-----
 8 files changed, 515 insertions(+), 221 deletions(-)
 create mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
 delete mode 100644 tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
new file mode 100644
index 00000000..521af220
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reactive;
+using System.Reactive.Concurrency;
+using System.Reactive.Linq;
+using System.Threading;
+using Microsoft.Reactive.Testing;
+
+namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
+{
+    /// <summary>
+    /// Observer for testing <see cref="Observable"/>s using the FluentAssertions framework
+    /// </summary>
+    /// <typeparam name="TPayload"></typeparam>
+    public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
+    {
+        private readonly IDisposable _subscription;
+        private readonly EventLoopScheduler _observeScheduler = new EventLoopScheduler();
+        private readonly RollingReplaySubject<Recorded<Notification<TPayload>>> _rollingReplaySubject = new RollingReplaySubject<Recorded<Notification<TPayload>>>();
+
+        /// <summary>
+        /// The observable which is observed by this instance
+        /// </summary>
+        public IObservable<TPayload> Subject { get; }
+
+        /// <summary>
+        /// The stream of recorded <see cref="Notification{T}"/>s
+        /// </summary>
+        public IObservable<Recorded<Notification<TPayload>>> RecordedNotificationStream => _rollingReplaySubject.AsObservable();
+
+        /// <summary>
+        /// The recorded <see cref="Notification{T}"/>s
+        /// </summary>
+        public IEnumerable<Recorded<Notification<TPayload>>> RecordedNotifications =>
+            _rollingReplaySubject.Snapshot();
+
+        /// <summary>
+        /// The recorded messages
+        /// </summary>
+        public IEnumerable<TPayload> RecordedMessages =>
+            RecordedNotifications.GetMessages();
+
+        /// <summary>
+        /// Creates a new <see cref="FluentTestObserver{TPayload}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
+        /// </summary>
+        /// <param name="subject">the <see cref="IObservable{T}"/> under test</param>
+        public FluentTestObserver(IObservable<TPayload> subject)
+        {
+            Subject = subject;
+            _observeScheduler.Schedule(() =>
+                Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
+
+            _subscription = subject.ObserveOn(_observeScheduler).Subscribe(this);
+        }
+
+        /// <summary>
+        /// Clears the recorded notifications and messages as well as the recorded notifications stream buffer
+        /// </summary>
+        public void Clear() => _rollingReplaySubject.Clear();
+
+        /// <inheritdoc />
+        public void OnNext(TPayload value) =>
+            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
+
+        /// <inheritdoc />
+        public void OnError(Exception exception) =>
+            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnError<TPayload>(exception)));
+
+        /// <inheritdoc />
+        public void OnCompleted() =>
+            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnCompleted<TPayload>()));
+        
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            _subscription?.Dispose();
+            _observeScheduler.Dispose();
+            _rollingReplaySubject?.Dispose();
+        }
+
+        /// <summary>
+        /// Returns an <see cref="ObservableAssertions{TPayload}"/> object that can be used to assert the observed <see cref="IObservable{T}"/>
+        /// </summary>
+        /// <returns></returns>
+        public ObservableAssertions<TPayload> Should() => new ObservableAssertions<TPayload>(this);
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs
new file mode 100644
index 00000000..c728a671
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
+{
+    internal static class NoSynchronizationContextScope
+    {
+        public static T ExecuteInDefaultSynchronizationContext<T>(this Task<T> task)
+        {
+            using (NoSynchronizationContextScope.Enter())
+            {
+                task.Wait();
+                return task.Result;
+            }
+        }
+
+        public static DisposingAction Enter()
+        {
+            var context = SynchronizationContext.Current;
+            SynchronizationContext.SetSynchronizationContext(null);
+            return new DisposingAction(() => SynchronizationContext.SetSynchronizationContext(context));
+        }
+
+        internal class DisposingAction : IDisposable
+        {
+            private readonly Action action;
+
+            public DisposingAction(Action action)
+            {
+                this.action = action;
+            }
+
+            public void Dispose()
+            {
+                action();
+            }
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
new file mode 100644
index 00000000..697145f8
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reactive;
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
+using FluentAssertions;
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+using Microsoft.Reactive.Testing;
+
+namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
+{
+    /// <summary>
+    /// Provides methods to assert an <see cref="IObservable{T}"/> observed by a <see cref="FluentTestObserver{TPayload}"/>
+    /// </summary>
+    /// <typeparam name="TPayload"></typeparam>
+    public class ObservableAssertions<TPayload> : ReferenceTypeAssertions<IObservable<TPayload>, ObservableAssertions<TPayload>>
+    {
+        public FluentTestObserver<TPayload> Observer { get; }
+
+        protected internal ObservableAssertions(FluentTestObserver<TPayload> observer): base(observer.Subject)
+        {
+            Observer = observer;
+        }
+
+        protected override string Identifier => "Subscription";
+        
+        /// <summary>
+        /// Asserts that at least <paramref name="numberOfNotifications"/> notifications were pushed to the <see cref="FluentTestObserver{TPayload}"/> within the specified <paramref name="timeout"/>.<br />
+        /// This includes any previously recorded notifications since it has been created or cleared. 
+        /// </summary>
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(int numberOfNotifications, TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            var notifications = Observer.RecordedNotificationStream
+                .Where(recorded => recorded.Value.Kind == NotificationKind.OnNext)
+                .Take(numberOfNotifications)
+                .Timeout(timeout)
+                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
+                .ToList()
+                .ToTask()
+                .ExecuteInDefaultSynchronizationContext();
+            
+            Execute.Assertion
+                .ForCondition(notifications.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {0} to push at least one notification within {1}{reason}, but it did not.", Observer.Subject, timeout);
+
+            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>(this, notifications);
+        }
+
+        /// <summary>
+        /// Asserts that at least <paramref name="numberOfNotifications"/> notifications are pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
+        /// This includes any previously recorded notifications since it has been created or cleared. 
+        /// </summary>
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
+            => Push(numberOfNotifications, TimeSpan.FromSeconds(1), because, becauseArgs);
+
+        /// <summary>
+        /// Asserts that at least 1 notification is pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
+        /// This includes any previously recorded notifications since it has been created or cleared. 
+        /// </summary>
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(string because = "", params object[] becauseArgs)
+            => Push(1, TimeSpan.FromSeconds(1), because, becauseArgs);
+
+
+        /// <summary>
+        /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the specified <paramref name="timeout"/>.<br />
+        /// This includes any previously recorded notifications since it has been created or cleared. 
+        /// </summary>
+        public AndConstraint<ObservableAssertions<TPayload>> NotPush(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            bool anyNotifications = Observer.RecordedNotificationStream
+                .Any(recorded => recorded.Value.Kind == NotificationKind.OnNext)
+                .Timeout(timeout)
+                .Catch(Observable.Return(false))
+                .ToTask()
+                .ExecuteInDefaultSynchronizationContext();
+
+            Execute.Assertion
+                .ForCondition(!anyNotifications)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {0} to not push any notifications{reason}, but it did.", Observer.Subject);
+            
+            return new AndConstraint<ObservableAssertions<TPayload>>(this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the next 100 milliseconds.<br />
+        /// This includes any previously recorded notifications since it has been created or last cleared. 
+        /// </summary>
+        public AndConstraint<ObservableAssertions<TPayload>> NotPush(string because = "", params object[] becauseArgs)
+            => NotPush(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+
+
+        /// <summary>
+        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the specified <paramref name="timeout"/>. 
+        /// </summary>
+        public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            var exception = Observer.RecordedNotificationStream
+                .Timeout(timeout)
+                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
+                .FirstOrDefaultAsync(recorded => recorded.Value.Kind == NotificationKind.OnError)
+                .Select(recorded => recorded.Value.Exception)
+                .ToTask()
+                .ExecuteInDefaultSynchronizationContext();
+
+            Execute.Assertion
+                .ForCondition(exception != null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {0} to fail within {1}{reason}, but it did not.", Observer.Subject, timeout);
+            
+            return new AndWhichConstraint<ObservableAssertions<TPayload>, Exception>(this, exception);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the next 1 second. 
+        /// </summary>
+        public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(string because = "", params object[] becauseArgs)
+            => Fail(TimeSpan.FromSeconds(1), because, becauseArgs);
+
+
+        /// <summary>
+        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the specified <paramref name="timeout"/>. 
+        /// </summary>
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Complete(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+
+            bool completed = Observer.RecordedNotificationStream
+                .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
+                .Timeout(timeout)
+                .Catch(Observable.Return(false))
+                .ToTask()
+                .ExecuteInDefaultSynchronizationContext();
+            
+            Execute.Assertion
+                .ForCondition(completed)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {0} to complete within {1}{reason}, but it did not.", Observer.Subject, timeout);
+
+            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>(this, Observer.RecordedNotifications);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the next 1 second. 
+        /// </summary>
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Complete(string because = "", params object[] becauseArgs)
+            => Complete(TimeSpan.FromSeconds(1), because, becauseArgs);
+
+
+        /// <summary>
+        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the specified <paramref name="timeout"/>. 
+        /// </summary>
+        public AndConstraint<ObservableAssertions<TPayload>> NotComplete(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            bool completed = Observer.RecordedNotificationStream
+                .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
+                .Timeout(timeout)
+                .Catch(Observable.Return(false))
+                .ToTask()
+                .ExecuteInDefaultSynchronizationContext();
+
+            Execute.Assertion
+                .ForCondition(!completed)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {0} to not complete{reason}, but it did.", Observer.Subject);
+            
+            return new AndConstraint<ObservableAssertions<TPayload>>(this);
+        }
+
+        /// <summary>
+        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the next 100 milliseconds. 
+        /// </summary>
+        public AndConstraint<ObservableAssertions<TPayload>> NotComplete(string because = "", params object[] becauseArgs)
+            => NotComplete(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
new file mode 100644
index 00000000..0fd4afa7
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reactive;
+using FluentAssertions;
+using FluentAssertions.Execution;
+using Microsoft.Reactive.Testing;
+
+namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
+{
+    public static class ObservableExtensions
+    {
+        /// <summary>
+        /// Create a new <see cref="FluentTestObserver{TPayload}"/> subscribed to this <paramref name="observable"/>
+        /// </summary>
+        public static FluentTestObserver<T> Observe<T>(this IObservable<T> observable) => new FluentTestObserver<T>(observable);
+
+        /// <summary>
+        /// Asserts that the recorded messages contain at lease one item which matches the <paramref name="predicate"/>
+        /// </summary>
+        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> WithMessage<TPayload>(
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
+        {
+            if (predicate is null) throw new ArgumentNullException(nameof(predicate));
+            
+            var compiledPredicate = predicate.Compile();
+            bool match = recorderConstraint.GetMessages().Any(compiledPredicate);
+            
+            Execute.Assertion
+                .ForCondition(match)
+                .FailWith("Expected at least one message from {0} to match {1}, but found none.", recorderConstraint.And.Subject, predicate.Body);
+
+            return recorderConstraint;
+        }
+
+        /// <summary>
+        /// Asserts that the last recorded message matches the <paramref name="predicate"/>
+        /// </summary>
+        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> WithLastMessage<TPayload>(
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
+        {
+            if (predicate is null)
+                throw new ArgumentNullException(nameof(predicate));
+
+            bool match = predicate.Compile().Invoke(recorderConstraint.GetLastMessage());
+
+            Execute.Assertion
+                .ForCondition(match)
+                .FailWith("Expected the last message from {0} to match {1}, but it did not.", recorderConstraint.And.Subject, predicate.Body);
+            
+            return recorderConstraint;
+        }
+
+        /// <summary>
+        /// Extracts the last recorded message
+        /// </summary>
+        public static TPayload GetLastMessage<TPayload>(
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
+                recorderConstraint) =>
+            recorderConstraint.GetMessages().LastOrDefault();
+
+        /// <summary>
+        /// Extracts the recorded messages
+        /// </summary>
+        public static IEnumerable<TPayload> GetMessages<TPayload>(
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
+            recorderConstraint) => recorderConstraint.Subject.GetMessages();
+
+        /// <summary>
+        /// Extracts the recorded messages from a number od recorded notifications
+        /// </summary>
+        public static IEnumerable<TPayload> GetMessages<TPayload>(
+            this IEnumerable<Recorded<Notification<TPayload>>> recordedNotifications) => recordedNotifications
+            .Where(r => r.Value.Kind == NotificationKind.OnNext)
+            .Select(recorded => recorded.Value.Value);
+
+
+        /// <summary>
+        /// Clears the recorded notifications on the underlying <see cref="FluentTestObserver{TPayload}"/>
+        /// </summary>
+        public static void Clear<TPayload>(
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
+                recorderConstraint) => recorderConstraint.And.Observer.Clear();
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
new file mode 100644
index 00000000..eef1d294
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
+{
+    /// <summary>
+    /// Clearable <see cref="ReplaySubject{T}"/> taken from James World: https://stackoverflow.com/a/28945444/4340541
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class RollingReplaySubject<T> : ISubject<T>, IDisposable
+    {
+        private readonly ReplaySubject<IObservable<T>> _subjects;
+        private readonly IObservable<T> _concatenatedSubjects;
+        private ISubject<T> _currentSubject;
+
+        public RollingReplaySubject()
+        {
+            _subjects = new ReplaySubject<IObservable<T>>(1);
+            _concatenatedSubjects = _subjects.Concat();
+            _currentSubject = new ReplaySubject<T>();
+            _subjects.OnNext(_currentSubject);
+        }
+
+        public void Clear()
+        {
+            _currentSubject.OnCompleted();
+            _currentSubject = new ReplaySubject<T>();
+            _subjects.OnNext(_currentSubject);
+        }
+
+        public void OnNext(T value) => _currentSubject.OnNext(value);
+
+        public void OnError(Exception error) => _currentSubject.OnError(error);
+
+        public void OnCompleted()
+        {
+            _currentSubject.OnCompleted();
+            _subjects.OnCompleted();
+            // a quick way to make the current ReplaySubject unreachable
+            // except to in-flight observers, and not hold up collection
+            _currentSubject = new Subject<T>();
+        }
+
+        public IDisposable Subscribe(IObserver<T> observer) => _concatenatedSubjects.Subscribe(observer);
+
+        public IEnumerable<T> Snapshot()
+        {
+            var snapshot = new List<T>();
+            using (this.Subscribe(item => snapshot.Add(item)))
+            {
+                // Deliberately empty; subscribing will add everything to the list.
+            }
+            return snapshot;
+        }
+
+        public void Dispose()
+        {
+            OnCompleted();
+            _subjects?.Dispose();
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index dfbb9146..4fd09bf5 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -11,6 +11,7 @@
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
+    <PackageReference Include="Microsoft.Reactive.Testing" Version="4.3.2" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
   </ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
deleted file mode 100644
index dad65ff1..00000000
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ /dev/null
@@ -1,175 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Reactive.Concurrency;
-using System.Reactive.Linq;
-using System.Threading;
-using FluentAssertions;
-using FluentAssertions.Execution;
-using FluentAssertions.Primitives;
-
-namespace GraphQL.Client.Tests.Common.Helpers
-{
-    public class ObservableTester<TSubscriptionPayload> : IDisposable
-    {
-        private readonly IDisposable _subscription;
-        private readonly ManualResetEventSlim _updateReceived = new ManualResetEventSlim();
-        private readonly ManualResetEventSlim _completed = new ManualResetEventSlim();
-        private readonly ManualResetEventSlim _error = new ManualResetEventSlim();
-        private readonly EventLoopScheduler _observeScheduler = new EventLoopScheduler();
-
-        /// <summary>
-        /// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
-        /// </summary>
-        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
-
-        /// <summary>
-        /// Indicates that an update has been received since the last <see cref="_reset"/>
-        /// </summary>
-        public bool UpdateReceived => _updateReceived.IsSet;
-        /// <summary>
-        /// The last payload which was received.
-        /// </summary>
-        public TSubscriptionPayload LastPayload { get; private set; }
-
-        public Exception Error { get; private set; }
-
-        /// <summary>
-        /// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
-        /// </summary>
-        /// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
-        public ObservableTester(IObservable<TSubscriptionPayload> observable)
-        {
-
-            _observeScheduler.Schedule(() =>
-                Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
-
-            _subscription = observable.ObserveOn(_observeScheduler).Subscribe(
-                obj =>
-                {
-                    Debug.WriteLine($"observable tester {GetHashCode()}: payload received");
-                    LastPayload = obj;
-                    _updateReceived.Set();
-                },
-                ex =>
-                {
-                    Debug.WriteLine($"observable tester {GetHashCode()} error received: {ex}");
-                    Error = ex;
-                    _error.Set();
-                },
-                () =>
-                {
-                    Debug.WriteLine($"observable tester {GetHashCode()}: completed");
-                    _completed.Set();
-                });
-        }
-
-        /// <summary>
-        /// Resets the tester class. Should be called before triggering the potential update
-        /// </summary>
-        private void Reset() => _updateReceived.Reset();
-
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            _subscription?.Dispose();
-            _observeScheduler.Dispose();
-        }
-
-        public SubscriptionAssertions<TSubscriptionPayload> Should() => new SubscriptionAssertions<TSubscriptionPayload>(this);
-
-        public class SubscriptionAssertions<TPayload> : ReferenceTypeAssertions<ObservableTester<TPayload>, SubscriptionAssertions<TPayload>>
-        {
-            public SubscriptionAssertions(ObservableTester<TPayload> tester)
-            {
-                Subject = tester;
-            }
-
-            protected override string Identifier => "Subscription";
-
-            public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(TimeSpan timeout,
-                string because = "", params object[] becauseArgs)
-            {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .Given(() =>
-                    {
-                        var isSet = Subject._updateReceived.Wait(timeout);
-                        if (!isSet)
-                            Debug.WriteLine($"waiting for payload on thread {Thread.CurrentThread.ManagedThreadId} timed out!");
-                        return isSet;
-                    })
-                    .ForCondition(isSet => isSet)
-                    .FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
-
-                Subject._updateReceived.Reset();
-                return new AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
-            }
-            public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(string because = "", params object[] becauseArgs)
-                => HaveReceivedPayload(Subject.Timeout, because, becauseArgs);
-
-            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(TimeSpan timeout,
-                string because = "", params object[] becauseArgs)
-            {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject._updateReceived.Wait(timeout))
-                    .ForCondition(isSet => !isSet)
-                    .FailWith("Expected {context:Subscription} to not receive a new payload{reason}, but did receive an update: {0}", Subject.LastPayload);
-
-                Subject._updateReceived.Reset();
-                return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
-            }
-            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(string because = "", params object[] becauseArgs)
-                => NotHaveReceivedPayload(TimeSpan.FromMilliseconds(100), because, becauseArgs);
-
-            public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(TimeSpan timeout,
-                string because = "", params object[] becauseArgs)
-            {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject._error.Wait(timeout))
-                    .ForCondition(isSet => isSet)
-                    .FailWith("Expected {context:Subscription} to fail{reason}, but did not receive an error within {0}", timeout);
-
-                return new AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception>(this, Subject.Error);
-            }
-            public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(string because = "", params object[] becauseArgs)
-                => HaveReceivedError(Subject.Timeout, because, becauseArgs);
-
-
-            public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(TimeSpan timeout,
-                string because = "", params object[] becauseArgs)
-            {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject._completed.Wait(timeout))
-                    .ForCondition(isSet => isSet)
-                    .FailWith("Expected {context:Subscription} to complete{reason}, but did not complete within {0}", timeout);
-
-                return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
-            }
-            public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(string because = "", params object[] becauseArgs)
-                => HaveCompleted(Subject.Timeout, because, becauseArgs);
-
-            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(TimeSpan timeout,
-                string because = "", params object[] becauseArgs)
-            {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject._completed.Wait(timeout))
-                    .ForCondition(isSet => !isSet)
-                    .FailWith("Expected {context:Subscription} not to complete within {0}{reason}, but it did!", timeout);
-
-                return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
-            }
-            public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveCompleted(string because = "", params object[] becauseArgs)
-                => NotHaveCompleted(Subject.Timeout, because, becauseArgs);
-        }
-    }
-
-    public static class ObservableExtensions
-    {
-        public static ObservableTester<T> Monitor<T>(this IObservable<T> observable) => new ObservableTester<T>(observable);
-    }
-
-}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 1a0a273e..3feee68c 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -5,12 +5,14 @@
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
+using FluentAssertions.Execution;
 using FluentAssertions.Extensions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Client.Tests.Common.Chat.Schema;
+using GraphQL.Client.Tests.Common.FluentAssertions.Reactive;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
 using Microsoft.Extensions.DependencyInjection;
@@ -134,22 +136,22 @@ public async void CanCreateObservableSubscription()
             var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
 
             Debug.WriteLine("subscribing...");
-            using var tester = observable.Monitor();
-            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+            using var observer = observable.Observe();
+            observer.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             var response = await ChatClient.AddMessageAsync(message1);
             response.Data.AddMessage.Content.Should().Be(message1);
-            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
+            observer.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
 
             const string message2 = "lorem ipsum dolor si amet";
             response = await ChatClient.AddMessageAsync(message2);
             response.Data.AddMessage.Content.Should().Be(message2);
-            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
+            observer.Should().Push(3).GetLastMessage().Data.MessageAdded.Content.Should().Be(message2);
 
             // disposing the client should throw a TaskCanceledException on the subscription
             ChatClient.Dispose();
-            tester.Should().HaveCompleted();
+            observer.Should().Complete();
         }
 
         public class MessageAddedSubscriptionResult
@@ -172,40 +174,40 @@ public async void CanReconnectWithSameObservable()
             var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
 
             Debug.WriteLine("subscribing...");
-            var tester = observable.Monitor();
+            var observer = observable.Observe();
             callbackMonitor.Should().HaveBeenInvokedWithPayload();
             await ChatClient.InitializeWebsocketConnection();
             Debug.WriteLine("websocket connection initialized");
-            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+            observer.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             Debug.WriteLine($"adding message {message1}");
             var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(true);
             response.Data.AddMessage.Content.Should().Be(message1);
-            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
+            observer.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
 
             const string message2 = "How are you?";
             response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(true);
             response.Data.AddMessage.Content.Should().Be(message2);
-            tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
+            observer.Should().Push(3).GetLastMessage().Data.MessageAdded.Content.Should().Be(message2);
 
             Debug.WriteLine("disposing subscription...");
-            tester.Dispose(); // does not close the websocket connection
+            observer.Dispose(); // does not close the websocket connection
 
             Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
-            var tester2 = observable.Monitor();
+            var observer2 = observable.Observe();
             Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
-            tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message2);
+            observer2.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(message2);
 
             const string message3 = "lorem ipsum dolor si amet";
             response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(true);
             response.Data.AddMessage.Content.Should().Be(message3);
-            tester2.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message3);
+            observer2.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message3);
 
             // disposing the client should complete the subscription
             ChatClient.Dispose();
-            tester2.Should().HaveCompleted();
-            tester2.Dispose();
+            observer2.Should().Complete();
+            observer2.Dispose();
         }
 
         private const string SUBSCRIPTION_QUERY2 = @"
@@ -247,25 +249,31 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(_subscriptionRequest2, callbackTester2.Invoke);
 
             Debug.WriteLine("subscribing...");
-            var messagesMonitor = observable1.Monitor();
-            var joinedMonitor = observable2.Monitor();
+            var messagesMonitor = observable1.Observe();
+            var joinedMonitor = observable2.Observe();
 
-            messagesMonitor.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+            messagesMonitor.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             var response = await ChatClient.AddMessageAsync(message1);
             response.Data.AddMessage.Content.Should().Be(message1);
-            messagesMonitor.Should().HaveReceivedPayload()
-                .Which.Data.MessageAdded.Content.Should().Be(message1);
-            joinedMonitor.Should().NotHaveReceivedPayload();
+            messagesMonitor.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
+            joinedMonitor.Should().NotPush();
+            messagesMonitor.Clear();
+            joinedMonitor.Clear();
 
             var joinResponse = await ChatClient.JoinDeveloperUser();
             joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
-            var payload = joinedMonitor.Should().HaveReceivedPayload().Subject;
-            payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
-            payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
-            messagesMonitor.Should().NotHaveReceivedPayload();
+            var payload = joinedMonitor.Should().Push().GetLastMessage();
+            using (new AssertionScope())
+            {
+                payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
+                payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+            }
+            messagesMonitor.Should().NotPush();
+            messagesMonitor.Clear();
+            joinedMonitor.Clear();
 
             Debug.WriteLine("disposing subscription...");
             joinedMonitor.Dispose();
@@ -273,12 +281,12 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             const string message3 = "lorem ipsum dolor si amet";
             response = await ChatClient.AddMessageAsync(message3);
             response.Data.AddMessage.Content.Should().Be(message3);
-            messagesMonitor.Should().HaveReceivedPayload()
-                .Which.Data.MessageAdded.Content.Should().Be(message3);
+            messagesMonitor.Should().Push()
+                .GetLastMessage().Data.MessageAdded.Content.Should().Be(message3);
 
             // disposing the client should complete the subscription
             ChatClient.Dispose();
-            messagesMonitor.Should().HaveCompleted();
+            messagesMonitor.Should().Complete();
         }
 
 
@@ -309,7 +317,7 @@ public async void CanHandleConnectionTimeout()
                 var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, errorMonitor.Invoke);
 
                 Debug.WriteLine("subscribing...");
-                var tester = observable.Monitor();
+                var observer = observable.Observe();
                 callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
                 websocketStates.Should().ContainInOrder(
@@ -319,12 +327,12 @@ public async void CanHandleConnectionTimeout()
                 // clear the collection so the next tests on the collection work as expected
                 websocketStates.Clear();
 
-                tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+                observer.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
                 const string message1 = "Hello World";
                 var response = await ChatClient.AddMessageAsync(message1);
                 response.Data.AddMessage.Content.Should().Be(message1);
-                tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(message1);
+                observer.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
 
                 Debug.WriteLine("stopping web host...");
                 await Fixture.ShutdownServer();
@@ -339,7 +347,7 @@ public async void CanHandleConnectionTimeout()
                 Debug.WriteLine("web host started");
                 reconnectBlocker.Set();
                 callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
-                tester.Should().HaveReceivedPayload().Which.Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+                observer.Should().Push(3).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
                 websocketStates.Should().ContainInOrder(
                     GraphQLWebsocketConnectionState.Disconnected,
@@ -348,7 +356,7 @@ public async void CanHandleConnectionTimeout()
 
                 // disposing the client should complete the subscription
                 ChatClient.Dispose();
-                tester.Should().HaveCompleted(5.Seconds());
+                observer.Should().Complete(5.Seconds());
             }
         }
 
@@ -360,7 +368,7 @@ public async void CanHandleSubscriptionError()
             await ChatClient.InitializeWebsocketConnection();
             callbackMonitor.Should().HaveBeenInvokedWithPayload();
             Debug.WriteLine("creating subscription stream");
-            IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
+            var observable = ChatClient.CreateSubscriptionStream<object>(
                 new GraphQLRequest(@"
 					subscription {
 					  failImmediately {
@@ -370,14 +378,13 @@ public async void CanHandleSubscriptionError()
                 );
 
             Debug.WriteLine("subscribing...");
-            using (var tester = observable.Monitor())
-            {
-                tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(3))
-                    .Which.Errors.Should().ContainSingle();
-                tester.Should().HaveCompleted();
-                ChatClient.Dispose();
-            }
 
+            using var observer = observable.Observe();
+            observer.Should().Push(1, 3.Seconds())
+                .GetLastMessage()
+                .Errors.Should().ContainSingle();
+            observer.Should().Complete();
+            ChatClient.Dispose();
         }
 
 
@@ -390,7 +397,7 @@ public async void CanHandleQueryErrorInSubscription()
             await ChatClient.InitializeWebsocketConnection();
             callbackMonitor.Should().HaveBeenInvokedWithPayload();
             Debug.WriteLine("creating subscription stream");
-            IObservable<GraphQLResponse<object>> observable = ChatClient.CreateSubscriptionStream<object>(
+            var observable = ChatClient.CreateSubscriptionStream<object>(
                 new GraphQLRequest(@"
 					subscription {
 					  fieldDoesNotExist {
@@ -400,11 +407,11 @@ public async void CanHandleQueryErrorInSubscription()
             );
 
             Debug.WriteLine("subscribing...");
-            using (var tester = observable.Monitor())
+            using (var tester = observable.Observe())
             {
-                tester.Should().HaveReceivedPayload()
-                    .Which.Errors.Should().ContainSingle();
-                tester.Should().HaveCompleted();
+                tester.Should().Push()
+                    .GetLastMessage().Errors.Should().ContainSingle();
+                tester.Should().Complete();
                 ChatClient.Dispose();
             }
         }

From 31f6988359ed85c999183e11bdcbf16b71409431 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 2 Apr 2020 14:41:35 +0200
Subject: [PATCH 232/455] fix assertion fail messages

---
 .../FluentAssertions.Reactive/ObservableAssertions.cs  | 10 +++++-----
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index 697145f8..9af03426 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -45,7 +45,7 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
             Execute.Assertion
                 .ForCondition(notifications.Any())
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {0} to push at least one notification within {1}{reason}, but it did not.", Observer.Subject, timeout);
+                .FailWith("Expected {context} to push at least one notification within {0}{reason}, but it did not.", timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>(this, notifications);
         }
@@ -82,7 +82,7 @@ public AndConstraint<ObservableAssertions<TPayload>> NotPush(TimeSpan timeout,
             Execute.Assertion
                 .ForCondition(!anyNotifications)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {0} to not push any notifications{reason}, but it did.", Observer.Subject);
+                .FailWith("Expected {context} to not push any notifications{reason}, but it did.");
             
             return new AndConstraint<ObservableAssertions<TPayload>>(this);
         }
@@ -112,7 +112,7 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(TimeSp
             Execute.Assertion
                 .ForCondition(exception != null)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {0} to fail within {1}{reason}, but it did not.", Observer.Subject, timeout);
+                .FailWith("Expected {context} to fail within {0}{reason}, but it did not.", timeout);
             
             return new AndWhichConstraint<ObservableAssertions<TPayload>, Exception>(this, exception);
         }
@@ -141,7 +141,7 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
             Execute.Assertion
                 .ForCondition(completed)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {0} to complete within {1}{reason}, but it did not.", Observer.Subject, timeout);
+                .FailWith("Expected {context} to complete within {0}{reason}, but it did not.", timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>(this, Observer.RecordedNotifications);
         }
@@ -169,7 +169,7 @@ public AndConstraint<ObservableAssertions<TPayload>> NotComplete(TimeSpan timeou
             Execute.Assertion
                 .ForCondition(!completed)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {0} to not complete{reason}, but it did.", Observer.Subject);
+                .FailWith("Expected {context} to not complete{reason}, but it did.");
             
             return new AndConstraint<ObservableAssertions<TPayload>>(this);
         }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 3feee68c..12c2eea4 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -407,11 +407,11 @@ public async void CanHandleQueryErrorInSubscription()
             );
 
             Debug.WriteLine("subscribing...");
-            using (var tester = observable.Observe())
+            using (var observer = observable.Observe())
             {
-                tester.Should().Push()
+                observer.Should().Push()
                     .GetLastMessage().Errors.Should().ContainSingle();
-                tester.Should().Complete();
+                observer.Should().Complete();
                 ChatClient.Dispose();
             }
         }

From 650352ac4ea21db4287c51f54895c09da25fd6a0 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 2 Apr 2020 14:56:09 +0200
Subject: [PATCH 233/455] consolidate dependencies

---
 .github/workflows/branches-ubuntu.yml            |  3 ++-
 .github/workflows/main-ubuntu.yml                |  2 ++
 dotnet-tools.json                                |  2 +-
 .../GraphQL.Client.Abstractions.Websocket.csproj |  7 +++++++
 .../GraphQL.Client.Abstractions.csproj           |  7 +++++++
 .../GraphQL.Client.LocalExecution.csproj         |  7 +++++++
 .../GraphQL.Client.Serializer.Newtonsoft.csproj  |  7 +++++++
 ...aphQL.Client.Serializer.SystemTextJson.csproj |  7 +++++++
 src/GraphQL.Client/GraphQL.Client.csproj         |  7 +++++++
 src/GraphQL.Primitives/GraphQL.Primitives.csproj |  7 +++++++
 .../GraphQL.Client.Serializer.Tests.csproj       | 16 +++++++++++-----
 .../GraphQL.Client.Tests.Common.csproj           |  4 ++--
 .../GraphQL.Integration.Tests.csproj             |  6 +++---
 .../GraphQL.Primitives.Tests.csproj              |  7 ++++++-
 14 files changed, 76 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 488f6596..1743235f 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -6,7 +6,8 @@ on:
       - 'release/**'
       - 'releases/**'
 env:
-  DOTNET_CLI_TELEMETRY_OPTOUT: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true  
+  MSBUILDSINGLELOADCONTEXT: 1
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo
diff --git a/.github/workflows/main-ubuntu.yml b/.github/workflows/main-ubuntu.yml
index bb58dcff..a0d006b7 100644
--- a/.github/workflows/main-ubuntu.yml
+++ b/.github/workflows/main-ubuntu.yml
@@ -10,6 +10,8 @@ on:
       - V*
 env:
   DOTNET_CLI_TELEMETRY_OPTOUT: true
+  MSBUILDSINGLELOADCONTEXT: 1
+
 jobs:
   generateVersionInfo:  
     name: GenerateVersionInfo
diff --git a/dotnet-tools.json b/dotnet-tools.json
index 6d123e6b..133edefa 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -8,7 +8,7 @@
       ]
     },
     "gitversion.tool": {
-      "version": "5.1.3",
+      "version": "5.2.4",
       "commands": [
         "dotnet-gitversion"
       ]
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index c191671f..f070a6b5 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -11,4 +11,11 @@
 	<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="GitVersionTask" Version="5.2.4">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	</ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 63e9aa89..4e5413ab 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -16,4 +16,11 @@
 		<PackageReference Include="System.Reactive" Version="4.3.2" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="GitVersionTask" Version="5.2.4">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	</ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 927c3470..1b65a0d9 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -17,4 +17,11 @@
 		<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="GitVersionTask" Version="5.2.4">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	</ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index c492b1ed..fa040d95 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -15,4 +15,11 @@
     <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Update="GitVersionTask" Version="5.2.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index e8be48d7..52d3b180 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -15,4 +15,11 @@
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="GitVersionTask" Version="5.2.4">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	</ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 0e0119ba..43e4271a 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -37,6 +37,13 @@
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="GitVersionTask" Version="5.2.4">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	</ItemGroup>
+
 	
 
 
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index 53f58f4b..51034540 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -7,4 +7,11 @@
 		<RootNamespace>GraphQL</RootNamespace>
 		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
+
+	<ItemGroup>
+	  <PackageReference Update="GitVersionTask" Version="5.2.4">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
+	</ItemGroup>
 </Project>
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index b61c1466..87c5b880 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -6,11 +6,17 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.10.2" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
-    <PackageReference Include="coverlet.collector" Version="1.0.1" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="1.2.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 4fd09bf5..f37d033b 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -6,11 +6,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.10.0" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
     <PackageReference Include="GraphQL" Version="2.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.3" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="4.3.2" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 777bd6ed..b09be5dd 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,9 +7,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.10.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="4.3.2" />
     <PackageReference Include="NETStandard.Library" Version="2.0.3" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index c7be7594..e2f04365 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -7,7 +7,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <PackageReference Include="FluentAssertions" Version="5.10.0" />
+	  <PackageReference Include="FluentAssertions" Version="5.10.3" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -16,6 +16,11 @@
 
 	<ItemGroup>
 	  <PackageReference Update="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+	  <PackageReference Update="xunit" Version="2.4.1" />
+	  <PackageReference Update="xunit.runner.visualstudio" Version="2.4.1">
+	    <PrivateAssets>all</PrivateAssets>
+	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  </PackageReference>
 	</ItemGroup>
 
 </Project>

From 02625d58943d999f603032cb5c18d2b4214cb1ae Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Fri, 3 Apr 2020 20:48:10 +0300
Subject: [PATCH 234/455] spell check, formatting, code cleanup

---
 GraphQL.Client.sln                            |  7 +++--
 .../GraphQL.Client.Example.csproj             |  1 -
 .../PersonAndFilmsResponse.cs                 |  1 +
 examples/GraphQL.Client.Example/Program.cs    |  6 +---
 root.props                                    |  1 -
 ...aphQL.Client.Abstractions.Websocket.csproj |  4 +--
 .../GraphQLWebSocketMessageType.cs            |  1 -
 .../GraphQLWebSocketRequest.cs                |  5 +---
 .../GraphQLWebSocketResponse.cs               |  3 --
 .../GraphQLWebsocketConnectionState.cs        |  2 ++
 .../IGraphQLWebsocketJsonSerializer.cs        |  2 +-
 .../GraphQL.Client.Abstractions.csproj        |  1 -
 .../IGraphQLClient.cs                         |  5 +---
 .../IGraphQLJsonSerializer.cs                 |  5 +---
 .../ExecutionResultExtensions.cs              |  7 -----
 .../GraphQLEnumConverter.cs                   |  1 -
 .../GraphQLLocalExecutionClient.cs            |  4 +--
 ...raphQL.Client.Serializer.Newtonsoft.csproj |  2 +-
 .../MapConverter.cs                           | 15 ++++------
 .../NewtonsoftJsonSerializer.cs               |  2 --
 ...QL.Client.Serializer.SystemTextJson.csproj |  2 +-
 .../ImmutableConverter.cs                     |  1 -
 .../JsonSerializerOptionsExtensions.cs        |  3 +-
 src/GraphQL.Client/GraphQL.Client.csproj      | 10 ++-----
 src/GraphQL.Client/GraphQLHttpClient.cs       | 29 +++++++++----------
 .../GraphQLHttpClientExtensions.cs            |  2 +-
 .../GraphQLHttpClientOptions.cs               |  2 --
 src/GraphQL.Client/GraphQLHttpException.cs    |  4 ---
 src/GraphQL.Client/GraphQLHttpRequest.cs      |  1 -
 src/GraphQL.Client/GraphQLHttpResponse.cs     |  4 +--
 .../Websocket/GraphQLHttpWebSocket.cs         |  7 ++---
 .../GraphQL.Primitives.csproj                 |  1 +
 src/GraphQL.Primitives/GraphQLError.cs        |  7 +----
 src/GraphQL.Primitives/GraphQLLocation.cs     |  4 ---
 src/GraphQL.Primitives/GraphQLRequest.cs      |  3 --
 src/GraphQL.Primitives/GraphQLResponse.cs     |  7 -----
 src/GraphQL.Primitives/Map.cs                 |  1 -
 src/src.props                                 |  1 -
 .../BaseSerializeNoCamelCaseTest.cs           |  4 +--
 .../BaseSerializerTest.cs                     |  3 +-
 .../Chat/AddMessageMutationResult.cs          |  1 +
 .../Chat/AddMessageVariables.cs               |  4 ++-
 .../Chat/GraphQLClientChatExtensions.cs       |  1 -
 .../Chat/JoinDeveloperMutationResult.cs       |  2 ++
 .../Chat/Schema/ChatQuery.cs                  |  2 --
 tests/GraphQL.Client.Tests.Common/Common.cs   |  1 +
 .../Helpers/CallbackMonitor.cs                |  1 +
 .../Helpers/ConcurrentTaskWrapper.cs          |  1 -
 .../Helpers/MiscellaneousExtensions.cs        |  2 --
 .../Helpers/ObservableTester.cs               |  2 +-
 .../GraphQL.Integration.Tests.csproj          |  4 +--
 .../Helpers/IntegrationServerTestFixture.cs   |  2 ++
 .../Helpers/WebHostHelpers.cs                 |  2 ++
 .../QueryAndMutationTests/Base.cs             |  3 --
 .../WebsocketTests/Base.cs                    |  7 +----
 .../WebsocketTests/Newtonsoft.cs              |  3 +-
 .../GraphQLLocationTest.cs                    |  4 ---
 .../GraphQLRequestTest.cs                     | 29 ++++++++++---------
 .../GraphQLResponseTest.cs                    |  4 ---
 .../JsonSerializationTests.cs                 |  2 --
 .../GraphQL/Models/Repository.cs              |  8 ++---
 tests/GraphQL.Server.Test/GraphQL/Storage.cs  |  4 ---
 .../GraphQL/TestMutation.cs                   |  4 ---
 .../GraphQL.Server.Test/GraphQL/TestQuery.cs  |  4 ---
 .../GraphQL.Server.Test/GraphQL/TestSchema.cs |  4 ---
 .../GraphQL/TestSubscription.cs               |  4 ---
 tests/GraphQL.Server.Test/Program.cs          |  6 +---
 tests/GraphQL.Server.Test/Startup.cs          | 12 --------
 tests/IntegrationTestServer/Startup.cs        |  6 ++--
 tests/tests.props                             |  1 -
 70 files changed, 91 insertions(+), 210 deletions(-)
 delete mode 100644 src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 24ea23a4..3d966cd9 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -34,8 +34,9 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{05CAF9B2-981E-40C0-AE31-5FA56E351F12}"
 	ProjectSection(SolutionItems) = preProject
 		.github\workflows\branches-ubuntu.yml = .github\workflows\branches-ubuntu.yml
-		.github\workflows\branches.yml = .github\workflows\branches.yml
-		.github\workflows\main.yml = .github\workflows\main.yml
+		.github\workflows\branches-windows.yml = .github\workflows\branches-windows.yml
+		.github\workflows\main-ubuntu.yml = .github\workflows\main-ubuntu.yml
+		.github\workflows\main-windows.yml = .github\workflows\main-windows.yml
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Primitives", "src\GraphQL.Primitives\GraphQL.Primitives.csproj", "{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6}"
@@ -64,7 +65,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.S
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{89AD33AB-64F6-4F82-822F-21DF7A10CEC0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Example", "examples\GraphQL.Client.Example\GraphQL.Client.Example.csproj", "{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Example", "examples\GraphQL.Client.Example\GraphQL.Client.Example.csproj", "{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index 54506df0..d6a75865 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -3,7 +3,6 @@
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
 		<TargetFramework>netcoreapp3.1</TargetFramework>
-		<IsPackable>false</IsPackable>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
index ea3d7de5..eafba6d1 100644
--- a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
+++ b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
@@ -9,6 +9,7 @@ public class PersonAndFilmsResponse
         public class PersonContent
         {
             public string Name { get; set; }
+
             public FilmConnectionContent FilmConnection { get; set; }
 
             public class FilmConnectionContent
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index 2ef597ec..0bfd14b1 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -7,13 +7,10 @@
 
 namespace GraphQL.Client.Example
 {
-
     public class Program
     {
-
-        public static async Task Main(string[] args)
+        public static async Task Main()
         {
-            _ = args;
             using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
 
             var personAndFilmsRequest = new GraphQLRequest
@@ -49,6 +46,5 @@ query PersonAndFilms($id: ID) {
             Console.WriteLine("Press any key to quit...");
             Console.ReadKey();
         }
-
     }
 }
diff --git a/root.props b/root.props
index 2c0a5b7d..b076b4d3 100644
--- a/root.props
+++ b/root.props
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="utf-8"?>
 <Project>
 
 	<PropertyGroup>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index c191671f..9abfd542 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
     <Description>Abstractions for the Websocket transport used in GraphQL.Client</Description>
 	  <TargetFramework>netstandard2.0</TargetFramework>
-	  <LangVersion>8.0</LangVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
-	<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
index 6dd7f019..daa83114 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
@@ -84,6 +84,5 @@ public static class GraphQLWebSocketMessageType
         ///     id: string : operation id
         /// </summary>
         public const string GQL_STOP = "stop"; // Client -> Server
-
     }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index 7c986acc..623e4271 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -4,7 +4,6 @@
 
 namespace GraphQL.Client.Abstractions.Websocket
 {
-
     /// <summary>
     /// A Subscription Request
     /// </summary>
@@ -50,7 +49,7 @@ public GraphQLRequest Payload
         public Task SendTask() => _tcs.Task;
 
         /// <summary>
-        /// gets called when the send operation for this request has completed sucessfully
+        /// gets called when the send operation for this request has completed successfully
         /// </summary>
         public void SendCompleted() => _tcs.SetResult(true);
 
@@ -109,7 +108,5 @@ public override int GetHashCode()
 
         /// <inheritdoc />
         public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
-
     }
-
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
index d6c69a70..390834da 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
@@ -3,13 +3,11 @@
 
 namespace GraphQL.Client.Abstractions.Websocket
 {
-
     /// <summary>
     /// A Subscription Response
     /// </summary>
     public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse>
     {
-
         /// <summary>
         /// The Identifier of the Response
         /// </summary>
@@ -65,7 +63,6 @@ public override int GetHashCode()
         /// <inheritdoc />
         public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
             !(response1 == response2);
-
     }
 
     public class GraphQLWebSocketResponse<TPayload> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TPayload>>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
index 148436cd..c5fd3107 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
@@ -3,7 +3,9 @@ namespace GraphQL.Client.Abstractions.Websocket
     public enum GraphQLWebsocketConnectionState
     {
         Disconnected,
+
         Connecting,
+
         Connected
     }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index 23536db5..5e3d58ec 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -12,7 +12,7 @@ public interface IGraphQLWebsocketJsonSerializer : IGraphQLJsonSerializer
         byte[] SerializeToBytes(GraphQLWebSocketRequest request);
 
         Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
-        GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
 
+        GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
     }
 }
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 63e9aa89..666c63c0 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -4,7 +4,6 @@
 
 	<PropertyGroup>
 		<Description>Abstractions for GraphQL.Client</Description>
-		<RootNamespace>GraphQL.Client.Abstractions</RootNamespace>
 		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
 
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
index df0557af..0508f8b5 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
@@ -5,10 +5,8 @@
 
 namespace GraphQL.Client.Abstractions
 {
-
     public interface IGraphQLClient : IDisposable
     {
-
         Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
         Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
@@ -30,9 +28,8 @@ public interface IGraphQLClient : IDisposable
         /// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
         /// </summary>
         /// <param name="request">the GraphQL request for this subscription</param>
-        /// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occuring within the sequence</param>
+        /// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occurring within the sequence</param>
         /// <returns>an observable stream for the specified subscription</returns>
         IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler);
     }
-
 }
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
index 5c119e4a..fa21dbac 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
@@ -8,9 +8,6 @@ public interface IGraphQLJsonSerializer
     {
         string SerializeToString(GraphQLRequest request);
 
-        Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream,
-            CancellationToken cancellationToken);
+        Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken);
     }
-
-
 }
diff --git a/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs b/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
deleted file mode 100644
index 32133976..00000000
--- a/src/GraphQL.Client.LocalExecution/ExecutionResultExtensions.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace GraphQL.Client.LocalExecution
-{
-    public class ExecutionResultExtensions
-    {
-
-    }
-}
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs b/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
index 89bbcfc0..a02cf935 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
@@ -34,5 +34,4 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
             }
         }
     }
-
 }
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index c055cecb..d458d20e 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -22,10 +22,8 @@ public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema,
             => new GraphQLLocalExecutionClient<TSchema>(schema, serializer);
     }
 
-
     public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
     {
-
         private static readonly JsonSerializerSettings _variablesSerializerSettings = new JsonSerializerSettings
         {
             Formatting = Formatting.Indented,
@@ -38,8 +36,8 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
         };
 
         public TSchema Schema { get; }
-        public IGraphQLJsonSerializer Serializer { get; }
 
+        public IGraphQLJsonSerializer Serializer { get; }
 
         private readonly DocumentExecuter _documentExecuter;
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index c492b1ed..a298a460 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  
 	<Import Project="../src.props" />
 
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using Newtonsoft.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
-	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index f15787e8..64bc8671 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Runtime.InteropServices;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
@@ -12,13 +11,12 @@ public override void WriteJson(JsonWriter writer, Map value, JsonSerializer seri
             throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-        public override Map ReadJson(JsonReader reader, Type objectType, Map existingValue,
-            bool hasExistingValue, JsonSerializer serializer)
+        public override Map ReadJson(JsonReader reader, Type objectType, Map existingValue, bool hasExistingValue, JsonSerializer serializer)
         {
             var rootToken = JToken.ReadFrom(reader);
             if (rootToken is JObject)
             {
-                return ReadDictionary<Map>(rootToken);
+                return (Map)ReadDictionary(rootToken, new Map());
             }
             else
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
@@ -27,7 +25,7 @@ public override Map ReadJson(JsonReader reader, Type objectType, Map existingVal
         private object ReadToken(JToken? token) =>
             token switch
             {
-                JObject jObject => ReadDictionary<Dictionary<string, object>>(jObject),
+                JObject jObject => ReadDictionary(jObject, new Dictionary<string, object>()),
                 JArray jArray => ReadArray(jArray),
                 JValue jValue => jValue.Value,
                 JConstructor _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
@@ -39,16 +37,15 @@ private object ReadToken(JToken? token) =>
                 _ => throw new ArgumentOutOfRangeException(nameof(token.Type))
             };
 
-        private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionary : Dictionary<string, object>
+        private Dictionary<string, object> ReadDictionary(JToken element, Dictionary<string, object> to)
         {
-            var result = Activator.CreateInstance<TDictionary>();
             foreach (var property in ((JObject)element).Properties())
             {
                 if (IsUnsupportedJTokenType(property.Value.Type))
                     continue;
-                result[property.Name] = ReadToken(property.Value);
+                to[property.Name] = ReadToken(property.Value);
             }
-            return result;
+            return to;
         }
 
         private IEnumerable<object> ReadArray(JToken element)
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 99936421..5ec06c1a 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -49,7 +49,6 @@ public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsock
 
         public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
 
-
         private Task<T> DeserializeFromUtf8Stream<T>(Stream stream)
         {
             using var sr = new StreamReader(stream);
@@ -57,6 +56,5 @@ private Task<T> DeserializeFromUtf8Stream<T>(Stream stream)
             var serializer = JsonSerializer.Create(JsonSerializerSettings);
             return Task.FromResult(serializer.Deserialize<T>(reader));
         }
-
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index e8be48d7..009daeea 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  
 	<Import Project="../src.props" />
 
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using System.Text.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
-	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index 78b5811b..4a26f6f2 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -8,7 +8,6 @@
 
 namespace GraphQL.Client.Serializer.SystemTextJson
 {
-
     /// <summary>
     /// class for converting immutable objects, derived from https://github.com/manne/obviously/blob/master/src/system.text.json/Core/ImmutableConverter.cs
     /// </summary>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
index e2d914c0..bc2ddc14 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
@@ -4,8 +4,7 @@ namespace GraphQL.Client.Serializer.SystemTextJson
 {
     public static class JsonSerializerOptionsExtensions
     {
-        public static JsonSerializerOptions SetupImmutableConverter(
-            this JsonSerializerOptions options)
+        public static JsonSerializerOptions SetupImmutableConverter(this JsonSerializerOptions options)
         {
             options.Converters.Add(new ImmutableConverter());
             return options;
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 0e0119ba..5946a683 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -2,10 +2,10 @@
 
 	<Import Project="../src.props" />
 
-    <PropertyGroup>
+  <PropertyGroup>
 		<TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
-	    <RootNamespace>GraphQL.Client.Http</RootNamespace>
-    </PropertyGroup>
+	  <RootNamespace>GraphQL.Client.Http</RootNamespace>
+  </PropertyGroup>
 
 	<PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
 		<DefineConstants>NETSTANDARD</DefineConstants>
@@ -23,7 +23,6 @@
 	  <None Include="GraphQLSerializationExtensions.cs" />
 	</ItemGroup>
 
-
 	<ItemGroup>
 		<PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
 	</ItemGroup>
@@ -37,7 +36,4 @@
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
-	
-
-
 </Project>
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 72b4b907..4388e8e1 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -11,10 +11,8 @@
 
 namespace GraphQL.Client.Http
 {
-
     public class GraphQLHttpClient : IGraphQLClient
     {
-
         private readonly GraphQLHttpWebSocket _graphQlHttpWebSocket;
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
@@ -42,8 +40,7 @@ public class GraphQLHttpClient : IGraphQLClient
         /// <summary>
         /// the websocket connection state
         /// </summary>
-        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState =>
-            _graphQlHttpWebSocket.ConnectionState;
+        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => _graphQlHttpWebSocket.ConnectionState;
 
         #region Constructors
 
@@ -160,7 +157,6 @@ private Uri GetWebSocketUri()
 
         #endregion
 
-
         #region IDisposable
 
         /// <summary>
@@ -172,26 +168,27 @@ public void Dispose()
             {
                 if (!_disposed)
                 {
-                    _dispose();
+                    _disposed = true;
+                    Dispose(true);
                 }
             }
         }
 
-        private bool _disposed = false;
+        private volatile bool _disposed;
         private readonly object _disposeLocker = new object();
 
-        private void _dispose()
+        protected virtual void Dispose(bool disposing)
         {
-            _disposed = true;
-            Debug.WriteLine($"disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
-            _cancellationTokenSource.Cancel();
-            HttpClient.Dispose();
-            _graphQlHttpWebSocket.Dispose();
-            _cancellationTokenSource.Dispose();
+            if (disposing)
+            {
+                Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
+                _cancellationTokenSource.Cancel();
+                HttpClient.Dispose();
+                _graphQlHttpWebSocket.Dispose();
+                _cancellationTokenSource.Dispose();
+            }
         }
 
         #endregion
-
     }
-
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index 99886c0c..31f29785 100644
--- a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -15,7 +15,7 @@ public static class GraphQLHttpClientExtensions
         /// </summary>
         /// <param name="client">the GraphQL client</param>
         /// <param name="request">the GraphQL request for this subscription</param>
-        /// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occuring within the sequence</param>
+        /// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occurring within the sequence</param>
         /// <returns>an observable stream for the specified subscription</returns>
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(this IGraphQLClient client,
             GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) =>
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 6b93cb7b..aeb99db6 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -5,13 +5,11 @@
 
 namespace GraphQL.Client.Http
 {
-
     /// <summary>
     /// The Options that the <see cref="GraphQLHttpClient"/> will use
     /// </summary>
     public class GraphQLHttpClientOptions
     {
-
         /// <summary>
         /// The GraphQL EndPoint to be used
         /// </summary>
diff --git a/src/GraphQL.Client/GraphQLHttpException.cs b/src/GraphQL.Client/GraphQLHttpException.cs
index d30bd759..3b256bf3 100644
--- a/src/GraphQL.Client/GraphQLHttpException.cs
+++ b/src/GraphQL.Client/GraphQLHttpException.cs
@@ -3,13 +3,11 @@
 
 namespace GraphQL.Client.Http
 {
-
     /// <summary>
     /// An exception thrown on unexpected <see cref="System.Net.Http.HttpResponseMessage"/>
     /// </summary>
     public class GraphQLHttpException : Exception
     {
-
         /// <summary>
         /// The <see cref="System.Net.Http.HttpResponseMessage"/>
         /// </summary>
@@ -23,7 +21,5 @@ public GraphQLHttpException(HttpResponseMessage httpResponseMessage) : base($"Un
         {
             HttpResponseMessage = httpResponseMessage ?? throw new ArgumentNullException(nameof(httpResponseMessage));
         }
-
     }
-
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index f801f9c7..1069ac4c 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -4,7 +4,6 @@
 
 namespace GraphQL.Client.Http
 {
-
     public class GraphQLHttpRequest : GraphQLRequest
     {
         public GraphQLHttpRequest()
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index 73a4cea8..b4b09784 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -4,7 +4,6 @@
 
 namespace GraphQL.Client.Http
 {
-
     public class GraphQLHttpResponse<T> : GraphQLResponse<T>
     {
         public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode)
@@ -17,6 +16,7 @@ public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders resp
         }
 
         public HttpResponseHeaders ResponseHeaders { get; set; }
+
         public HttpStatusCode StatusCode { get; set; }
     }
 
@@ -25,7 +25,7 @@ public static class GraphQLResponseExtensions
         public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) => new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
 
         /// <summary>
-        /// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws ig the cast fails.
+        /// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws if the cast fails.
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="response"></param>
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index f0156030..21222865 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -48,7 +48,6 @@ internal class GraphQLHttpWebSocket : IDisposable
 
         #endregion
 
-
         #region Public properties
 
         /// <summary>
@@ -73,7 +72,6 @@ internal class GraphQLHttpWebSocket : IDisposable
 
         #endregion
 
-
         public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
         {
             _internalCancellationToken = _internalCancellationTokenSource.Token;
@@ -89,7 +87,6 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
                 .Subscribe(async request => await SendWebSocketRequestAsync(request));
         }
 
-
         #region Send requests
 
         /// <summary>
@@ -490,7 +487,7 @@ private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
             Observable.Using(() => new EventLoopScheduler(), scheduler =>
                 Observable.Create<WebsocketMessageWrapper>(async observer =>
                 {
-                    // make sure the websocket ist connected
+                    // make sure the websocket is connected
                     await InitializeWebSocket();
                     // subscribe observer to message stream
                     var subscription = new CompositeDisposable(_incomingMessages.ObserveOn(scheduler).Subscribe(observer))
@@ -591,6 +588,7 @@ private async Task CloseAsync()
         }
 
         #region IDisposable
+
         public void Dispose() => Complete();
 
         /// <summary>
@@ -636,6 +634,7 @@ private async Task CompleteAsync()
 
             Debug.WriteLine($"websocket {_clientWebSocket.GetHashCode()} disposed");
         }
+
         #endregion
     }
 }
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index 53f58f4b..2b97da30 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -7,4 +7,5 @@
 		<RootNamespace>GraphQL</RootNamespace>
 		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
+  
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 0bfe834c..9b7cfc99 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -5,13 +5,11 @@
 
 namespace GraphQL
 {
-
     /// <summary>
     /// Represents a GraphQL Error of a GraphQL Query
     /// </summary>
     public class GraphQLError : IEquatable<GraphQLError?>
     {
-
         /// <summary>
         /// The locations of the error
         /// </summary>
@@ -41,8 +39,7 @@ public class GraphQLError : IEquatable<GraphQLError?>
         /// </summary>
         /// <param name="obj">The object to compare with this instance</param>
         /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
-        public override bool Equals(object? obj) =>
-            Equals(obj as GraphQLError);
+        public override bool Equals(object? obj) => Equals(obj as GraphQLError);
 
         /// <summary>
         /// Returns a value that indicates whether this instance is equal to a specified object
@@ -117,7 +114,5 @@ public override int GetHashCode()
         /// <returns>true if left and right are unequal; otherwise, false</returns>
         public static bool operator !=(GraphQLError? left, GraphQLError? right) =>
             !EqualityComparer<GraphQLError?>.Default.Equals(left, right);
-
     }
-
 }
diff --git a/src/GraphQL.Primitives/GraphQLLocation.cs b/src/GraphQL.Primitives/GraphQLLocation.cs
index c1fe6cee..9464817a 100644
--- a/src/GraphQL.Primitives/GraphQLLocation.cs
+++ b/src/GraphQL.Primitives/GraphQLLocation.cs
@@ -3,13 +3,11 @@
 
 namespace GraphQL
 {
-
     /// <summary>
     /// Represents a GraphQL Location of a GraphQL Query
     /// </summary>
     public sealed class GraphQLLocation : IEquatable<GraphQLLocation?>
     {
-
         /// <summary>
         /// The Column
         /// </summary>
@@ -65,7 +63,5 @@ public override int GetHashCode() =>
         /// <returns>true if left and right are unequal; otherwise, false</returns>
         public static bool operator !=(GraphQLLocation? left, GraphQLLocation? right) =>
             !EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
-
     }
-
 }
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index a36dae38..72033552 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -4,7 +4,6 @@
 
 namespace GraphQL
 {
-
     /// <summary>
     /// A GraphQL request
     /// </summary>
@@ -110,6 +109,4 @@ public override int GetHashCode()
         /// <returns>true if left and right are unequal; otherwise, false</returns>
         public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
     }
-
-
 }
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 0b2781fd..ff8eaac9 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -5,10 +5,8 @@
 
 namespace GraphQL
 {
-
     public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?>
     {
-
         [DataMember(Name = "data")]
         public T Data { get; set; }
 
@@ -86,13 +84,8 @@ public override int GetHashCode()
             }
         }
 
-
         public static bool operator ==(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => EqualityComparer<GraphQLResponse<T>?>.Default.Equals(response1, response2);
 
         public static bool operator !=(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => !(response1 == response2);
-
     }
-
-
-
 }
diff --git a/src/GraphQL.Primitives/Map.cs b/src/GraphQL.Primitives/Map.cs
index cba91bee..9c4f503b 100644
--- a/src/GraphQL.Primitives/Map.cs
+++ b/src/GraphQL.Primitives/Map.cs
@@ -2,7 +2,6 @@
 
 namespace GraphQL
 {
-
     /// <summary>
     /// A type equivalent to a javascript map. Create a custom json converter for this class to customize your serializers behaviour
     /// </summary>
diff --git a/src/src.props b/src/src.props
index e2e2512b..f09d3e47 100644
--- a/src/src.props
+++ b/src/src.props
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="utf-8"?>
 <Project>
 
 	<Import Project="../root.props" />
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index 5547e136..7ef81660 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -13,9 +13,10 @@ namespace GraphQL.Client.Serializer.Tests
 {
     public abstract class BaseSerializeNoCamelCaseTest
     {
-
         public IGraphQLWebsocketJsonSerializer Serializer { get; }
+
         public IGraphQLClient ChatClient { get; }
+
         public IGraphQLClient StarWarsClient { get; }
 
         protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer serializer)
@@ -41,7 +42,6 @@ public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest re
             json.Should().Be(expectedJson.RemoveWhitespace());
         }
 
-
         [Fact]
         public async void WorksWithoutCamelCaseNamingStrategy()
         {
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 940b7392..5811823c 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -18,7 +18,9 @@ namespace GraphQL.Client.Serializer.Tests
     public abstract class BaseSerializerTest
     {
         public IGraphQLWebsocketJsonSerializer Serializer { get; }
+
         public IGraphQLClient ChatClient { get; }
+
         public IGraphQLClient StarWarsClient { get; }
 
         protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer serializer)
@@ -83,7 +85,6 @@ public async void CanDeserializeExtensions()
             response.Errors[0].Extensions["data"].Should().BeEquivalentTo(ChatQuery.TestExtensions);
         }
 
-
         [Theory]
         [ClassData(typeof(StarWarsHumans))]
         public async void CanDoSerializationWithAnonymousTypes(int id, string name)
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
index 385e537b..70a51a72 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
@@ -3,6 +3,7 @@ namespace GraphQL.Client.Tests.Common.Chat
     public class AddMessageMutationResult
     {
         public AddMessageContent AddMessage { get; set; }
+
         public class AddMessageContent
         {
             public string Content { get; set; }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
index 3a6ae10c..0a330007 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
@@ -4,12 +4,14 @@ namespace GraphQL.Client.Tests.Common.Chat
 {
     public class AddMessageVariables
     {
-
         public AddMessageInput Input { get; set; }
+
         public class AddMessageInput
         {
             public string FromId { get; set; }
+
             public string Content { get; set; }
+
             public DateTime SentAt { get; set; }
         }
     }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index 261f5722..f4417860 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -44,6 +44,5 @@ public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUs
                 });
             return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
         }
-
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
index c1b02444..c9910444 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
@@ -3,9 +3,11 @@ namespace GraphQL.Client.Tests.Common.Chat
     public class JoinDeveloperMutationResult
     {
         public JoinContent Join { get; set; }
+
         public class JoinContent
         {
             public string DisplayName { get; set; }
+
             public string Id { get; set; }
         }
     }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 0eb335ef..e60bf97e 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -7,7 +7,6 @@ namespace GraphQL.Client.Tests.Common.Chat.Schema
 {
     public class ChatQuery : ObjectGraphType
     {
-
         public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
             {"extension1", "hello world"},
             {"another extension", 4711},
@@ -19,7 +18,6 @@ public class ChatQuery : ObjectGraphType
         public readonly ManualResetEventSlim LongRunningQueryBlocker = new ManualResetEventSlim();
         public readonly ManualResetEventSlim WaitingOnQueryBlocker = new ManualResetEventSlim();
 
-
         public ChatQuery(IChat chat)
         {
             Name = "ChatQuery";
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
index 3bfd2409..97dd30fe 100644
--- a/tests/GraphQL.Client.Tests.Common/Common.cs
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -17,6 +17,7 @@ public static StarWarsSchema GetStarWarsSchema()
             services.AddStarWarsSchema();
             return services.BuildServiceProvider().GetRequiredService<StarWarsSchema>();
         }
+
         public static ChatSchema GetChatSchema()
         {
             var services = new ServiceCollection();
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index a6a4e50f..df759d07 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -20,6 +20,7 @@ public class CallbackMonitor<T>
         /// Indicates that an update has been received since the last <see cref="Reset"/>
         /// </summary>
         public bool CallbackInvoked => _callbackInvoked.IsSet;
+
         /// <summary>
         /// The last payload which was received.
         /// </summary>
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
index 6af84092..c16e1744 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
@@ -3,7 +3,6 @@
 
 namespace GraphQL.Client.Tests.Common.Helpers
 {
-
     public class ConcurrentTaskWrapper
     {
         public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) => new ConcurrentTaskWrapper<TResult>(createTask);
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
index b769399b..dcbb6db9 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
@@ -22,7 +22,5 @@ public static CallbackMonitor<GraphQLHttpClient> ConfigureMonitorForOnWebsocketC
             };
             return tester;
         }
-
-
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index dad65ff1..82e7eac7 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -26,6 +26,7 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable
         /// Indicates that an update has been received since the last <see cref="_reset"/>
         /// </summary>
         public bool UpdateReceived => _updateReceived.IsSet;
+
         /// <summary>
         /// The last payload which was received.
         /// </summary>
@@ -171,5 +172,4 @@ public static class ObservableExtensions
     {
         public static ObservableTester<T> Monitor<T>(this IObservable<T> observable) => new ObservableTester<T>(observable);
     }
-
 }
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 777bd6ed..5b55b2e2 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -1,8 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
@@ -28,5 +27,4 @@
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
   </ItemGroup>
 
-
 </Project>
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index e70751b7..25773b47 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -13,7 +13,9 @@ namespace GraphQL.Integration.Tests.Helpers
     public abstract class IntegrationServerTestFixture
     {
         public int Port { get; private set; }
+
         public IWebHost Server { get; private set; }
+
         public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
 
         public IntegrationServerTestFixture()
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 81ff2248..0bdb0e8c 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -55,7 +55,9 @@ public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer)
         }
 
         public int Port { get; }
+
         public IWebHost Server { get; set; }
+
         public IGraphQLWebsocketJsonSerializer Serializer { get; set; }
 
         public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 550eb6a0..4e9cd45a 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -15,10 +15,8 @@
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests
 {
-
     public abstract class Base : IAsyncLifetime
     {
-
         protected IntegrationServerTestFixture Fixture;
         protected GraphQLHttpClient StarWarsClient;
         protected GraphQLHttpClient ChatClient;
@@ -222,6 +220,5 @@ query Long {
             // let the server finish its query
             chatQuery.LongRunningQueryBlocker.Set();
         }
-
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 1a0a273e..2bb72794 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -162,7 +162,6 @@ public class MessageAddedContent
             }
         }
 
-
         [Fact]
         public async void CanReconnectWithSameObservable()
         {
@@ -223,6 +222,7 @@ public class UserJoinedSubscriptionResult
             public class UserJoinedContent
             {
                 public string DisplayName { get; set; }
+
                 public string Id { get; set; }
             }
 
@@ -230,7 +230,6 @@ public class UserJoinedContent
 
         private readonly GraphQLRequest _subscriptionRequest2 = new GraphQLRequest(SUBSCRIPTION_QUERY2);
 
-
         [Fact]
         public async void CanConnectTwoSubscriptionsSimultaneously()
         {
@@ -352,7 +351,6 @@ public async void CanHandleConnectionTimeout()
             }
         }
 
-
         [Fact]
         public async void CanHandleSubscriptionError()
         {
@@ -377,10 +375,8 @@ public async void CanHandleSubscriptionError()
                 tester.Should().HaveCompleted();
                 ChatClient.Dispose();
             }
-
         }
 
-
         [Fact]
         public async void CanHandleQueryErrorInSubscription()
         {
@@ -408,6 +404,5 @@ public async void CanHandleQueryErrorInSubscription()
                 ChatClient.Dispose();
             }
         }
-
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
index aa6cb945..d77ca14c 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
@@ -7,6 +7,7 @@ namespace GraphQL.Integration.Tests.WebsocketTests
     public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
     {
         public Newtonsoft(ITestOutputHelper output, NewtonsoftIntegrationServerTestFixture fixture) : base(output, fixture)
-        { }
+        {
+        }
     }
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
index ce34bcc8..3d7fde8d 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
@@ -2,10 +2,8 @@
 
 namespace GraphQL.Primitives.Tests
 {
-
     public class GraphQLLocationTest
     {
-
         [Fact]
         public void ConstructorFact()
         {
@@ -60,7 +58,5 @@ public void GetHashCodeFact()
             var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
             Assert.True(graphQLLocation1.GetHashCode() == graphQLLocation2.GetHashCode());
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
index 8fbda085..e5b41a15 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
@@ -2,10 +2,8 @@
 
 namespace GraphQL.Primitives.Tests
 {
-
     public class GraphQLRequestTest
     {
-
         [Fact]
         public void ConstructorFact()
         {
@@ -47,7 +45,6 @@ public void Equality3Fact()
             Assert.Equal(graphQLRequest1, graphQLRequest2);
         }
 
-
         [Fact]
         public void Equality4Fact()
         {
@@ -75,8 +72,8 @@ public void InEquality1Fact()
         [Fact]
         public void InEquality2Fact()
         {
-            GraphQLRequest graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            GraphQLRequest graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
             Assert.NotEqual(graphQLRequest1, graphQLRequest2);
         }
 
@@ -122,8 +119,10 @@ public void PropertyQueryGetFact()
         [Fact]
         public void PropertyQuerySetFact()
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            graphQLRequest.Query = "{hero{name2}}";
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName")
+            {
+                Query = "{hero{name2}}"
+            };
             Assert.Equal("{hero{name2}}", graphQLRequest.Query);
         }
 
@@ -144,8 +143,10 @@ public void PropertyOperationNameNullGetFact()
         [Fact]
         public void PropertyOperationNameSetFact()
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1");
-            graphQLRequest.OperationName = "operationName2";
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1")
+            {
+                OperationName = "operationName2"
+            };
             Assert.Equal("operationName2", graphQLRequest.OperationName);
         }
 
@@ -166,17 +167,17 @@ public void PropertyVariableNullGetFact()
         [Fact]
         public void PropertyVariableSetFact()
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1");
-            graphQLRequest.Variables = new
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1")
             {
-                varName = "varValue2"
+                Variables = new
+                {
+                    varName = "varValue2"
+                }
             };
             Assert.Equal(new
             {
                 varName = "varValue2"
             }, graphQLRequest.Variables);
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
index ed23f3fd..ce062e05 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
@@ -2,10 +2,8 @@
 
 namespace GraphQL.Primitives.Tests
 {
-
     public class GraphQLResponseTest
     {
-
         [Fact]
         public void Constructor1Fact()
         {
@@ -112,7 +110,5 @@ public void GetHashCodeFact()
             };
             Assert.True(graphQLResponse1.GetHashCode() == graphQLResponse2.GetHashCode());
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
index da1ccf02..094670a0 100644
--- a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
@@ -7,7 +7,6 @@ namespace GraphQL.Primitives.Tests
 {
     public class JsonSerializationTests
     {
-
         [Fact]
         public void WebSocketResponseDeserialization()
         {
@@ -22,7 +21,6 @@ public void WebSocketResponseDeserialization()
         public class TestObject
         {
             public string Id { get; set; }
-
         }
 
         public class ExtendedTestObject : TestObject
diff --git a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
index e387d32b..95e5f1fc 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
@@ -3,19 +3,21 @@
 
 namespace GraphQL.Server.Test.GraphQL.Models
 {
-
     public class Repository
     {
         public int DatabaseId { get; set; }
+
         public string Id { get; set; }
+
         public string Name { get; set; }
+
         public object Owner { get; set; }
+
         public Uri Url { get; set; }
     }
 
     public class RepositoryGraphType : ObjectGraphType<Repository>
     {
-
         public RepositoryGraphType()
         {
             Name = nameof(Repository);
@@ -25,7 +27,5 @@ public RepositoryGraphType()
             //this.Field(expression => expression.Owner);
             Field<NonNullGraphType<UriGraphType>>("url");
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/Storage.cs b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
index 613a537a..0280b28f 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Storage.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
@@ -5,10 +5,8 @@
 
 namespace GraphQL.Server.Test.GraphQL
 {
-
     public static class Storage
     {
-
         public static IQueryable<Repository> Repositories { get; } = new List<Repository>()
             .Append(new Repository
             {
@@ -19,7 +17,5 @@ public static class Storage
                 Url = new Uri("https://github.com/graphql-dotnet/graphql-client")
             })
             .AsQueryable();
-
     }
-
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
index a1077dc6..dfd67981 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
@@ -2,14 +2,10 @@
 
 namespace GraphQL.Server.Test.GraphQL
 {
-
     public class TestMutation : ObjectGraphType
     {
-
         public TestMutation()
         {
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index 2fb39ab3..bf8aa3ae 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -4,10 +4,8 @@
 
 namespace GraphQL.Server.Test.GraphQL
 {
-
     public class TestQuery : ObjectGraphType
     {
-
         public TestQuery()
         {
             Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context =>
@@ -17,7 +15,5 @@ public TestQuery()
                 return Storage.Repositories.FirstOrDefault(predicate => predicate.Name == name);
             });
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
index a61d3558..c589d388 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
@@ -2,17 +2,13 @@
 
 namespace GraphQL.Server.Test.GraphQL
 {
-
     public class TestSchema : Schema
     {
-
         public TestSchema()
         {
             Query = new TestQuery();
             //this.Mutation = new TestMutation();
             //this.Subscription = new TestSubscription();
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
index f6d50470..4fabf386 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
@@ -2,14 +2,10 @@
 
 namespace GraphQL.Server.Test.GraphQL
 {
-
     public class TestSubscription : ObjectGraphType
     {
-
         public TestSubscription()
         {
         }
-
     }
-
 }
diff --git a/tests/GraphQL.Server.Test/Program.cs b/tests/GraphQL.Server.Test/Program.cs
index 2b5c329a..df18d888 100644
--- a/tests/GraphQL.Server.Test/Program.cs
+++ b/tests/GraphQL.Server.Test/Program.cs
@@ -4,18 +4,14 @@
 
 namespace GraphQL.Server.Test
 {
-
     public class Program
     {
-
         public static async Task Main(string[] args) =>
             await CreateHostBuilder(args).Build().RunAsync();
 
         public static IWebHostBuilder CreateHostBuilder(string[] args = null) =>
             WebHost.CreateDefaultBuilder(args)
-                .UseKestrel(options => { options.AllowSynchronousIO = true; })
+                .UseKestrel(options => options.AllowSynchronousIO = true)
                 .UseStartup<Startup>();
-
     }
-
 }
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index d330ed5d..a1f710ee 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -2,23 +2,13 @@
 using GraphQL.Server.Ui.GraphiQL;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
 namespace GraphQL.Server.Test
 {
-
     public class Startup
     {
-
-        public IConfiguration Configuration { get; }
-
-        public Startup(IConfiguration configuration)
-        {
-            Configuration = configuration;
-        }
-
         public void Configure(IApplicationBuilder app)
         {
             var webHostEnvironment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
@@ -43,7 +33,5 @@ public void ConfigureServices(IServiceCollection services)
                 options.ExposeExceptions = true;
             }).AddWebSockets();
         }
-
     }
-
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 71a76d67..49586dc0 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -24,16 +24,14 @@ public Startup(IConfiguration configuration, IWebHostEnvironment environment)
         }
 
         public IConfiguration Configuration { get; }
+
         public IWebHostEnvironment Environment { get; }
 
         // This method gets called by the runtime. Use this method to add services to the container.
         // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
         public void ConfigureServices(IServiceCollection services)
         {
-            services.Configure<KestrelServerOptions>(options =>
-            {
-                options.AllowSynchronousIO = true;
-            });
+            services.Configure<KestrelServerOptions>(options => options.AllowSynchronousIO = true);
 
             services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
             services.AddChatSchema();
diff --git a/tests/tests.props b/tests/tests.props
index 46e995fc..2b4c9451 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="utf-8"?>
 <Project>
 
 	<Import Project="../root.props" />

From 3bbeec2821e71d422d41f9667c5ad3c115443be9 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sat, 4 Apr 2020 13:31:17 +0300
Subject: [PATCH 235/455] consolidate test projects spaces instead of tabs

---
 .../GraphQL.Client.Example.csproj             | 16 ++---
 root.props                                    | 66 +++++++++----------
 ...aphQL.Client.Abstractions.Websocket.csproj | 12 ++--
 .../GraphQL.Client.Abstractions.csproj        | 22 +++----
 .../GraphQL.Client.LocalExecution.csproj      | 26 ++++----
 ...raphQL.Client.Serializer.Newtonsoft.csproj |  2 +-
 ...QL.Client.Serializer.SystemTextJson.csproj | 14 ++--
 src/GraphQL.Client/GraphQL.Client.csproj      | 50 +++++++-------
 .../GraphQL.Primitives.csproj                 | 12 ++--
 src/src.props                                 | 56 ++++++++--------
 .../GraphQL.Client.Serializer.Tests.csproj    | 11 +---
 .../GraphQL.Client.Tests.Common.csproj        |  4 +-
 .../Helpers/CallbackMonitor.cs                |  4 +-
 .../Helpers/ObservableTester.cs               | 10 +--
 .../GraphQL.Integration.Tests.csproj          | 11 +---
 .../WebsocketTests/Base.cs                    |  2 -
 .../GraphQL.Primitives.Tests.csproj           |  8 ---
 .../JsonSerializationTests.cs                 |  1 +
 .../GraphQL.Server.Test.csproj                | 20 +++---
 .../IntegrationTestServer.csproj              |  3 +
 tests/tests.props                             | 20 +++---
 21 files changed, 177 insertions(+), 193 deletions(-)

diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index d6a75865..ff9af100 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<PropertyGroup>
-		<OutputType>Exe</OutputType>
-		<TargetFramework>netcoreapp3.1</TargetFramework>
-	</PropertyGroup>
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
 
-	<ItemGroup>
-		<ProjectReference Include="..\..\src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
-		<ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
-	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
+  </ItemGroup>
 
 </Project>
diff --git a/root.props b/root.props
index b076b4d3..17bd287e 100644
--- a/root.props
+++ b/root.props
@@ -1,38 +1,38 @@
 <Project>
 
-	<PropertyGroup>
-		<Authors>Deinok,Alexander Rose,graphql-dotnet</Authors>
-		<Description>A GraphQL Client for .NET Standard</Description>
-		<GenerateAssemblyInfo>True</GenerateAssemblyInfo>
-		<GenerateDocumentationFile>True</GenerateDocumentationFile>
-		<LangVersion>8.0</LangVersion>
-		<NeutralLanguage>en-US</NeutralLanguage>
-		<NoWarn>CS0618;CS1591;CS1701;CS8618;CS8632;NU5048;NU5105;NU5125</NoWarn>
-		<Nullable>annotations</Nullable>
-		<PackageIcon>icon.png</PackageIcon>
-		<PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
-		<PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
-		<PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
-		<PackageTags>GraphQL</PackageTags>
-		<RepositoryType>git</RepositoryType>
-		<RepositoryUrl>https://github.com/graphql-dotnet/graphql-client</RepositoryUrl>
-		<TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-		<WarningLevel>4</WarningLevel>
-	</PropertyGroup>
+  <PropertyGroup>
+    <Authors>Deinok,Alexander Rose,graphql-dotnet</Authors>
+    <Description>A GraphQL Client for .NET Standard</Description>
+    <GenerateAssemblyInfo>True</GenerateAssemblyInfo>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+    <LangVersion>8.0</LangVersion>
+    <NeutralLanguage>en-US</NeutralLanguage>
+    <NoWarn>$(NoWarn);CS1591;NU5048;NU5105;NU5125</NoWarn>
+    <Nullable>annotations</Nullable>
+    <PackageIcon>icon.png</PackageIcon>
+    <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
+    <PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <PackageTags>GraphQL</PackageTags>
+    <RepositoryType>git</RepositoryType>
+    <RepositoryUrl>https://github.com/graphql-dotnet/graphql-client</RepositoryUrl>
+    <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
 
-	<ItemGroup>
-		<Content Include="$(MSBuildThisFileDirectory)/LICENSE.txt">
-			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-			<Pack>true</Pack>
-			<PackagePath>LICENSE.txt</PackagePath>
-			<Visible>false</Visible>
-		</Content>
-		<Content Include="$(MSBuildThisFileDirectory)/assets/logo.64x64.png">
-			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-			<Pack>true</Pack>
-			<PackagePath>icon.png</PackagePath>
-			<Visible>false</Visible>
-		</Content>
-	</ItemGroup>
+  <ItemGroup>
+    <Content Include="$(MSBuildThisFileDirectory)/LICENSE.txt">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Pack>true</Pack>
+      <PackagePath>LICENSE.txt</PackagePath>
+      <Visible>false</Visible>
+    </Content>
+    <Content Include="$(MSBuildThisFileDirectory)/assets/logo.64x64.png">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Pack>true</Pack>
+      <PackagePath>icon.png</PackagePath>
+      <Visible>false</Visible>
+    </Content>
+  </ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index 9abfd542..d1980775 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
   
-	<Import Project="../src.props" />
+  <Import Project="../src.props" />
 
-	<PropertyGroup>
+  <PropertyGroup>
     <Description>Abstractions for the Websocket transport used in GraphQL.Client</Description>
 	  <TargetFramework>netstandard2.0</TargetFramework>
-	</PropertyGroup>
+  </PropertyGroup>
 
-	<ItemGroup>
-	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
-	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+  </ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 666c63c0..d7678b66 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -1,18 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<Import Project="../src.props" />
+  <Import Project="../src.props" />
 
-	<PropertyGroup>
-		<Description>Abstractions for GraphQL.Client</Description>
-		<TargetFrameworks>netstandard2.0</TargetFrameworks>
-	</PropertyGroup>
+  <PropertyGroup>
+    <Description>Abstractions for GraphQL.Client</Description>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+  </PropertyGroup>
 
-	<ItemGroup>
-      <ProjectReference Include="..\GraphQL.Primitives\GraphQL.Primitives.csproj" />
-	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Primitives\GraphQL.Primitives.csproj" />
+  </ItemGroup>
 
-	<ItemGroup>
-		<PackageReference Include="System.Reactive" Version="4.3.2" />
-	</ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Reactive" Version="4.3.2" />
+  </ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 927c3470..ebef7ea0 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -1,20 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<Import Project="../src.props" />
+  <Import Project="../src.props" />
 
-	<PropertyGroup>
-		<Description>A GraphQL Client which executes the queries directly on a provided GraphQL schema using graphql-dotnet</Description>
-		<TargetFramework>netstandard2.0</TargetFramework>
-	</PropertyGroup>
+  <PropertyGroup>
+    <Description>A GraphQL Client which executes the queries directly on a provided GraphQL schema using graphql-dotnet</Description>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="GraphQL" Version="2.4.0" />
-		<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-		<PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
-	</ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="GraphQL" Version="2.4.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+  </ItemGroup>
 
-	<ItemGroup>
-		<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
-	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+  </ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index a298a460..4bbcb784 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   
-	<Import Project="../src.props" />
+  <Import Project="../src.props" />
 
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using Newtonsoft.Json as underlying JSON library</Description>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index 009daeea..9433b8dd 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -1,18 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
   
-	<Import Project="../src.props" />
+  <Import Project="../src.props" />
 
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using System.Text.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
   </PropertyGroup>
 
-	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-		<PackageReference Include="System.Text.Json" Version="4.7.0" />
-	</ItemGroup>
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Text.Json" Version="4.7.0" />
+  </ItemGroup>
 
-	<ItemGroup>
-	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
-	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
+  </ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 5946a683..ac1fa526 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -1,39 +1,39 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<Import Project="../src.props" />
+  <Import Project="../src.props" />
 
   <PropertyGroup>
-		<TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
-	  <RootNamespace>GraphQL.Client.Http</RootNamespace>
+    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <RootNamespace>GraphQL.Client.Http</RootNamespace>
   </PropertyGroup>
 
-	<PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-		<DefineConstants>NETSTANDARD</DefineConstants>
-	</PropertyGroup>
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+    <DefineConstants>NETSTANDARD</DefineConstants>
+  </PropertyGroup>
 
-	<PropertyGroup Condition=" '$(TargetFramework)' == 'net461'">
-		<DefineConstants>NETFRAMEWORK</DefineConstants>
-	</PropertyGroup>
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'net461'">
+    <DefineConstants>NETFRAMEWORK</DefineConstants>
+  </PropertyGroup>
 
-	<ItemGroup>
-	  <Compile Remove="GraphQLSerializationExtensions.cs" />
-	</ItemGroup>
+  <ItemGroup>
+    <Compile Remove="GraphQLSerializationExtensions.cs" />
+  </ItemGroup>
 
-	<ItemGroup>
-	  <None Include="GraphQLSerializationExtensions.cs" />
-	</ItemGroup>
+  <ItemGroup>
+    <None Include="GraphQLSerializationExtensions.cs" />
+  </ItemGroup>
 
-	<ItemGroup>
-		<PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
-	</ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
+  </ItemGroup>
 
-	<ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
-		<PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
-	</ItemGroup>
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
+    <PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
+  </ItemGroup>
 
-	<ItemGroup>
-	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
-	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
-	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
+    <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+  </ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index 2b97da30..1c324df3 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<Import Project="../src.props" />
+  <Import Project="../src.props" />
 
-	<PropertyGroup>
-		<Description>GraphQL basic types</Description>
-		<RootNamespace>GraphQL</RootNamespace>
-		<TargetFrameworks>netstandard2.0</TargetFrameworks>
-	</PropertyGroup>
+  <PropertyGroup>
+    <Description>GraphQL basic types</Description>
+    <RootNamespace>GraphQL</RootNamespace>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+  </PropertyGroup>
   
 </Project>
diff --git a/src/src.props b/src/src.props
index f09d3e47..2f7ebb50 100644
--- a/src/src.props
+++ b/src/src.props
@@ -1,36 +1,36 @@
 <Project>
 
-	<Import Project="../root.props" />
+  <Import Project="../root.props" />
 
-	<PropertyGroup>
-		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-		<LangVersion>8.0</LangVersion>
-	</PropertyGroup>
+  <PropertyGroup>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <LangVersion>8.0</LangVersion>
+  </PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="GitVersionTask" Version="5.1.2">
-			<PrivateAssets>all</PrivateAssets>
-			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-		</PackageReference>
-	</ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="GitVersionTask" Version="5.1.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
 
-	<PropertyGroup Condition=" '$(GitVersion_SemVer)' != ''">
-		<GetVersion>false</GetVersion>
-		<WriteVersionInfoToBuildLog>false</WriteVersionInfoToBuildLog>
-		<UpdateAssemblyInfo>false</UpdateAssemblyInfo>
-		<GenerateGitVersionInformation>false</GenerateGitVersionInformation>
+  <PropertyGroup Condition=" '$(GitVersion_SemVer)' != ''">
+    <GetVersion>false</GetVersion>
+    <WriteVersionInfoToBuildLog>false</WriteVersionInfoToBuildLog>
+    <UpdateAssemblyInfo>false</UpdateAssemblyInfo>
+    <GenerateGitVersionInformation>false</GenerateGitVersionInformation>
 
-		<Version>$(GitVersion_FullSemVer)</Version>
-		<VersionPrefix>$(GitVersion_MajorMinorPatch)</VersionPrefix>
-		<VersionSuffix Condition=" '$(UseFullSemVerForNuGet)' == 'false' ">$(GitVersion_NuGetPreReleaseTag)</VersionSuffix>
-		<VersionSuffix Condition=" '$(UseFullSemVerForNuGet)' == 'true' ">$(GitVersion_PreReleaseTag)</VersionSuffix>
-		<PackageVersion Condition=" '$(UseFullSemVerForNuGet)' == 'false' ">$(GitVersion_NuGetVersion)</PackageVersion>
-		<PackageVersion Condition=" '$(UseFullSemVerForNuGet)' == 'true' ">$(GitVersion_FullSemVer)</PackageVersion>
-		<InformationalVersion Condition=" '$(InformationalVersion)' == '' ">$(GitVersion_InformationalVersion)</InformationalVersion>
-		<AssemblyVersion Condition=" '$(AssemblyVersion)' == '' ">$(GitVersion_AssemblySemVer)</AssemblyVersion>
-		<FileVersion Condition=" '$(FileVersion)' == '' ">$(GitVersion_AssemblySemFileVer)</FileVersion>
-		<RepositoryBranch Condition=" '$(RepositoryBranch)' == '' ">$(GitVersion_BranchName)</RepositoryBranch>
-		<RepositoryCommit Condition=" '$(RepositoryCommit)' == '' ">$(GitVersion_Sha)</RepositoryCommit>
-	</PropertyGroup>
+    <Version>$(GitVersion_FullSemVer)</Version>
+    <VersionPrefix>$(GitVersion_MajorMinorPatch)</VersionPrefix>
+    <VersionSuffix Condition=" '$(UseFullSemVerForNuGet)' == 'false' ">$(GitVersion_NuGetPreReleaseTag)</VersionSuffix>
+    <VersionSuffix Condition=" '$(UseFullSemVerForNuGet)' == 'true' ">$(GitVersion_PreReleaseTag)</VersionSuffix>
+    <PackageVersion Condition=" '$(UseFullSemVerForNuGet)' == 'false' ">$(GitVersion_NuGetVersion)</PackageVersion>
+    <PackageVersion Condition=" '$(UseFullSemVerForNuGet)' == 'true' ">$(GitVersion_FullSemVer)</PackageVersion>
+    <InformationalVersion Condition=" '$(InformationalVersion)' == '' ">$(GitVersion_InformationalVersion)</InformationalVersion>
+    <AssemblyVersion Condition=" '$(AssemblyVersion)' == '' ">$(GitVersion_AssemblySemVer)</AssemblyVersion>
+    <FileVersion Condition=" '$(FileVersion)' == '' ">$(GitVersion_AssemblySemFileVer)</FileVersion>
+    <RepositoryBranch Condition=" '$(RepositoryBranch)' == '' ">$(GitVersion_BranchName)</RepositoryBranch>
+    <RepositoryCommit Condition=" '$(RepositoryCommit)' == '' ">$(GitVersion_Sha)</RepositoryCommit>
+  </PropertyGroup>
 
 </Project>
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index b61c1466..3a5af98e 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -1,18 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
+  <Import Project="../tests.props" />
+  
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-	  <IsPackable>false</IsPackable>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.10.2" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
-    <PackageReference Include="coverlet.collector" Version="1.0.1" />
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\..\src\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj" />
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index dfbb9146..ad646c73 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -1,12 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
+  <Import Project="../tests.props" />
+  
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-	  <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.10.0" />
     <PackageReference Include="GraphQL" Version="2.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index df759d07..6aa7284a 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -12,7 +12,7 @@ public class CallbackMonitor<T>
         private readonly ManualResetEventSlim _callbackInvoked = new ManualResetEventSlim();
 
         /// <summary>
-        /// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+        /// The timeout for <see cref="CallbackAssertions{T}.HaveBeenInvokedWithPayload(TimeSpan, string, object[])"/>. Defaults to 1 second.
         /// </summary>
         public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
@@ -38,7 +38,7 @@ public void Invoke(T param)
         /// </summary>
         public void Reset()
         {
-            LastPayload = default(T);
+            LastPayload = default;
             _callbackInvoked.Reset();
         }
 
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 82e7eac7..1a8d5220 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -18,12 +18,12 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable
         private readonly EventLoopScheduler _observeScheduler = new EventLoopScheduler();
 
         /// <summary>
-        /// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+        /// The timeout for SubscriptionAssertions.***Have*** methods. Defaults to 3 seconds.
         /// </summary>
         public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
 
         /// <summary>
-        /// Indicates that an update has been received since the last <see cref="_reset"/>
+        /// Indicates that an update has been received since the last <see cref="Reset()"/>
         /// </summary>
         public bool UpdateReceived => _updateReceived.IsSet;
 
@@ -102,7 +102,7 @@ public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceiv
                     .ForCondition(isSet => isSet)
                     .FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
 
-                Subject._updateReceived.Reset();
+                Subject.Reset();
                 return new AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
             }
             public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(string because = "", params object[] becauseArgs)
@@ -117,7 +117,7 @@ public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(Ti
                     .ForCondition(isSet => !isSet)
                     .FailWith("Expected {context:Subscription} to not receive a new payload{reason}, but did receive an update: {0}", Subject.LastPayload);
 
-                Subject._updateReceived.Reset();
+                Subject.Reset();
                 return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
             }
             public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(string because = "", params object[] becauseArgs)
@@ -134,10 +134,10 @@ public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveRecei
 
                 return new AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception>(this, Subject.Error);
             }
+
             public AndWhichConstraint<SubscriptionAssertions<TPayload>, Exception> HaveReceivedError(string because = "", params object[] becauseArgs)
                 => HaveReceivedError(Subject.Timeout, because, becauseArgs);
 
-
             public AndConstraint<SubscriptionAssertions<TPayload>> HaveCompleted(TimeSpan timeout,
                 string because = "", params object[] becauseArgs)
             {
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 5b55b2e2..3cc7fd29 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -1,23 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
+  <Import Project="../tests.props" />
+  
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.10.0" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="4.3.2" />
-    <PackageReference Include="NETStandard.Library" Version="2.0.3" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
-    </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 2bb72794..786d0923 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -380,8 +380,6 @@ public async void CanHandleSubscriptionError()
         [Fact]
         public async void CanHandleQueryErrorInSubscription()
         {
-            var test = new GraphQLRequest("tset", new { test = "blaa" });
-
             var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
             await ChatClient.InitializeWebsocketConnection();
             callbackMonitor.Should().HaveBeenInvokedWithPayload();
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index c7be7594..99070b4c 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -6,16 +6,8 @@
 		<TargetFramework>netcoreapp3.1</TargetFramework>
 	</PropertyGroup>
 
-	<ItemGroup>
-	  <PackageReference Include="FluentAssertions" Version="5.10.0" />
-	</ItemGroup>
-
 	<ItemGroup>
 		<ProjectReference Include="..\..\src\GraphQL.Primitives\GraphQL.Primitives.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <PackageReference Update="Microsoft.NET.Test.Sdk" Version="16.5.0" />
-	</ItemGroup>
-
 </Project>
diff --git a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
index 094670a0..74add0a1 100644
--- a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
@@ -13,6 +13,7 @@ public void WebSocketResponseDeserialization()
             var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff" };
             var json = JsonSerializer.Serialize(testObject);
             var deserialized = JsonSerializer.Deserialize<TestObject>(json);
+            deserialized.Id.Should().Be("test");
             var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
             var childObject = (JsonElement)dict["ChildObject"];
             childObject.GetProperty("Id").GetString().Should().Be(testObject.ChildObject.Id);
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 8ae5718c..bdb8aaba 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -1,13 +1,15 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
-	<PropertyGroup>
-		<TargetFramework>netcoreapp3.1</TargetFramework>
-	</PropertyGroup>
+  <Import Project="../tests.props" />
 
-	<ItemGroup>
-		<PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
-		<PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
-		<PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
-	</ItemGroup>
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+  </ItemGroup>
 
 </Project>
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index a1f28376..2cc80a82 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
+  <Import Project="../tests.props" />
+  
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+    <StartupObject>IntegrationTestServer.Program</StartupObject>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/tests.props b/tests/tests.props
index 2b4c9451..af4d8c78 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -1,16 +1,18 @@
 <Project>
 
-	<Import Project="../root.props" />
+  <Import Project="../root.props" />
 
-	<PropertyGroup>
+  <PropertyGroup>
 		<IsPackable>false</IsPackable>
-		<IsTestProject>true</IsTestProject>
-	</PropertyGroup>
+    <NoWarn>$(NoWarn);NU1701;IDE1006</NoWarn>
+  </PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
-		<PackageReference Include="xunit" Version="2.4.1" />
-		<PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-	</ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
+    <PackageReference Include="coverlet.collector" Version="1.0.1" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+  </ItemGroup>
 
 </Project>

From e26ab0425230afd2ce2dc9d3b844fe20fea8cbee Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sat, 4 Apr 2020 13:48:57 +0300
Subject: [PATCH 236/455]  fix props

---
 examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj | 1 +
 .../GraphQL.Client.Tests.Common.csproj                        | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index ff9af100..8880a7a6 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index ad646c73..1f013292 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -1,9 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../tests.props" />
-  
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,6 +12,7 @@
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
   </ItemGroup>
 
   <ItemGroup>

From 1ae75762caf835aeaa40ebabdddb9766f3d18ada Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sat, 4 Apr 2020 13:55:46 +0300
Subject: [PATCH 237/455] fix again

---
 .../GraphQL.Client.Tests.Common.csproj                         | 2 +-
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj           | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 1f013292..84b470fe 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -6,13 +6,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
     <PackageReference Include="GraphQL" Version="2.4.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
     <PackageReference Include="System.Reactive" Version="4.3.2" />
     <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index bdb8aaba..eeb2302e 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -1,9 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
-  <Import Project="../tests.props" />
-
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>

From 2c1dd95c37ac9d3c2e539f1ae13f21b881b316e8 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sat, 4 Apr 2020 17:04:51 +0300
Subject: [PATCH 238/455] fix props

---
 .../GraphQL.Client.Tests.Common.csproj                     | 1 -
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj       | 1 -
 tests/IntegrationTestServer/IntegrationTestServer.csproj   | 2 --
 tests/tests.props                                          | 7 +++++--
 4 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 84b470fe..3be17715 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index eeb2302e..ad08e233 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 2cc80a82..da280f0f 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
-  <Import Project="../tests.props" />
-  
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
     <StartupObject>IntegrationTestServer.Program</StartupObject>
diff --git a/tests/tests.props b/tests/tests.props
index af4d8c78..19bc6d36 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -8,10 +8,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-    <PackageReference Include="coverlet.collector" Version="1.0.1" />
+    <PackageReference Include="coverlet.collector" Version="1.2.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime;build;native;contentfiles;analyzers;buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="FluentAssertions" Version="5.10.3" />
   </ItemGroup>
 

From a4c74b1fe4dedc80a7e177c72db358c615479215 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sat, 4 Apr 2020 17:18:02 +0300
Subject: [PATCH 239/455] timeout

---
 tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 1a8d5220..2374e7f4 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -18,9 +18,9 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable
         private readonly EventLoopScheduler _observeScheduler = new EventLoopScheduler();
 
         /// <summary>
-        /// The timeout for SubscriptionAssertions.***Have*** methods. Defaults to 3 seconds.
+        /// The timeout for SubscriptionAssertions.***Have*** methods. Defaults to 30 seconds.
         /// </summary>
-        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
+        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(30);
 
         /// <summary>
         /// Indicates that an update has been received since the last <see cref="Reset()"/>

From 51eb8013b81b18020147703afcea2fbd20e3693b Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sat, 4 Apr 2020 17:31:08 +0300
Subject: [PATCH 240/455] revert

---
 .../Helpers/ObservableTester.cs                       | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
index 2374e7f4..0c361d83 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ObservableTester.cs
@@ -18,12 +18,12 @@ public class ObservableTester<TSubscriptionPayload> : IDisposable
         private readonly EventLoopScheduler _observeScheduler = new EventLoopScheduler();
 
         /// <summary>
-        /// The timeout for SubscriptionAssertions.***Have*** methods. Defaults to 30 seconds.
+        /// The timeout for SubscriptionAssertions.***Have*** methods. Defaults to 3 seconds.
         /// </summary>
-        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(30);
+        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(3);
 
         /// <summary>
-        /// Indicates that an update has been received since the last <see cref="Reset()"/>
+        /// Indicates that an update has been received since the last reset of <see cref="_updateReceived"/>
         /// </summary>
         public bool UpdateReceived => _updateReceived.IsSet;
 
@@ -102,9 +102,10 @@ public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceiv
                     .ForCondition(isSet => isSet)
                     .FailWith("Expected {context:Subscription} to receive new payload{reason}, but did not receive an update within {0}", timeout);
 
-                Subject.Reset();
+                Subject._updateReceived.Reset();
                 return new AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
             }
+
             public AndWhichConstraint<SubscriptionAssertions<TPayload>, TPayload> HaveReceivedPayload(string because = "", params object[] becauseArgs)
                 => HaveReceivedPayload(Subject.Timeout, because, becauseArgs);
 
@@ -117,7 +118,7 @@ public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(Ti
                     .ForCondition(isSet => !isSet)
                     .FailWith("Expected {context:Subscription} to not receive a new payload{reason}, but did receive an update: {0}", Subject.LastPayload);
 
-                Subject.Reset();
+                Subject._updateReceived.Reset();
                 return new AndConstraint<SubscriptionAssertions<TPayload>>(this);
             }
             public AndConstraint<SubscriptionAssertions<TPayload>> NotHaveReceivedPayload(string because = "", params object[] becauseArgs)

From 9b745f0378901aaba7e8204fa0b6353b9444fb1b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 5 Apr 2020 01:35:30 +0200
Subject: [PATCH 241/455] Apply suggestions from code review

remove excess newlines

Co-Authored-By: Ivan Maximov <sungam3r@yandex.ru>
---
 .../FluentAssertions.Reactive/ObservableAssertions.cs         | 4 ----
 .../FluentAssertions.Reactive/ObservableExtensions.cs         | 1 -
 2 files changed, 5 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index 9af03426..4efa9c36 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -64,7 +64,6 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(string because = "", params object[] becauseArgs)
             => Push(1, TimeSpan.FromSeconds(1), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the specified <paramref name="timeout"/>.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
@@ -94,7 +93,6 @@ public AndConstraint<ObservableAssertions<TPayload>> NotPush(TimeSpan timeout,
         public AndConstraint<ObservableAssertions<TPayload>> NotPush(string because = "", params object[] becauseArgs)
             => NotPush(TimeSpan.FromMilliseconds(100), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the specified <paramref name="timeout"/>. 
         /// </summary>
@@ -123,7 +121,6 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(TimeSp
         public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(string because = "", params object[] becauseArgs)
             => Fail(TimeSpan.FromSeconds(1), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the specified <paramref name="timeout"/>. 
         /// </summary>
@@ -152,7 +149,6 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Complete(string because = "", params object[] becauseArgs)
             => Complete(TimeSpan.FromSeconds(1), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the specified <paramref name="timeout"/>. 
         /// </summary>
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
index 0fd4afa7..1b477552 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
@@ -75,7 +75,6 @@ public static IEnumerable<TPayload> GetMessages<TPayload>(
             .Where(r => r.Value.Kind == NotificationKind.OnNext)
             .Select(recorded => recorded.Value.Value);
 
-
         /// <summary>
         /// Clears the recorded notifications on the underlying <see cref="FluentTestObserver{TPayload}"/>
         /// </summary>

From e67d70ea1e1bc3b553c96837ca472ef47c7b24f1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 10:06:21 +0200
Subject: [PATCH 242/455] remove unused file, cleanup GitVersionTask references

---
 ...aphQL.Client.Abstractions.Websocket.csproj |  8 ----
 .../GraphQL.Client.Abstractions.csproj        |  7 ---
 .../GraphQL.Client.LocalExecution.csproj      |  7 ---
 ...raphQL.Client.Serializer.Newtonsoft.csproj |  8 ----
 ...QL.Client.Serializer.SystemTextJson.csproj | 11 +----
 src/GraphQL.Client/GraphQL.Client.csproj      | 21 +--------
 .../GraphQLSerializationExtensions.cs         | 44 -------------------
 .../GraphQL.Primitives.csproj                 |  6 ---
 src/src.props                                 | 13 +++---
 9 files changed, 10 insertions(+), 115 deletions(-)
 delete mode 100644 src/GraphQL.Client/GraphQLSerializationExtensions.cs

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index f070a6b5..0863c38f 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -4,18 +4,10 @@
 	<PropertyGroup>
     <Description>Abstractions for the Websocket transport used in GraphQL.Client</Description>
 	  <TargetFramework>netstandard2.0</TargetFramework>
-	  <LangVersion>8.0</LangVersion>
 	</PropertyGroup>
 
 	<ItemGroup>
 	<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <PackageReference Update="GitVersionTask" Version="5.2.4">
-	    <PrivateAssets>all</PrivateAssets>
-	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-	  </PackageReference>
-	</ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 4e5413ab..63e9aa89 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -16,11 +16,4 @@
 		<PackageReference Include="System.Reactive" Version="4.3.2" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <PackageReference Update="GitVersionTask" Version="5.2.4">
-	    <PrivateAssets>all</PrivateAssets>
-	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-	  </PackageReference>
-	</ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 1b65a0d9..927c3470 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -17,11 +17,4 @@
 		<ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <PackageReference Update="GitVersionTask" Version="5.2.4">
-	    <PrivateAssets>all</PrivateAssets>
-	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-	  </PackageReference>
-	</ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index fa040d95..530f1757 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -4,7 +4,6 @@
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using Newtonsoft.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
-	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
@@ -15,11 +14,4 @@
     <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Update="GitVersionTask" Version="5.2.4">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index 52d3b180..2713516e 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
-	<Import Project="../src.props" />
+
+  <Import Project="../src.props" />
 
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using System.Text.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
-	  <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
@@ -15,11 +15,4 @@
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <PackageReference Update="GitVersionTask" Version="5.2.4">
-	    <PrivateAssets>all</PrivateAssets>
-	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-	  </PackageReference>
-	</ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 43e4271a..df3edd60 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -15,16 +15,7 @@
 		<DefineConstants>NETFRAMEWORK</DefineConstants>
 	</PropertyGroup>
 
-	<ItemGroup>
-	  <Compile Remove="GraphQLSerializationExtensions.cs" />
-	</ItemGroup>
-
-	<ItemGroup>
-	  <None Include="GraphQLSerializationExtensions.cs" />
-	</ItemGroup>
-
-
-	<ItemGroup>
+  <ItemGroup>
 		<PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
 	</ItemGroup>
 
@@ -37,14 +28,4 @@
 	  <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
 	</ItemGroup>
 
-	<ItemGroup>
-	  <PackageReference Update="GitVersionTask" Version="5.2.4">
-	    <PrivateAssets>all</PrivateAssets>
-	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-	  </PackageReference>
-	</ItemGroup>
-
-	
-
-
 </Project>
diff --git a/src/GraphQL.Client/GraphQLSerializationExtensions.cs b/src/GraphQL.Client/GraphQLSerializationExtensions.cs
deleted file mode 100644
index 8d702204..00000000
--- a/src/GraphQL.Client/GraphQLSerializationExtensions.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-using System.IO;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Client.Abstractions.Websocket;
-using GraphQL.Client.Http.Websocket;
-using Newtonsoft.Json;
-
-namespace GraphQL.Client.Http {
-	public static class GraphQLSerializationExtensions {
-
-		public static string SerializeToJson(this GraphQLRequest request,
-			GraphQLHttpClientOptions options) {
-			return JsonConvert.SerializeObject(request, options.JsonSerializerSettings);
-		}
-		
-		public static byte[] SerializeToBytes(this GraphQLRequest request,
-			GraphQLHttpClientOptions options) {
-			var json = JsonConvert.SerializeObject(request, options.JsonSerializerSettings);
-			return Encoding.UTF8.GetBytes(json);
-		}
-
-		public static TGraphQLResponse DeserializeFromJson<TGraphQLResponse>(this string jsonString,
-			GraphQLHttpClientOptions options) {
-			return JsonConvert.DeserializeObject<TGraphQLResponse>(jsonString, options.JsonSerializerSettings);
-		}
-
-		public static TObject DeserializeFromBytes<TObject>(this byte[] utf8Bytes,
-			GraphQLHttpClientOptions options) {
-			return JsonConvert.DeserializeObject<TObject>(Encoding.UTF8.GetString(utf8Bytes), options.JsonSerializerSettings);
-		}
-
-
-		public static Task<TGraphQLResponse> DeserializeFromJsonAsync<TGraphQLResponse>(this Stream stream,
-			GraphQLHttpClientOptions options, CancellationToken cancellationToken = default) {
-			using (StreamReader sr = new StreamReader(stream))
-			using (JsonReader reader = new JsonTextReader(sr)) {
-				JsonSerializer serializer = JsonSerializer.Create(options.JsonSerializerSettings);
-				
-				return Task.FromResult(serializer.Deserialize<TGraphQLResponse>(reader));
-			}
-		}
-	}
-}
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index 51034540..53d39859 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -8,10 +8,4 @@
 		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
 
-	<ItemGroup>
-	  <PackageReference Update="GitVersionTask" Version="5.2.4">
-	    <PrivateAssets>all</PrivateAssets>
-	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-	  </PackageReference>
-	</ItemGroup>
 </Project>
diff --git a/src/src.props b/src/src.props
index e2e2512b..d7ed8515 100644
--- a/src/src.props
+++ b/src/src.props
@@ -8,12 +8,13 @@
 		<LangVersion>8.0</LangVersion>
 	</PropertyGroup>
 
-	<ItemGroup>
-		<PackageReference Include="GitVersionTask" Version="5.1.2">
-			<PrivateAssets>all</PrivateAssets>
-			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-		</PackageReference>
-	</ItemGroup>
+  <!--TODO: remove condition when https://github.com/GitTools/GitVersion/issues/2063 is fixed-->
+  <ItemGroup Condition=" '$(DEBUG)' != ''">
+    <PackageReference Update="GitVersionTask" Version="5.2.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
 
 	<PropertyGroup Condition=" '$(GitVersion_SemVer)' != ''">
 		<GetVersion>false</GetVersion>

From 3724956e0166beef3fad9285e9d610207d091cfc Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 10:31:41 +0200
Subject: [PATCH 243/455] add async assertions

---
 .../ObservableAssertions.cs                   | 98 ++++++++++++++++++-
 .../ObservableExtensions.cs                   | 24 ++++-
 2 files changed, 117 insertions(+), 5 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index 4efa9c36..cd6bf808 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -4,6 +4,7 @@
 using System.Reactive;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
+using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
@@ -50,6 +51,39 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>(this, notifications);
         }
 
+
+        /// <inheritdoc cref="Push(int,TimeSpan,string,object[])"/>
+        public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            IEnumerable<TPayload> notifications = new List<TPayload>();
+
+            try
+            {
+                notifications = await Observer.RecordedNotificationStream
+                    .Select(r => r.Value)
+                    .Dematerialize()
+                    .Take(numberOfNotifications)
+                    .Timeout(timeout)
+                    .Catch<TPayload, TimeoutException>(exception => Observable.Empty<TPayload>())
+                    .ToList()
+                    .ToTask();
+
+                Execute.Assertion
+                    .ForCondition(notifications.Any())
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected {context} to push at least one notification within {0}{reason}, but it did not.", timeout);
+            }
+            catch (Exception e)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected {context} to push at least one notification, but failed with exception {1}.", timeout, e);
+            }
+
+            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
+        }
+
         /// <summary>
         /// Asserts that at least <paramref name="numberOfNotifications"/> notifications are pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
@@ -57,6 +91,10 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
             => Push(numberOfNotifications, TimeSpan.FromSeconds(1), because, becauseArgs);
 
+        /// <inheritdoc cref="Push(int,string,object[])"/>
+        public Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, string because = "", params object[] becauseArgs)
+            => PushAsync(numberOfNotifications, TimeSpan.FromSeconds(1), because, becauseArgs);
+
         /// <summary>
         /// Asserts that at least 1 notification is pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
@@ -64,6 +102,11 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(string because = "", params object[] becauseArgs)
             => Push(1, TimeSpan.FromSeconds(1), because, becauseArgs);
 
+        /// <inheritdoc cref="Push(string,object[])"/>
+        public Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(string because = "", params object[] becauseArgs)
+            => PushAsync(1, TimeSpan.FromSeconds(1), because, becauseArgs);
+
+
         /// <summary>
         /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the specified <paramref name="timeout"/>.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
@@ -93,6 +136,7 @@ public AndConstraint<ObservableAssertions<TPayload>> NotPush(TimeSpan timeout,
         public AndConstraint<ObservableAssertions<TPayload>> NotPush(string because = "", params object[] becauseArgs)
             => NotPush(TimeSpan.FromMilliseconds(100), because, becauseArgs);
 
+
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the specified <paramref name="timeout"/>. 
         /// </summary>
@@ -115,16 +159,40 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(TimeSp
             return new AndWhichConstraint<ObservableAssertions<TPayload>, Exception>(this, exception);
         }
 
+        /// <inheritdoc cref="Fail(TimeSpan,string,object[])"/>
+        public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, Exception>> FailAsync(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            var exception = await Observer.RecordedNotificationStream
+                .Timeout(timeout)
+                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
+                .FirstOrDefaultAsync(recorded => recorded.Value.Kind == NotificationKind.OnError)
+                .Select(recorded => recorded.Value.Exception)
+                .ToTask();
+
+            Execute.Assertion
+                .ForCondition(exception != null)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {context} to fail within {0}{reason}, but it did not.", timeout);
+
+            return new AndWhichConstraint<ObservableAssertions<TPayload>, Exception>(this, exception);
+        }
+
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the next 1 second. 
         /// </summary>
         public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(string because = "", params object[] becauseArgs)
             => Fail(TimeSpan.FromSeconds(1), because, becauseArgs);
 
+        /// <inheritdoc cref="Fail(string,object[])"/>
+        public Task<AndWhichConstraint<ObservableAssertions<TPayload>, Exception>> FailAsync(string because = "", params object[] becauseArgs)
+            => FailAsync(TimeSpan.FromSeconds(1), because, becauseArgs);
+
+
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the specified <paramref name="timeout"/>. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Complete(TimeSpan timeout,
+        public AndConstraint<ObservableAssertions<TPayload>> Complete(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
 
@@ -140,15 +208,39 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<N
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context} to complete within {0}{reason}, but it did not.", timeout);
 
-            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>(this, Observer.RecordedNotifications);
+            return new AndConstraint<ObservableAssertions<TPayload>>(this);
+        }
+
+        /// <inheritdoc cref="Complete(System.TimeSpan,string,object[])"/>
+        public async Task<AndConstraint<ObservableAssertions<TPayload>>> CompleteAsync(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+
+            bool completed = await Observer.RecordedNotificationStream
+                .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
+                .Timeout(timeout)
+                .Catch(Observable.Return(false))
+                .ToTask();
+
+            Execute.Assertion
+                .ForCondition(completed)
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {context} to complete within {0}{reason}, but it did not.", timeout);
+
+            return new AndConstraint<ObservableAssertions<TPayload>>(this);
         }
 
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the next 1 second. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Complete(string because = "", params object[] becauseArgs)
+        public AndConstraint<ObservableAssertions<TPayload>> Complete(string because = "", params object[] becauseArgs)
             => Complete(TimeSpan.FromSeconds(1), because, becauseArgs);
 
+        /// <inheritdoc cref="Complete(string,object[])"/>
+        public Task<AndConstraint<ObservableAssertions<TPayload>>> CompleteAsync(string because = "", params object[] becauseArgs)
+            => CompleteAsync(TimeSpan.FromSeconds(1), because, becauseArgs);
+
+
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the specified <paramref name="timeout"/>. 
         /// </summary>
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
index 1b477552..ec8c2137 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reactive;
+using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Execution;
 using Microsoft.Reactive.Testing;
@@ -58,7 +59,18 @@ public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Rec
         public static TPayload GetLastMessage<TPayload>(
             this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
                 recorderConstraint) =>
-            recorderConstraint.GetMessages().LastOrDefault();
+            recorderConstraint.Subject.GetLastMessage();
+
+        /// <summary>
+        /// Extracts the last recorded message
+        /// </summary>
+        public static async Task<TPayload> GetLastMessageAsync<TPayload>(
+            this Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>>
+                assertionTask)
+        {
+            var constraint = await assertionTask;
+            return constraint.GetLastMessage();
+        }
 
         /// <summary>
         /// Extracts the recorded messages
@@ -68,13 +80,21 @@ this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Not
             recorderConstraint) => recorderConstraint.Subject.GetMessages();
 
         /// <summary>
-        /// Extracts the recorded messages from a number od recorded notifications
+        /// Extracts the recorded messages from a number of recorded notifications
         /// </summary>
         public static IEnumerable<TPayload> GetMessages<TPayload>(
             this IEnumerable<Recorded<Notification<TPayload>>> recordedNotifications) => recordedNotifications
             .Where(r => r.Value.Kind == NotificationKind.OnNext)
             .Select(recorded => recorded.Value.Value);
 
+        /// <summary>
+        /// Extracts the recorded messages from a number od recorded notifications
+        /// </summary>
+        public static TPayload GetLastMessage<TPayload>(
+            this IEnumerable<Recorded<Notification<TPayload>>> recordedNotifications) =>
+            recordedNotifications.GetMessages().LastOrDefault();
+
+
         /// <summary>
         /// Clears the recorded notifications on the underlying <see cref="FluentTestObserver{TPayload}"/>
         /// </summary>

From 93c1f073229802fffcd8964096b9cc48b5b9156e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 10:39:33 +0200
Subject: [PATCH 244/455] run observable assertions async

---
 .../ObservableExtensions.cs                   |  4 +-
 .../WebsocketTests/Base.cs                    | 78 +++++++++++--------
 2 files changed, 49 insertions(+), 33 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
index ec8c2137..da2d3987 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
@@ -65,11 +65,11 @@ this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Not
         /// Extracts the last recorded message
         /// </summary>
         public static async Task<TPayload> GetLastMessageAsync<TPayload>(
-            this Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>>
+            this Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>>
                 assertionTask)
         {
             var constraint = await assertionTask;
-            return constraint.GetLastMessage();
+            return constraint.Subject.LastOrDefault();
         }
 
         /// <summary>
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 12c2eea4..eb5bcc97 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Linq;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -137,21 +138,24 @@ public async void CanCreateObservableSubscription()
 
             Debug.WriteLine("subscribing...");
             using var observer = observable.Observe();
-            observer.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+            var test = await observer.Should().PushAsync(1);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             var response = await ChatClient.AddMessageAsync(message1);
             response.Data.AddMessage.Content.Should().Be(message1);
-            observer.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
+            await observer.Should().PushAsync(2);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
 
             const string message2 = "lorem ipsum dolor si amet";
             response = await ChatClient.AddMessageAsync(message2);
             response.Data.AddMessage.Content.Should().Be(message2);
-            observer.Should().Push(3).GetLastMessage().Data.MessageAdded.Content.Should().Be(message2);
+            await observer.Should().PushAsync(3);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
 
             // disposing the client should throw a TaskCanceledException on the subscription
             ChatClient.Dispose();
-            observer.Should().Complete();
+            await observer.Should().CompleteAsync();
         }
 
         public class MessageAddedSubscriptionResult
@@ -178,18 +182,21 @@ public async void CanReconnectWithSameObservable()
             callbackMonitor.Should().HaveBeenInvokedWithPayload();
             await ChatClient.InitializeWebsocketConnection();
             Debug.WriteLine("websocket connection initialized");
-            observer.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+            await observer.Should().PushAsync(1);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             Debug.WriteLine($"adding message {message1}");
             var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(true);
             response.Data.AddMessage.Content.Should().Be(message1);
-            observer.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
+            await observer.Should().PushAsync(2);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
 
             const string message2 = "How are you?";
             response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(true);
             response.Data.AddMessage.Content.Should().Be(message2);
-            observer.Should().Push(3).GetLastMessage().Data.MessageAdded.Content.Should().Be(message2);
+            await observer.Should().PushAsync(3);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
 
             Debug.WriteLine("disposing subscription...");
             observer.Dispose(); // does not close the websocket connection
@@ -197,16 +204,18 @@ public async void CanReconnectWithSameObservable()
             Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
             var observer2 = observable.Observe();
             Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
-            observer2.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(message2);
+            await observer2.Should().PushAsync(1);
+            observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
 
             const string message3 = "lorem ipsum dolor si amet";
             response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(true);
             response.Data.AddMessage.Content.Should().Be(message3);
-            observer2.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message3);
+            await observer2.Should().PushAsync(2);
+            observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message3);
 
             // disposing the client should complete the subscription
             ChatClient.Dispose();
-            observer2.Should().Complete();
+            await observer2.Should().CompleteAsync();
             observer2.Dispose();
         }
 
@@ -257,7 +266,9 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             const string message1 = "Hello World";
             var response = await ChatClient.AddMessageAsync(message1);
             response.Data.AddMessage.Content.Should().Be(message1);
-            messagesMonitor.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
+            await messagesMonitor.Should().PushAsync(2);
+            messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
+
             joinedMonitor.Should().NotPush();
             messagesMonitor.Clear();
             joinedMonitor.Clear();
@@ -265,12 +276,13 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             var joinResponse = await ChatClient.JoinDeveloperUser();
             joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
 
-            var payload = joinedMonitor.Should().Push().GetLastMessage();
+            var payload = await joinedMonitor.Should().PushAsync().GetLastMessageAsync();
             using (new AssertionScope())
             {
                 payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
                 payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
             }
+
             messagesMonitor.Should().NotPush();
             messagesMonitor.Clear();
             joinedMonitor.Clear();
@@ -281,12 +293,12 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             const string message3 = "lorem ipsum dolor si amet";
             response = await ChatClient.AddMessageAsync(message3);
             response.Data.AddMessage.Content.Should().Be(message3);
-            messagesMonitor.Should().Push()
-                .GetLastMessage().Data.MessageAdded.Content.Should().Be(message3);
+            var msg = await messagesMonitor.Should().PushAsync().GetLastMessageAsync();
+            msg.Data.MessageAdded.Content.Should().Be(message3);
 
             // disposing the client should complete the subscription
             ChatClient.Dispose();
-            messagesMonitor.Should().Complete();
+            await messagesMonitor.Should().CompleteAsync();
         }
 
 
@@ -327,12 +339,14 @@ public async void CanHandleConnectionTimeout()
                 // clear the collection so the next tests on the collection work as expected
                 websocketStates.Clear();
 
-                observer.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+                await observer.Should().PushAsync(1);
+                observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
                 const string message1 = "Hello World";
                 var response = await ChatClient.AddMessageAsync(message1);
                 response.Data.AddMessage.Content.Should().Be(message1);
-                observer.Should().Push(2).GetLastMessage().Data.MessageAdded.Content.Should().Be(message1);
+                await observer.Should().PushAsync(2);
+                observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
 
                 Debug.WriteLine("stopping web host...");
                 await Fixture.ShutdownServer();
@@ -347,7 +361,8 @@ public async void CanHandleConnectionTimeout()
                 Debug.WriteLine("web host started");
                 reconnectBlocker.Set();
                 callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
-                observer.Should().Push(3).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+                await observer.Should().PushAsync(3);
+                observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
                 websocketStates.Should().ContainInOrder(
                     GraphQLWebsocketConnectionState.Disconnected,
@@ -356,7 +371,7 @@ public async void CanHandleConnectionTimeout()
 
                 // disposing the client should complete the subscription
                 ChatClient.Dispose();
-                observer.Should().Complete(5.Seconds());
+                await observer.Should().CompleteAsync(5.Seconds());
             }
         }
 
@@ -380,14 +395,14 @@ public async void CanHandleSubscriptionError()
             Debug.WriteLine("subscribing...");
 
             using var observer = observable.Observe();
-            observer.Should().Push(1, 3.Seconds())
-                .GetLastMessage()
-                .Errors.Should().ContainSingle();
-            observer.Should().Complete();
+
+            await observer.Should().PushAsync();
+            observer.RecordedMessages.Last().Errors.Should().ContainSingle();
+
+            await observer.Should().CompleteAsync();
             ChatClient.Dispose();
         }
 
-
         [Fact]
         public async void CanHandleQueryErrorInSubscription()
         {
@@ -407,13 +422,14 @@ public async void CanHandleQueryErrorInSubscription()
             );
 
             Debug.WriteLine("subscribing...");
-            using (var observer = observable.Observe())
-            {
-                observer.Should().Push()
-                    .GetLastMessage().Errors.Should().ContainSingle();
-                observer.Should().Complete();
-                ChatClient.Dispose();
-            }
+
+            using var observer = observable.Observe();
+
+            await observer.Should().PushAsync();
+            observer.RecordedMessages.Last().Errors.Should().ContainSingle();
+
+            await observer.Should().CompleteAsync();
+            ChatClient.Dispose();
         }
 
     }

From c06cb6eb7074b7b10e8c05fda7e274d7becb102d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 10:45:34 +0200
Subject: [PATCH 245/455] move assertion outside of try..catch

---
 .../FluentAssertions.Reactive/ObservableAssertions.cs  | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index cd6bf808..28640229 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -68,11 +68,6 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
                     .Catch<TPayload, TimeoutException>(exception => Observable.Empty<TPayload>())
                     .ToList()
                     .ToTask();
-
-                Execute.Assertion
-                    .ForCondition(notifications.Any())
-                    .BecauseOf(because, becauseArgs)
-                    .FailWith("Expected {context} to push at least one notification within {0}{reason}, but it did not.", timeout);
             }
             catch (Exception e)
             {
@@ -80,6 +75,11 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
                     .BecauseOf(because, becauseArgs)
                     .FailWith("Expected {context} to push at least one notification, but failed with exception {1}.", timeout, e);
             }
+            
+            Execute.Assertion
+                .ForCondition(notifications.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {context} to push at least one notification within {0}{reason}, but it did not.", timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }

From 30c249c83a9c6c9099bf663602cc104f294f7904 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 10:50:10 +0200
Subject: [PATCH 246/455] set default timeout to 10s

---
 .../FluentAssertions.Reactive/ObservableAssertions.cs         | 4 ++--
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs        | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index 28640229..8b321fde 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -89,11 +89,11 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
-            => Push(numberOfNotifications, TimeSpan.FromSeconds(1), because, becauseArgs);
+            => Push(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
 
         /// <inheritdoc cref="Push(int,string,object[])"/>
         public Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, string because = "", params object[] becauseArgs)
-            => PushAsync(numberOfNotifications, TimeSpan.FromSeconds(1), because, becauseArgs);
+            => PushAsync(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
 
         /// <summary>
         /// Asserts that at least 1 notification is pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index eb5bcc97..7f103a9a 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -138,7 +138,7 @@ public async void CanCreateObservableSubscription()
 
             Debug.WriteLine("subscribing...");
             using var observer = observable.Observe();
-            var test = await observer.Should().PushAsync(1);
+            await observer.Should().PushAsync(1);
             observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";

From 9e676ebb8834ff54e998c918d6061b58635b14e5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 11:03:12 +0200
Subject: [PATCH 247/455] consolidate ObservableExtensions and
 ObservableAssertions

---
 .../ObservableAssertions.cs                   | 43 +++++++++++--------
 .../ObservableExtensions.cs                   | 28 +++++-------
 .../WebsocketTests/Base.cs                    |  3 +-
 3 files changed, 36 insertions(+), 38 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index 8b321fde..fd266d0b 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -31,27 +31,38 @@ protected internal ObservableAssertions(FluentTestObserver<TPayload> observer):
         /// Asserts that at least <paramref name="numberOfNotifications"/> notifications were pushed to the <see cref="FluentTestObserver{TPayload}"/> within the specified <paramref name="timeout"/>.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(int numberOfNotifications, TimeSpan timeout,
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
-            var notifications = Observer.RecordedNotificationStream
-                .Where(recorded => recorded.Value.Kind == NotificationKind.OnNext)
-                .Take(numberOfNotifications)
-                .Timeout(timeout)
-                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
-                .ToList()
-                .ToTask()
-                .ExecuteInDefaultSynchronizationContext();
+            IEnumerable<TPayload> notifications = new List<TPayload>();
+
+            try
+            {
+                notifications = Observer.RecordedNotificationStream
+                    .Select(r => r.Value)
+                    .Dematerialize()
+                    .Take(numberOfNotifications)
+                    .Timeout(timeout)
+                    .Catch<TPayload, TimeoutException>(exception => Observable.Empty<TPayload>())
+                    .ToList()
+                    .ToTask()
+                    .ExecuteInDefaultSynchronizationContext();
+            }
+            catch (Exception e)
+            {
+                Execute.Assertion
+                    .BecauseOf(because, becauseArgs)
+                    .FailWith("Expected {context} to push at least one notification, but failed with exception {1}.", timeout, e);
+            }
             
             Execute.Assertion
                 .ForCondition(notifications.Any())
                 .BecauseOf(because, becauseArgs)
                 .FailWith("Expected {context} to push at least one notification within {0}{reason}, but it did not.", timeout);
 
-            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>(this, notifications);
+            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
 
-
         /// <inheritdoc cref="Push(int,TimeSpan,string,object[])"/>
         public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, TimeSpan timeout,
             string because = "", params object[] becauseArgs)
@@ -88,7 +99,7 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
         /// Asserts that at least <paramref name="numberOfNotifications"/> notifications are pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
             => Push(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
 
         /// <inheritdoc cref="Push(int,string,object[])"/>
@@ -99,14 +110,13 @@ public Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayl
         /// Asserts that at least 1 notification is pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> Push(string because = "", params object[] becauseArgs)
+        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(string because = "", params object[] becauseArgs)
             => Push(1, TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <inheritdoc cref="Push(string,object[])"/>
         public Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(string because = "", params object[] becauseArgs)
             => PushAsync(1, TimeSpan.FromSeconds(1), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the specified <paramref name="timeout"/>.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
@@ -136,7 +146,6 @@ public AndConstraint<ObservableAssertions<TPayload>> NotPush(TimeSpan timeout,
         public AndConstraint<ObservableAssertions<TPayload>> NotPush(string because = "", params object[] becauseArgs)
             => NotPush(TimeSpan.FromMilliseconds(100), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the specified <paramref name="timeout"/>. 
         /// </summary>
@@ -188,14 +197,12 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(string
         public Task<AndWhichConstraint<ObservableAssertions<TPayload>, Exception>> FailAsync(string because = "", params object[] becauseArgs)
             => FailAsync(TimeSpan.FromSeconds(1), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the specified <paramref name="timeout"/>. 
         /// </summary>
         public AndConstraint<ObservableAssertions<TPayload>> Complete(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
-
             bool completed = Observer.RecordedNotificationStream
                 .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
                 .Timeout(timeout)
@@ -215,7 +222,6 @@ public AndConstraint<ObservableAssertions<TPayload>> Complete(TimeSpan timeout,
         public async Task<AndConstraint<ObservableAssertions<TPayload>>> CompleteAsync(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
-
             bool completed = await Observer.RecordedNotificationStream
                 .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
                 .Timeout(timeout)
@@ -240,7 +246,6 @@ public AndConstraint<ObservableAssertions<TPayload>> Complete(string because = "
         public Task<AndConstraint<ObservableAssertions<TPayload>>> CompleteAsync(string because = "", params object[] becauseArgs)
             => CompleteAsync(TimeSpan.FromSeconds(1), because, becauseArgs);
 
-
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the specified <paramref name="timeout"/>. 
         /// </summary>
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
index da2d3987..a9dfce46 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
@@ -20,13 +20,13 @@ public static class ObservableExtensions
         /// <summary>
         /// Asserts that the recorded messages contain at lease one item which matches the <paramref name="predicate"/>
         /// </summary>
-        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> WithMessage<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
+        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> WithMessage<TPayload>(
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
         {
             if (predicate is null) throw new ArgumentNullException(nameof(predicate));
             
             var compiledPredicate = predicate.Compile();
-            bool match = recorderConstraint.GetMessages().Any(compiledPredicate);
+            bool match = recorderConstraint.Subject.Any(compiledPredicate);
             
             Execute.Assertion
                 .ForCondition(match)
@@ -38,8 +38,8 @@ public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Rec
         /// <summary>
         /// Asserts that the last recorded message matches the <paramref name="predicate"/>
         /// </summary>
-        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> WithLastMessage<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
+        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> WithLastMessage<TPayload>(
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
         {
             if (predicate is null)
                 throw new ArgumentNullException(nameof(predicate));
@@ -57,9 +57,9 @@ public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Rec
         /// Extracts the last recorded message
         /// </summary>
         public static TPayload GetLastMessage<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
+            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
                 recorderConstraint) =>
-            recorderConstraint.Subject.GetLastMessage();
+            recorderConstraint.Subject.LastOrDefault();
 
         /// <summary>
         /// Extracts the last recorded message
@@ -71,14 +71,7 @@ this Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayloa
             var constraint = await assertionTask;
             return constraint.Subject.LastOrDefault();
         }
-
-        /// <summary>
-        /// Extracts the recorded messages
-        /// </summary>
-        public static IEnumerable<TPayload> GetMessages<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
-            recorderConstraint) => recorderConstraint.Subject.GetMessages();
-
+        
         /// <summary>
         /// Extracts the recorded messages from a number of recorded notifications
         /// </summary>
@@ -88,13 +81,12 @@ public static IEnumerable<TPayload> GetMessages<TPayload>(
             .Select(recorded => recorded.Value.Value);
 
         /// <summary>
-        /// Extracts the recorded messages from a number od recorded notifications
+        /// Extracts the last recorded message from a number of recorded notifications
         /// </summary>
         public static TPayload GetLastMessage<TPayload>(
             this IEnumerable<Recorded<Notification<TPayload>>> recordedNotifications) =>
             recordedNotifications.GetMessages().LastOrDefault();
-
-
+        
         /// <summary>
         /// Clears the recorded notifications on the underlying <see cref="FluentTestObserver{TPayload}"/>
         /// </summary>
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 7f103a9a..426df661 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -261,7 +261,8 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             var messagesMonitor = observable1.Observe();
             var joinedMonitor = observable2.Observe();
 
-            messagesMonitor.Should().Push(1).GetLastMessage().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+            await messagesMonitor.Should().PushAsync(1);
+            messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             var response = await ChatClient.AddMessageAsync(message1);

From e3606c27134c74c25356a6e4ccd5b6b9a4f47882 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 11:16:35 +0200
Subject: [PATCH 248/455] fix Assertion messages, add doc comments

---
 .../ObservableAssertions.cs                   | 27 +++++++++++++------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index fd266d0b..e6e86fb3 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -26,11 +26,15 @@ protected internal ObservableAssertions(FluentTestObserver<TPayload> observer):
         }
 
         protected override string Identifier => "Subscription";
-        
+
         /// <summary>
         /// Asserts that at least <paramref name="numberOfNotifications"/> notifications were pushed to the <see cref="FluentTestObserver{TPayload}"/> within the specified <paramref name="timeout"/>.<br />
-        /// This includes any previously recorded notifications since it has been created or cleared. 
-        /// </summary>
+        /// This includes any previously recorded notifications since it has been created or cleared.
+        /// </summary> 
+        /// <param name="numberOfNotifications">the number of notifications the observer should have recorded by now</param>
+        /// <param name="timeout">the maximum time to wait for the notifications to arrive</param>
+        /// <param name="because"></param>
+        /// <param name="becauseArgs"></param>
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
@@ -52,13 +56,15 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
             {
                 Execute.Assertion
                     .BecauseOf(because, becauseArgs)
-                    .FailWith("Expected {context} to push at least one notification, but failed with exception {1}.", timeout, e);
+                    .FailWith("Expected {context} to push at least {0} notification{1}, but failed with exception {2}.",
+                        numberOfNotifications, numberOfNotifications == 1 ? "" : "s", e);
             }
             
             Execute.Assertion
                 .ForCondition(notifications.Any())
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to push at least one notification within {0}{reason}, but it did not.", timeout);
+                .FailWith("Expected {context} to push at least {0} notification{1} within {2}{reason}, but it did not.",
+                    numberOfNotifications, numberOfNotifications == 1 ? "" : "s", timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
@@ -84,13 +90,15 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
             {
                 Execute.Assertion
                     .BecauseOf(because, becauseArgs)
-                    .FailWith("Expected {context} to push at least one notification, but failed with exception {1}.", timeout, e);
+                    .FailWith("Expected {context} to push at least {0} notification{1}, but failed with exception {2}.",
+                        numberOfNotifications, numberOfNotifications == 1 ? "" : "s", e);
             }
-            
+
             Execute.Assertion
                 .ForCondition(notifications.Any())
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to push at least one notification within {0}{reason}, but it did not.", timeout);
+                .FailWith("Expected {context} to push at least {0} notification{1} within {2}{reason}, but it did not.",
+                    numberOfNotifications, numberOfNotifications == 1 ? "" : "s", timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
@@ -99,6 +107,9 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
         /// Asserts that at least <paramref name="numberOfNotifications"/> notifications are pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
+        /// <param name="numberOfNotifications">the number of notifications the observer should have recorded by now</param>
+        /// <param name="because"></param>
+        /// <param name="becauseArgs"></param>
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
             => Push(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
 

From 014551454a7157182fe82a8b700c48c2117776d1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 11:48:38 +0200
Subject: [PATCH 249/455] optimize assertion message for push assertions

---
 .../ObservableAssertions.cs                   | 38 +++++++++----------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index e6e86fb3..6fb4c5f5 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -38,7 +38,10 @@ protected internal ObservableAssertions(FluentTestObserver<TPayload> observer):
         public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
-            IEnumerable<TPayload> notifications = new List<TPayload>();
+            IList<TPayload> notifications = new List<TPayload>();
+            var assertion = Execute.Assertion
+                .WithExpectation($"Expected {{context}} to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
+                .BecauseOf(because, becauseArgs);
 
             try
             {
@@ -54,17 +57,12 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
             }
             catch (Exception e)
             {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .FailWith("Expected {context} to push at least {0} notification{1}, but failed with exception {2}.",
-                        numberOfNotifications, numberOfNotifications == 1 ? "" : "s", e);
+                assertion.FailWith("but failed with exception {0}.", e);
             }
-            
-            Execute.Assertion
-                .ForCondition(notifications.Any())
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to push at least {0} notification{1} within {2}{reason}, but it did not.",
-                    numberOfNotifications, numberOfNotifications == 1 ? "" : "s", timeout);
+
+            assertion
+                .ForCondition(notifications.Count < numberOfNotifications)
+                .FailWith("but {0} were received.", numberOfNotifications);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
@@ -73,7 +71,10 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
         public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
-            IEnumerable<TPayload> notifications = new List<TPayload>();
+            IList<TPayload> notifications = new List<TPayload>();
+            var assertion = Execute.Assertion
+                .WithExpectation($"Expected {{context}} to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
+                .BecauseOf(because, becauseArgs);
 
             try
             {
@@ -88,17 +89,12 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
             }
             catch (Exception e)
             {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .FailWith("Expected {context} to push at least {0} notification{1}, but failed with exception {2}.",
-                        numberOfNotifications, numberOfNotifications == 1 ? "" : "s", e);
+                assertion.FailWith("but failed with exception {0}.", e);
             }
 
-            Execute.Assertion
-                .ForCondition(notifications.Any())
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to push at least {0} notification{1} within {2}{reason}, but it did not.",
-                    numberOfNotifications, numberOfNotifications == 1 ? "" : "s", timeout);
+            assertion
+                .ForCondition(notifications.Count < numberOfNotifications)
+                .FailWith("but {0} were received.", numberOfNotifications);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }

From c8f257084a78d9381c789e39e529dddf9afd911e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 11:53:12 +0200
Subject: [PATCH 250/455] fix assertion message again

---
 .../FluentAssertions.Reactive/ObservableAssertions.cs     | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index 6fb4c5f5..c65d4f79 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -57,12 +57,12 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
             }
             catch (Exception e)
             {
-                assertion.FailWith("but failed with exception {0}.", e);
+                assertion.FailWith("but it failed with exception {0}.", e);
             }
 
             assertion
                 .ForCondition(notifications.Count < numberOfNotifications)
-                .FailWith("but {0} were received.", numberOfNotifications);
+                .FailWith("but {0} were received.", notifications.Count);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
@@ -89,12 +89,12 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
             }
             catch (Exception e)
             {
-                assertion.FailWith("but failed with exception {0}.", e);
+                assertion.FailWith("but it failed with exception {0}.", e);
             }
 
             assertion
                 .ForCondition(notifications.Count < numberOfNotifications)
-                .FailWith("but {0} were received.", numberOfNotifications);
+                .FailWith("but {0} were received.", notifications.Count);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }

From b19f627af1796ee6d9c1661774396f54752eb7ea Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 11:54:22 +0200
Subject: [PATCH 251/455] and again

---
 .../FluentAssertions.Reactive/ObservableAssertions.cs         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index c65d4f79..6f69fa1f 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -62,7 +62,7 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
 
             assertion
                 .ForCondition(notifications.Count < numberOfNotifications)
-                .FailWith("but {0} were received.", notifications.Count);
+                .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
@@ -94,7 +94,7 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
 
             assertion
                 .ForCondition(notifications.Count < numberOfNotifications)
-                .FailWith("but {0} were received.", notifications.Count);
+                .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }

From ba7a991d4d9f6ecb77ab2ec7b7c3209f586dcbad Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 6 Apr 2020 11:56:31 +0200
Subject: [PATCH 252/455] fix condition

---
 .../FluentAssertions.Reactive/ObservableAssertions.cs         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
index 6f69fa1f..c30f986c 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
@@ -61,7 +61,7 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
             }
 
             assertion
-                .ForCondition(notifications.Count < numberOfNotifications)
+                .ForCondition(notifications.Count >= numberOfNotifications)
                 .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
@@ -93,7 +93,7 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
             }
 
             assertion
-                .ForCondition(notifications.Count < numberOfNotifications)
+                .ForCondition(notifications.Count >= numberOfNotifications)
                 .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
 
             return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);

From feb236205ac7ceec465087e9eeca5da7c2b6f67e Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 9 Apr 2020 22:52:58 +0200
Subject: [PATCH 253/455] update reactive assertions

---
 .../FluentTestObserver.cs                     |  62 ++++--
 ...bleAssertions.cs => ReactiveAssertions.cs} | 196 ++++++++++--------
 ...bleExtensions.cs => ReactiveExtensions.cs} |  27 ++-
 .../RollingReplaySubject.cs                   |   2 +-
 4 files changed, 181 insertions(+), 106 deletions(-)
 rename tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/{ObservableAssertions.cs => ReactiveAssertions.cs} (54%)
 rename tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/{ObservableExtensions.cs => ReactiveExtensions.cs} (69%)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
index 521af220..a9350130 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
@@ -1,10 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
+using System.Linq;
 using System.Reactive;
 using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
-using System.Threading;
 using Microsoft.Reactive.Testing;
 
 namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
@@ -16,7 +16,7 @@ namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
     public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
     {
         private readonly IDisposable _subscription;
-        private readonly EventLoopScheduler _observeScheduler = new EventLoopScheduler();
+        private readonly IScheduler _observeScheduler;
         private readonly RollingReplaySubject<Recorded<Notification<TPayload>>> _rollingReplaySubject = new RollingReplaySubject<Recorded<Notification<TPayload>>>();
 
         /// <summary>
@@ -33,13 +33,29 @@ public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
         /// The recorded <see cref="Notification{T}"/>s
         /// </summary>
         public IEnumerable<Recorded<Notification<TPayload>>> RecordedNotifications =>
-            _rollingReplaySubject.Snapshot();
+            _rollingReplaySubject.GetSnapshot();
 
         /// <summary>
         /// The recorded messages
         /// </summary>
         public IEnumerable<TPayload> RecordedMessages =>
             RecordedNotifications.GetMessages();
+        
+        /// <summary>
+        /// The exception 
+        /// </summary>
+        public Exception Error =>
+            RecordedNotifications
+                .Where(r => r.Value.Kind == NotificationKind.OnError)
+                .Select(r => r.Value.Exception)
+                .FirstOrDefault();
+        
+        /// <summary>
+        /// The recorded messages
+        /// </summary>
+        public bool Completed =>
+            RecordedNotifications
+                .Any(r => r.Value.Kind == NotificationKind.OnCompleted);
 
         /// <summary>
         /// Creates a new <see cref="FluentTestObserver{TPayload}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
@@ -48,10 +64,30 @@ public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
         public FluentTestObserver(IObservable<TPayload> subject)
         {
             Subject = subject;
-            _observeScheduler.Schedule(() =>
-                Debug.WriteLine($"Observe scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
+            _observeScheduler = new EventLoopScheduler();
+            _subscription = new CompositeDisposable(); subject.ObserveOn(_observeScheduler).Subscribe(this);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="FluentTestObserver{TPayload}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
+        /// </summary>
+        /// <param name="subject">the <see cref="IObservable{T}"/> under test</param>
+        public FluentTestObserver(IObservable<TPayload> subject, IScheduler scheduler)
+        {
+            Subject = subject;
+            _observeScheduler = scheduler;
+            _subscription = subject.ObserveOn(scheduler).Subscribe(this);
+        }
 
-            _subscription = subject.ObserveOn(_observeScheduler).Subscribe(this);
+        /// <summary>
+        /// Creates a new <see cref="FluentTestObserver{TPayload}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
+        /// </summary>
+        /// <param name="subject">the <see cref="IObservable{T}"/> under test</param>
+        public FluentTestObserver(IObservable<TPayload> subject, TestScheduler testScheduler)
+        {
+            Subject = subject;
+            _observeScheduler = testScheduler;
+            _subscription = subject.ObserveOn(Scheduler.CurrentThread).Subscribe(this);
         }
 
         /// <summary>
@@ -60,8 +96,11 @@ public FluentTestObserver(IObservable<TPayload> subject)
         public void Clear() => _rollingReplaySubject.Clear();
 
         /// <inheritdoc />
-        public void OnNext(TPayload value) =>
-            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
+        public void OnNext(TPayload value)
+        {
+            _rollingReplaySubject.OnNext(
+                new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
+        }
 
         /// <inheritdoc />
         public void OnError(Exception exception) =>
@@ -75,14 +114,13 @@ public void OnCompleted() =>
         public void Dispose()
         {
             _subscription?.Dispose();
-            _observeScheduler.Dispose();
             _rollingReplaySubject?.Dispose();
         }
 
         /// <summary>
-        /// Returns an <see cref="ObservableAssertions{TPayload}"/> object that can be used to assert the observed <see cref="IObservable{T}"/>
+        /// Returns an <see cref="ReactiveAssertions{TPayload}"/> object that can be used to assert the observed <see cref="IObservable{T}"/>
         /// </summary>
         /// <returns></returns>
-        public ObservableAssertions<TPayload> Should() => new ObservableAssertions<TPayload>(this);
+        public ReactiveAssertions<TPayload> Should() => new ReactiveAssertions<TPayload>(this);
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveAssertions.cs
similarity index 54%
rename from tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
rename to tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveAssertions.cs
index c30f986c..b9aa410c 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableAssertions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveAssertions.cs
@@ -8,6 +8,7 @@
 using FluentAssertions;
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
+using FluentAssertions.Specialized;
 using Microsoft.Reactive.Testing;
 
 namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
@@ -16,11 +17,12 @@ namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
     /// Provides methods to assert an <see cref="IObservable{T}"/> observed by a <see cref="FluentTestObserver{TPayload}"/>
     /// </summary>
     /// <typeparam name="TPayload"></typeparam>
-    public class ObservableAssertions<TPayload> : ReferenceTypeAssertions<IObservable<TPayload>, ObservableAssertions<TPayload>>
+    public class ReactiveAssertions<TPayload> : ReferenceTypeAssertions<IObservable<TPayload>, ReactiveAssertions<TPayload>>
     {
+        private readonly IExtractExceptions extractor = new AggregateExceptionExtractor();
         public FluentTestObserver<TPayload> Observer { get; }
 
-        protected internal ObservableAssertions(FluentTestObserver<TPayload> observer): base(observer.Subject)
+        protected internal ReactiveAssertions(FluentTestObserver<TPayload> observer): base(observer.Subject)
         {
             Observer = observer;
         }
@@ -35,12 +37,12 @@ protected internal ObservableAssertions(FluentTestObserver<TPayload> observer):
         /// <param name="timeout">the maximum time to wait for the notifications to arrive</param>
         /// <param name="because"></param>
         /// <param name="becauseArgs"></param>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, TimeSpan timeout,
+        public AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
             IList<TPayload> notifications = new List<TPayload>();
             var assertion = Execute.Assertion
-                .WithExpectation($"Expected {{context}} to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
+                .WithExpectation($"Expected observable to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
                 .BecauseOf(because, becauseArgs);
 
             try
@@ -57,23 +59,25 @@ public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
             }
             catch (Exception e)
             {
-                assertion.FailWith("but it failed with exception {0}.", e);
+                if(e is AggregateException aggregateException)
+                    e = aggregateException.InnerException;
+                assertion.FailWith("but it failed with a {0}.", e);
             }
 
             assertion
                 .ForCondition(notifications.Count >= numberOfNotifications)
                 .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
 
-            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
+            return new AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
 
         /// <inheritdoc cref="Push(int,TimeSpan,string,object[])"/>
-        public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, TimeSpan timeout,
+        public async Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
             IList<TPayload> notifications = new List<TPayload>();
             var assertion = Execute.Assertion
-                .WithExpectation($"Expected {{context}} to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
+                .WithExpectation($"Expected observable to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
                 .BecauseOf(because, becauseArgs);
 
             try
@@ -89,14 +93,16 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
             }
             catch (Exception e)
             {
-                assertion.FailWith("but it failed with exception {0}.", e);
+                if (e is AggregateException aggregateException)
+                    e = aggregateException.InnerException;
+                assertion.FailWith("but it failed with a {0}.", e);
             }
 
             assertion
                 .ForCondition(notifications.Count >= numberOfNotifications)
                 .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
 
-            return new AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
+            return new AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
         }
 
         /// <summary>
@@ -106,29 +112,29 @@ public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable
         /// <param name="numberOfNotifications">the number of notifications the observer should have recorded by now</param>
         /// <param name="because"></param>
         /// <param name="becauseArgs"></param>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
+        public AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
             => Push(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
 
         /// <inheritdoc cref="Push(int,string,object[])"/>
-        public Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, string because = "", params object[] becauseArgs)
+        public Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, string because = "", params object[] becauseArgs)
             => PushAsync(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
 
         /// <summary>
         /// Asserts that at least 1 notification is pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> Push(string because = "", params object[] becauseArgs)
+        public AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> Push(string because = "", params object[] becauseArgs)
             => Push(1, TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <inheritdoc cref="Push(string,object[])"/>
-        public Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(string because = "", params object[] becauseArgs)
+        public Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(string because = "", params object[] becauseArgs)
             => PushAsync(1, TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <summary>
         /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the specified <paramref name="timeout"/>.<br />
         /// This includes any previously recorded notifications since it has been created or cleared. 
         /// </summary>
-        public AndConstraint<ObservableAssertions<TPayload>> NotPush(TimeSpan timeout,
+        public AndConstraint<ReactiveAssertions<TPayload>> NotPush(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
             bool anyNotifications = Observer.RecordedNotificationStream
@@ -141,122 +147,84 @@ public AndConstraint<ObservableAssertions<TPayload>> NotPush(TimeSpan timeout,
             Execute.Assertion
                 .ForCondition(!anyNotifications)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to not push any notifications{reason}, but it did.");
+                .FailWith("Expected observable to not push any notifications{reason}, but it did.");
             
-            return new AndConstraint<ObservableAssertions<TPayload>>(this);
+            return new AndConstraint<ReactiveAssertions<TPayload>>(this);
         }
 
         /// <summary>
         /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the next 100 milliseconds.<br />
         /// This includes any previously recorded notifications since it has been created or last cleared. 
         /// </summary>
-        public AndConstraint<ObservableAssertions<TPayload>> NotPush(string because = "", params object[] becauseArgs)
+        public AndConstraint<ReactiveAssertions<TPayload>> NotPush(string because = "", params object[] becauseArgs)
             => NotPush(TimeSpan.FromMilliseconds(100), because, becauseArgs);
 
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the specified <paramref name="timeout"/>. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
+        public ExceptionAssertions<TException> Throw<TException>(TimeSpan timeout, string because = "", params object[] becauseArgs)
+            where TException : Exception
         {
-            var exception = Observer.RecordedNotificationStream
-                .Timeout(timeout)
-                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
-                .FirstOrDefaultAsync(recorded => recorded.Value.Kind == NotificationKind.OnError)
-                .Select(recorded => recorded.Value.Exception)
-                .ToTask()
-                .ExecuteInDefaultSynchronizationContext();
-
-            Execute.Assertion
-                .ForCondition(exception != null)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to fail within {0}{reason}, but it did not.", timeout);
-            
-            return new AndWhichConstraint<ObservableAssertions<TPayload>, Exception>(this, exception);
+            var notifications = GetRecordedNotifications(timeout).ExecuteInDefaultSynchronizationContext();
+            return Throw<TException>(notifications, because, becauseArgs);
         }
 
-        /// <inheritdoc cref="Fail(TimeSpan,string,object[])"/>
-        public async Task<AndWhichConstraint<ObservableAssertions<TPayload>, Exception>> FailAsync(TimeSpan timeout,
+        /// <inheritdoc cref="Throw"/>
+        public async Task<ExceptionAssertions<TException>> ThrowAsync<TException>(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
+            where TException : Exception
         {
-            var exception = await Observer.RecordedNotificationStream
-                .Timeout(timeout)
-                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
-                .FirstOrDefaultAsync(recorded => recorded.Value.Kind == NotificationKind.OnError)
-                .Select(recorded => recorded.Value.Exception)
-                .ToTask();
-
-            Execute.Assertion
-                .ForCondition(exception != null)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to fail within {0}{reason}, but it did not.", timeout);
-
-            return new AndWhichConstraint<ObservableAssertions<TPayload>, Exception>(this, exception);
+            var notifications = await GetRecordedNotifications(timeout);
+            return Throw<TException>(notifications, because, becauseArgs);
         }
 
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the next 1 second. 
         /// </summary>
-        public AndWhichConstraint<ObservableAssertions<TPayload>, Exception> Fail(string because = "", params object[] becauseArgs)
-            => Fail(TimeSpan.FromSeconds(1), because, becauseArgs);
+        public ExceptionAssertions<TException> Throw<TException>(string because = "", params object[] becauseArgs)
+            where TException : Exception
+            => Throw<TException>(TimeSpan.FromSeconds(1), because, becauseArgs);
 
-        /// <inheritdoc cref="Fail(string,object[])"/>
-        public Task<AndWhichConstraint<ObservableAssertions<TPayload>, Exception>> FailAsync(string because = "", params object[] becauseArgs)
-            => FailAsync(TimeSpan.FromSeconds(1), because, becauseArgs);
+        /// <inheritdoc cref="Throw(string,object[])"/>
+        public Task<ExceptionAssertions<TException>> ThrowAsync<TException>(string because = "", params object[] becauseArgs)
+            where TException : Exception
+            => ThrowAsync<TException>(TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the specified <paramref name="timeout"/>. 
         /// </summary>
-        public AndConstraint<ObservableAssertions<TPayload>> Complete(TimeSpan timeout,
+        public AndConstraint<ReactiveAssertions<TPayload>> Complete(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
-            bool completed = Observer.RecordedNotificationStream
-                .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
-                .Timeout(timeout)
-                .Catch(Observable.Return(false))
-                .ToTask()
-                .ExecuteInDefaultSynchronizationContext();
-            
-            Execute.Assertion
-                .ForCondition(completed)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to complete within {0}{reason}, but it did not.", timeout);
+            var notifications = GetRecordedNotifications(timeout).ExecuteInDefaultSynchronizationContext();
 
-            return new AndConstraint<ObservableAssertions<TPayload>>(this);
+            return Complete(timeout, because, becauseArgs, notifications);
         }
 
+
         /// <inheritdoc cref="Complete(System.TimeSpan,string,object[])"/>
-        public async Task<AndConstraint<ObservableAssertions<TPayload>>> CompleteAsync(TimeSpan timeout,
+        public async Task<AndConstraint<ReactiveAssertions<TPayload>>> CompleteAsync(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
-            bool completed = await Observer.RecordedNotificationStream
-                .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
-                .Timeout(timeout)
-                .Catch(Observable.Return(false))
-                .ToTask();
+            var notifications = await GetRecordedNotifications(timeout);
 
-            Execute.Assertion
-                .ForCondition(completed)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to complete within {0}{reason}, but it did not.", timeout);
-
-            return new AndConstraint<ObservableAssertions<TPayload>>(this);
+            return Complete(timeout, because, becauseArgs, notifications);
         }
 
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the next 1 second. 
         /// </summary>
-        public AndConstraint<ObservableAssertions<TPayload>> Complete(string because = "", params object[] becauseArgs)
+        public AndConstraint<ReactiveAssertions<TPayload>> Complete(string because = "", params object[] becauseArgs)
             => Complete(TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <inheritdoc cref="Complete(string,object[])"/>
-        public Task<AndConstraint<ObservableAssertions<TPayload>>> CompleteAsync(string because = "", params object[] becauseArgs)
+        public Task<AndConstraint<ReactiveAssertions<TPayload>>> CompleteAsync(string because = "", params object[] becauseArgs)
             => CompleteAsync(TimeSpan.FromSeconds(1), because, becauseArgs);
 
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the specified <paramref name="timeout"/>. 
         /// </summary>
-        public AndConstraint<ObservableAssertions<TPayload>> NotComplete(TimeSpan timeout,
+        public AndConstraint<ReactiveAssertions<TPayload>> NotComplete(TimeSpan timeout,
             string because = "", params object[] becauseArgs)
         {
             bool completed = Observer.RecordedNotificationStream
@@ -269,15 +237,73 @@ public AndConstraint<ObservableAssertions<TPayload>> NotComplete(TimeSpan timeou
             Execute.Assertion
                 .ForCondition(!completed)
                 .BecauseOf(because, becauseArgs)
-                .FailWith("Expected {context} to not complete{reason}, but it did.");
+                .FailWith("Expected observable to not complete{reason}, but it did.");
             
-            return new AndConstraint<ObservableAssertions<TPayload>>(this);
+            return new AndConstraint<ReactiveAssertions<TPayload>>(this);
         }
 
         /// <summary>
         /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the next 100 milliseconds. 
         /// </summary>
-        public AndConstraint<ObservableAssertions<TPayload>> NotComplete(string because = "", params object[] becauseArgs)
+        public AndConstraint<ReactiveAssertions<TPayload>> NotComplete(string because = "", params object[] becauseArgs)
             => NotComplete(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+
+        protected Task<IList<Recorded<Notification<TPayload>>>> GetRecordedNotifications(TimeSpan timeout) =>
+            Observer.RecordedNotificationStream
+                .TakeUntil(recorded => recorded.Value.Kind == NotificationKind.OnError)
+                .TakeUntil(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
+                .Timeout(timeout)
+                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
+                .ToList()
+                .ToTask();
+
+        protected ExceptionAssertions<TException> Throw<TException>(IList<Recorded<Notification<TPayload>>> notifications, string because, object[] becauseArgs)
+            where TException : Exception
+        {
+            var exception = notifications
+                .Where(r => r.Value.Kind == NotificationKind.OnError)
+                .Select(r => r.Value.Exception)
+                .FirstOrDefault();
+
+            TException[] expectedExceptions = extractor.OfType<TException>(exception).ToArray();
+
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
+                .WithExpectation("Expected observable to throw a <{0}>{reason}, ", typeof(TException))
+                .ForCondition(exception != null)
+                .FailWith("but no exception was thrown.")
+                .Then
+                .ForCondition(expectedExceptions.Any())
+                .FailWith("but found <{0}>: {1}{2}.",
+                    exception?.GetType(),
+                    Environment.NewLine,
+                    exception)
+                .Then
+                .ClearExpectation();
+
+            return new ExceptionAssertions<TException>(expectedExceptions);
+        }
+
+        protected AndConstraint<ReactiveAssertions<TPayload>> Complete(TimeSpan timeout, string because, object[] becauseArgs, IList<Recorded<Notification<TPayload>>> notifications)
+        {
+            var exception = notifications
+                .Where(r => r.Value.Kind == NotificationKind.OnError)
+                .Select(r => r.Value.Exception)
+                .FirstOrDefault();
+
+            Execute.Assertion
+                .WithExpectation("Expected observable to complete within {0}{reason}, ", timeout)
+                .BecauseOf(because, becauseArgs)
+                .ForCondition(exception is null)
+                .FailWith("but it failed with <{0}>: {1}{2}.",
+                    exception?.GetType(),
+                    Environment.NewLine,
+                    exception)
+                .Then
+                .ForCondition(notifications.Any(r => r.Value.Kind == NotificationKind.OnCompleted))
+                .FailWith("but it did not.");
+
+            return new AndConstraint<ReactiveAssertions<TPayload>>(this);
+        }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveExtensions.cs
similarity index 69%
rename from tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
rename to tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveExtensions.cs
index a9dfce46..8894ab99 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ObservableExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveExtensions.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reactive;
+using System.Reactive.Concurrency;
 using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Execution;
@@ -10,18 +11,28 @@
 
 namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
 {
-    public static class ObservableExtensions
+    public static class ReactiveExtensions
     {
         /// <summary>
         /// Create a new <see cref="FluentTestObserver{TPayload}"/> subscribed to this <paramref name="observable"/>
         /// </summary>
         public static FluentTestObserver<T> Observe<T>(this IObservable<T> observable) => new FluentTestObserver<T>(observable);
 
+        /// <summary>
+        /// Create a new <see cref="FluentTestObserver{TPayload}"/> subscribed to this <paramref name="observable"/>
+        /// </summary>
+        public static FluentTestObserver<T> Observe<T>(this IObservable<T> observable, IScheduler scheduler) => new FluentTestObserver<T>(observable, scheduler);
+
+        /// <summary>
+        /// Create a new <see cref="FluentTestObserver{TPayload}"/> subscribed to this <paramref name="observable"/>
+        /// </summary>
+        public static FluentTestObserver<T> Observe<T>(this IObservable<T> observable, TestScheduler scheduler) => new FluentTestObserver<T>(observable, scheduler);
+
         /// <summary>
         /// Asserts that the recorded messages contain at lease one item which matches the <paramref name="predicate"/>
         /// </summary>
-        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> WithMessage<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
+        public static AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> WithMessage<TPayload>(
+            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
         {
             if (predicate is null) throw new ArgumentNullException(nameof(predicate));
             
@@ -38,8 +49,8 @@ public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPa
         /// <summary>
         /// Asserts that the last recorded message matches the <paramref name="predicate"/>
         /// </summary>
-        public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> WithLastMessage<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
+        public static AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> WithLastMessage<TPayload>(
+            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
         {
             if (predicate is null)
                 throw new ArgumentNullException(nameof(predicate));
@@ -57,7 +68,7 @@ public static AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPa
         /// Extracts the last recorded message
         /// </summary>
         public static TPayload GetLastMessage<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
+            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>
                 recorderConstraint) =>
             recorderConstraint.Subject.LastOrDefault();
 
@@ -65,7 +76,7 @@ this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>
         /// Extracts the last recorded message
         /// </summary>
         public static async Task<TPayload> GetLastMessageAsync<TPayload>(
-            this Task<AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<TPayload>>>
+            this Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>>
                 assertionTask)
         {
             var constraint = await assertionTask;
@@ -91,7 +102,7 @@ public static TPayload GetLastMessage<TPayload>(
         /// Clears the recorded notifications on the underlying <see cref="FluentTestObserver{TPayload}"/>
         /// </summary>
         public static void Clear<TPayload>(
-            this AndWhichConstraint<ObservableAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
+            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
                 recorderConstraint) => recorderConstraint.And.Observer.Clear();
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
index eef1d294..df779dad 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
@@ -45,7 +45,7 @@ public void OnCompleted()
 
         public IDisposable Subscribe(IObserver<T> observer) => _concatenatedSubjects.Subscribe(observer);
 
-        public IEnumerable<T> Snapshot()
+        public IEnumerable<T> GetSnapshot()
         {
             var snapshot = new List<T>();
             using (this.Subscribe(item => snapshot.Add(item)))

From ccdf82d0a13a75fe13d5b918f817e8b65aeafea4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 9 Apr 2020 23:53:47 +0200
Subject: [PATCH 254/455] fix bug in FluentTestObserver

---
 .../FluentAssertions.Reactive/FluentTestObserver.cs    | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
index a9350130..5b494159 100644
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
+++ b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Reactive;
 using System.Reactive.Concurrency;
@@ -65,7 +66,7 @@ public FluentTestObserver(IObservable<TPayload> subject)
         {
             Subject = subject;
             _observeScheduler = new EventLoopScheduler();
-            _subscription = new CompositeDisposable(); subject.ObserveOn(_observeScheduler).Subscribe(this);
+            _subscription = subject.ObserveOn(_observeScheduler).Subscribe(this);
         }
 
         /// <summary>
@@ -96,11 +97,8 @@ public FluentTestObserver(IObservable<TPayload> subject, TestScheduler testSched
         public void Clear() => _rollingReplaySubject.Clear();
 
         /// <inheritdoc />
-        public void OnNext(TPayload value)
-        {
-            _rollingReplaySubject.OnNext(
-                new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
-        }
+        public void OnNext(TPayload value) =>
+            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
 
         /// <inheritdoc />
         public void OnError(Exception exception) =>

From d1950f8d855267fca74746d566cf3f9f994024fc Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 16 Apr 2020 21:06:50 +0200
Subject: [PATCH 255/455] fix for issue #87

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 72b4b907..2a3ebed2 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -129,11 +129,9 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TRes
             var preprocessedRequest = await Options.PreprocessRequest(request, this);
             using var httpRequestMessage = GenerateHttpRequestMessage(preprocessedRequest);
             using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, cancellationToken);
-            if (!httpResponseMessage.IsSuccessStatusCode)
-            {
-                throw new GraphQLHttpException(httpResponseMessage);
-            }
 
+            httpResponseMessage.EnsureSuccessStatusCode();
+            
             var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
             var response = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
             return response.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);

From 94213e53a3aec013e53f1b13216eec6891691124 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 16 Apr 2020 22:39:46 +0200
Subject: [PATCH 256/455] remove orphaned file

---
 .../Websocket/IGraphQLWebSocketJsonSerializer.cs             | 5 -----
 1 file changed, 5 deletions(-)
 delete mode 100644 src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs

diff --git a/src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs b/src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs
deleted file mode 100644
index 5f89191d..00000000
--- a/src/GraphQL.Client.Http/Websocket/IGraphQLWebSocketJsonSerializer.cs
+++ /dev/null
@@ -1,5 +0,0 @@
-namespace GraphQL.Client.Http.Websocket {
-	public interface IGraphQLWebSocketJsonSerializer: IGraphQLJsonSerializer {
-		GraphQLWebSocketResponse<TResponse> DeserializeWebSocketResponse<TResponse>(byte[] utf8bytes);
-	}
-}

From e5b12e732a70f1a893a120c481e99bb9078c134f Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 16 Apr 2020 23:10:16 +0200
Subject: [PATCH 257/455] include --tags switch on git fetch in github actions

---
 .github/workflows/branches-ubuntu.yml | 4 ++--
 .github/workflows/main-ubuntu.yml     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index 1743235f..ae41f4d6 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -19,8 +19,8 @@ jobs:
         fetch-depth: 0
     - name: Restore dotnet tools
       run: dotnet tool restore
-    - name: Fetch complete repository 
-      run: git fetch
+    - name: Fetch complete repository including tags
+      run: git fetch --tags && git describe
     - name: Generate version info from git history
       run: dotnet gitversion /output json > gitversion.json
     - name: Upload version info file
diff --git a/.github/workflows/main-ubuntu.yml b/.github/workflows/main-ubuntu.yml
index a0d006b7..82707e71 100644
--- a/.github/workflows/main-ubuntu.yml
+++ b/.github/workflows/main-ubuntu.yml
@@ -23,8 +23,8 @@ jobs:
         fetch-depth: 0
     - name: Restore dotnet tools
       run: dotnet tool restore
-    - name: Fetch complete repository 
-      run: git fetch
+    - name: Fetch complete repository including tags
+      run: git fetch --tags && git describe
     - name: Generate version info from git history
       run: dotnet gitversion /output json > gitversion.json
     - name: Upload version info file

From 32d9e4733192384bc7da1ba237d3718e2aa4aac9 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 16 Apr 2020 23:16:49 +0200
Subject: [PATCH 258/455] use --tags --force --prune

---
 .github/workflows/branches-ubuntu.yml | 2 +-
 .github/workflows/main-ubuntu.yml     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches-ubuntu.yml
index ae41f4d6..72864b9f 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches-ubuntu.yml
@@ -20,7 +20,7 @@ jobs:
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository including tags
-      run: git fetch --tags && git describe
+      run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
       run: dotnet gitversion /output json > gitversion.json
     - name: Upload version info file
diff --git a/.github/workflows/main-ubuntu.yml b/.github/workflows/main-ubuntu.yml
index 82707e71..82d24f1e 100644
--- a/.github/workflows/main-ubuntu.yml
+++ b/.github/workflows/main-ubuntu.yml
@@ -24,7 +24,7 @@ jobs:
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository including tags
-      run: git fetch --tags && git describe
+      run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
       run: dotnet gitversion /output json > gitversion.json
     - name: Upload version info file

From f1c05d7a6b5a6b015be9bedae437ffb3de7dacb2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sat, 18 Apr 2020 12:36:51 +0200
Subject: [PATCH 259/455] remove windows workflows, adapt to mainline
 development

---
 .github/workflows/branches-windows.yml        | 78 ---------------
 .../{branches-ubuntu.yml => branches.yml}     |  5 +-
 .github/workflows/main-windows.yml            | 98 -------------------
 .../workflows/{main-ubuntu.yml => master.yml} |  4 +-
 GitVersion.yml                                |  2 +-
 5 files changed, 6 insertions(+), 181 deletions(-)
 delete mode 100644 .github/workflows/branches-windows.yml
 rename .github/workflows/{branches-ubuntu.yml => branches.yml} (97%)
 delete mode 100644 .github/workflows/main-windows.yml
 rename .github/workflows/{main-ubuntu.yml => master.yml} (98%)

diff --git a/.github/workflows/branches-windows.yml b/.github/workflows/branches-windows.yml
deleted file mode 100644
index fdf2b81c..00000000
--- a/.github/workflows/branches-windows.yml
+++ /dev/null
@@ -1,78 +0,0 @@
-name: Branch workflow
-on: 
-  push:
-    branches-ignore:
-      - '**'
-jobs:
-  generateVersionInfo:  
-    name: GenerateVersionInfo
-    runs-on: windows-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - name: Restore dotnet tools
-      run: dotnet tool restore
-    - name: Fetch complete repository 
-      run: git fetch
-    - name: Generate version info from git history
-      run: dotnet dotnet-gitversion /output json | Out-File gitversion.json; Get-Content gitversion.json
-    - name: Upload version info file
-      uses: actions/upload-artifact@v1
-      with:
-        name: gitversion
-        path: gitversion.json
-
-  build:
-    name: Build
-    needs: generateVersionInfo
-    runs-on: windows-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - name: Download version info file
-      uses: actions/download-artifact@v1
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }; $env:GitVersion_SemVer
-    - name: Build solution
-      run: dotnet build -c Release
-    - name: Create NuGet packages
-      run: dotnet pack -c Release --no-build -o nupkg 
-    - name: Upload nuget packages
-      uses: actions/upload-artifact@v1
-      with:
-        name: nupkg
-        path: nupkg
-
-  test:
-    name: Test
-    needs: [build, generateVersionInfo]
-    runs-on: windows-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - name: Download version info file
-      uses: actions/download-artifact@v1
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
-    - name: Run tests
-      run: dotnet test -c Release -p:ParallelizeTestCollections=false
diff --git a/.github/workflows/branches-ubuntu.yml b/.github/workflows/branches.yml
similarity index 97%
rename from .github/workflows/branches-ubuntu.yml
rename to .github/workflows/branches.yml
index 72864b9f..8cbec3af 100644
--- a/.github/workflows/branches-ubuntu.yml
+++ b/.github/workflows/branches.yml
@@ -1,10 +1,11 @@
-name: Branch workflow (Ubuntu)
+name: Branch workflow
 on: 
   push:
     branches-ignore:
-      - develop
+      - master
       - 'release/**'
       - 'releases/**'
+  pull_request:
 env:
   DOTNET_CLI_TELEMETRY_OPTOUT: true  
   MSBUILDSINGLELOADCONTEXT: 1
diff --git a/.github/workflows/main-windows.yml b/.github/workflows/main-windows.yml
deleted file mode 100644
index 8ab30600..00000000
--- a/.github/workflows/main-windows.yml
+++ /dev/null
@@ -1,98 +0,0 @@
-name: Main workflow
-on:
-  push:
-    branches-ignore:
-      - '**'
-jobs:
-  generateVersionInfo:  
-    name: GenerateVersionInfo
-    runs-on: windows-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-      with:
-        fetch-depth: 0
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - name: Restore dotnet tools
-      run: dotnet tool restore
-    - name: Fetch complete repository 
-      run: git fetch
-    - name: Generate version info from git history
-      run: dotnet dotnet-gitversion /output json | Out-File gitversion.json; Get-Content gitversion.json
-      env:
-        IGNORE_NORMALISATION_GIT_HEAD_MOVE: 1
-    - name: Upload version info file
-      uses: actions/upload-artifact@v1
-      with:
-        name: gitversion
-        path: gitversion.json
-
-  build:
-    name: Build
-    needs: generateVersionInfo
-    runs-on: windows-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - name: Download version info file
-      uses: actions/download-artifact@v1
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }; $env:GitVersion_SemVer
-    - name: Build solution
-      run: dotnet build -c Release
-    - name: Create NuGet packages
-      run: dotnet pack -c Release --no-build -o nupkg 
-    - name: Upload nuget packages
-      uses: actions/upload-artifact@v1
-      with:
-        name: nupkg
-        path: nupkg
-
-  test:
-    name: Test
-    needs: [build, generateVersionInfo]
-    runs-on: windows-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Setup dotnet environment
-      uses: actions/setup-dotnet@master
-      with:
-        dotnet-version: '3.1.100'
-    - name: Download version info file
-      uses: actions/download-artifact@v1
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: Get-Content gitversion.json | ConvertFrom-Json | ForEach-Object { foreach ($item in $_.PSObject.properties) { "::set-env name=GitVersion_$($item.Name)::$($item.Value)" } }
-    - name: Run tests
-      run: dotnet test -c Release -p:ParallelizeTestCollections=false
-
-  publish:
-    name: Publish
-    needs: [test]
-    runs-on: windows-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-    - name: Download nuget packages
-      uses: actions/download-artifact@v1
-      with:
-        name: nupkg
-    - name: Setup Nuget.exe
-      uses: warrenbuckley/Setup-Nuget@v1
-    - name: Configure package source
-      run: nuget sources Add -Name "GPR" -Source https://nuget.pkg.github.com/graphql-dotnet/index.json -UserName graphql-dotnet -Password ${{secrets.GITHUB_TOKEN}}
-    - name: push packages
-      run: nuget push .\nupkg\*.nupkg -SkipDuplicate -Source "GPR"
diff --git a/.github/workflows/main-ubuntu.yml b/.github/workflows/master.yml
similarity index 98%
rename from .github/workflows/main-ubuntu.yml
rename to .github/workflows/master.yml
index 82d24f1e..ad8b79a5 100644
--- a/.github/workflows/main-ubuntu.yml
+++ b/.github/workflows/master.yml
@@ -1,8 +1,8 @@
-name: Main workflow (Ubuntu)
+name: Master workflow
 on: 
   push:
     branches:
-      - develop
+      - master
       - 'release/**'
       - 'releases/**'
     tags:        
diff --git a/GitVersion.yml b/GitVersion.yml
index 2210324b..0093d88e 100644
--- a/GitVersion.yml
+++ b/GitVersion.yml
@@ -1 +1 @@
-mode: ContinuousDeployment
+mode: Mainline

From 8a45417c421717220d6dcc2c90074b0d3cd75d20 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sat, 18 Apr 2020 12:47:47 +0200
Subject: [PATCH 260/455] output generatet verions info to build log

---
 .github/workflows/branches.yml | 2 +-
 .github/workflows/master.yml   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 8cbec3af..2db62d5a 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -23,7 +23,7 @@ jobs:
     - name: Fetch complete repository including tags
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
-      run: dotnet gitversion /output json > gitversion.json
+      run: dotnet gitversion /output json > gitversion.json && cat gitversion.json
     - name: Upload version info file
       uses: actions/upload-artifact@v1
       with:
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index ad8b79a5..e7e29460 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -26,7 +26,7 @@ jobs:
     - name: Fetch complete repository including tags
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
-      run: dotnet gitversion /output json > gitversion.json
+      run: dotnet gitversion /output json > gitversion.json && cat gitversion.json
     - name: Upload version info file
       uses: actions/upload-artifact@v1
       with:

From c5624303bfec2571ad5e1f2188567fbf0e4899e8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sat, 18 Apr 2020 11:22:50 +0200
Subject: [PATCH 261/455] throw custom exception on bad status code

---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 23 +++++++++---
 src/GraphQL.Client/GraphQLHttpException.cs    | 29 ---------------
 .../GraphQLHttpRequestException.cs            | 37 +++++++++++++++++++
 3 files changed, 54 insertions(+), 35 deletions(-)
 delete mode 100644 src/GraphQL.Client/GraphQLHttpException.cs
 create mode 100644 src/GraphQL.Client/GraphQLHttpRequestException.cs

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 2a3ebed2..53d2a1d9 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.IO;
 using System.Net.Http;
 using System.Text;
 using System.Threading;
@@ -128,13 +129,23 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TRes
         {
             var preprocessedRequest = await Options.PreprocessRequest(request, this);
             using var httpRequestMessage = GenerateHttpRequestMessage(preprocessedRequest);
-            using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, cancellationToken);
+            using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
 
-            httpResponseMessage.EnsureSuccessStatusCode();
-            
-            var bodyStream = await httpResponseMessage.Content.ReadAsStreamAsync();
-            var response = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(bodyStream, cancellationToken);
-            return response.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
+            var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync();
+
+            if (httpResponseMessage.IsSuccessStatusCode)
+            {
+                var graphQLResponse = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(contentStream, cancellationToken);
+                return graphQLResponse.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
+            }
+
+            // error handling
+            string content = null;
+            if (contentStream != null)
+                using (var sr = new StreamReader(contentStream))
+                    content = await sr.ReadToEndAsync();
+
+            throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
         }
 
         private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request)
diff --git a/src/GraphQL.Client/GraphQLHttpException.cs b/src/GraphQL.Client/GraphQLHttpException.cs
deleted file mode 100644
index d30bd759..00000000
--- a/src/GraphQL.Client/GraphQLHttpException.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System;
-using System.Net.Http;
-
-namespace GraphQL.Client.Http
-{
-
-    /// <summary>
-    /// An exception thrown on unexpected <see cref="System.Net.Http.HttpResponseMessage"/>
-    /// </summary>
-    public class GraphQLHttpException : Exception
-    {
-
-        /// <summary>
-        /// The <see cref="System.Net.Http.HttpResponseMessage"/>
-        /// </summary>
-        public HttpResponseMessage HttpResponseMessage { get; }
-
-        /// <summary>
-        /// Creates a new instance of <see cref="GraphQLHttpException"/>
-        /// </summary>
-        /// <param name="httpResponseMessage">The unexpected <see cref="System.Net.Http.HttpResponseMessage"/></param>
-        public GraphQLHttpException(HttpResponseMessage httpResponseMessage) : base($"Unexpected {nameof(System.Net.Http.HttpResponseMessage)} with code: {httpResponseMessage?.StatusCode}")
-        {
-            HttpResponseMessage = httpResponseMessage ?? throw new ArgumentNullException(nameof(httpResponseMessage));
-        }
-
-    }
-
-}
diff --git a/src/GraphQL.Client/GraphQLHttpRequestException.cs b/src/GraphQL.Client/GraphQLHttpRequestException.cs
new file mode 100644
index 00000000..c63f8646
--- /dev/null
+++ b/src/GraphQL.Client/GraphQLHttpRequestException.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+
+namespace GraphQL.Client.Http
+{
+
+    /// <summary>
+    /// An exception thrown on unexpected <see cref="System.Net.Http.HttpResponseMessage"/>
+    /// </summary>
+    public class GraphQLHttpRequestException : Exception
+    {
+        /// <summary>
+        /// The <see cref="System.Net.Http.HttpResponseMessage"/>
+        /// </summary>
+        public HttpStatusCode StatusCode { get; }
+
+        public HttpResponseHeaders ResponseHeaders { get; }
+
+        public string? Content { get; }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="GraphQLHttpRequestException"/>
+        /// </summary>
+        /// <param name="statusCode"></param>
+        /// <param name="responseHeaders"></param>
+        /// <param name="content"></param>
+        public GraphQLHttpRequestException(HttpStatusCode statusCode, HttpResponseHeaders responseHeaders, string? content) : base($"The HTTP request failed with status code {statusCode}")
+        {
+            StatusCode = statusCode;
+            ResponseHeaders = responseHeaders;
+            Content = content;
+        }
+    }
+
+}

From e7720c39f321eedd378214c32bc271daac601a88 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sat, 18 Apr 2020 11:49:27 +0200
Subject: [PATCH 262/455] create HttpRequestMessage in virtual member of
 GraphQLHttpRequest

---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 22 +++++-----------
 src/GraphQL.Client/GraphQLHttpRequest.cs      | 25 +++++++++++++++++++
 .../GraphQLHttpRequestException.cs            |  8 +++++-
 3 files changed, 38 insertions(+), 17 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 53d2a1d9..20ba2320 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -3,7 +3,6 @@
 using System.Diagnostics;
 using System.IO;
 using System.Net.Http;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
@@ -128,7 +127,11 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var preprocessedRequest = await Options.PreprocessRequest(request, this);
-            using var httpRequestMessage = GenerateHttpRequestMessage(preprocessedRequest);
+
+            if(!(preprocessedRequest is GraphQLHttpRequest graphQLHttpRequest))
+                graphQLHttpRequest = new GraphQLHttpRequest(preprocessedRequest);
+
+            using var httpRequestMessage = graphQLHttpRequest.ToHttpRequestMessage(Options, JsonSerializer);
             using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
 
             var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync();
@@ -148,22 +151,9 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TRes
             throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
         }
 
-        private HttpRequestMessage GenerateHttpRequestMessage(GraphQLRequest request)
-        {
-            var message = new HttpRequestMessage(HttpMethod.Post, Options.EndPoint)
-            {
-                Content = new StringContent(JsonSerializer.SerializeToString(request), Encoding.UTF8, Options.MediaType)
-            };
-
-            if (request is GraphQLHttpRequest httpRequest)
-                httpRequest.PreprocessHttpRequestMessage(message);
-
-            return message;
-        }
-
         private Uri GetWebSocketUri()
         {
-            var webSocketSchema = Options.EndPoint.Scheme == "https" ? "wss" : "ws";
+            string webSocketSchema = Options.EndPoint.Scheme == "https" ? "wss" : "ws";
             return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}");
         }
 
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index f801f9c7..ec5c5fd8 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Net.Http;
 using System.Runtime.Serialization;
+using System.Text;
+using GraphQL.Client.Abstractions;
 
 namespace GraphQL.Client.Http
 {
@@ -15,10 +17,33 @@ public GraphQLHttpRequest(string query, object? variables = null, string? operat
         {
         }
 
+        public GraphQLHttpRequest(GraphQLRequest other): base(other.Query, other.Variables, other.OperationName)
+        {
+        }
+
         /// <summary>
         /// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
         /// </summary>
         [IgnoreDataMember]
+        [Obsolete("Inherit from GraphQLHttpRequest and override ToHttpRequestMessage() to customize the HttpRequestMessage. Will be removed in v4.0.0.")]
         public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
+
+        /// <summary>
+        /// Creates a <see cref="HttpRequestMessage"/> from this <see cref="GraphQLHttpRequest"/>.
+        /// Used by <see cref="GraphQLHttpClient"/> to convert GraphQL requests when sending them as regular HTTP requests.
+        /// </summary>
+        /// <param name="options">the <see cref="GraphQLHttpClientOptions"/> passed from <see cref="GraphQLHttpClient"/></param>
+        /// <param name="serializer">the <see cref="IGraphQLJsonSerializer"/> passed from <see cref="GraphQLHttpClient"/></param>
+        /// <returns></returns>
+        public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions options, IGraphQLJsonSerializer serializer)
+        {
+            var message = new HttpRequestMessage(HttpMethod.Post, options.EndPoint)
+            {
+                Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
+            };
+
+            PreprocessHttpRequestMessage(message);
+            return message;
+        }
     }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequestException.cs b/src/GraphQL.Client/GraphQLHttpRequestException.cs
index c63f8646..3b8230ad 100644
--- a/src/GraphQL.Client/GraphQLHttpRequestException.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequestException.cs
@@ -12,12 +12,18 @@ namespace GraphQL.Client.Http
     public class GraphQLHttpRequestException : Exception
     {
         /// <summary>
-        /// The <see cref="System.Net.Http.HttpResponseMessage"/>
+        /// The returned status code
         /// </summary>
         public HttpStatusCode StatusCode { get; }
 
+        /// <summary>
+        /// the returned response headers
+        /// </summary>
         public HttpResponseHeaders ResponseHeaders { get; }
 
+        /// <summary>
+        /// the returned content
+        /// </summary>
         public string? Content { get; }
 
         /// <summary>

From 086694c433b66e620375a26d8c314a7b9b3debe2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sat, 18 Apr 2020 11:59:59 +0200
Subject: [PATCH 263/455] move conversion to GraphQLHttpRequest into
 Options.PreprocessRequest

---
 src/GraphQL.Client/GraphQLHttpClient.cs        | 7 ++-----
 src/GraphQL.Client/GraphQLHttpClientOptions.cs | 3 ++-
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 20ba2320..b2e70ed2 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -127,11 +127,8 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var preprocessedRequest = await Options.PreprocessRequest(request, this);
-
-            if(!(preprocessedRequest is GraphQLHttpRequest graphQLHttpRequest))
-                graphQLHttpRequest = new GraphQLHttpRequest(preprocessedRequest);
-
-            using var httpRequestMessage = graphQLHttpRequest.ToHttpRequestMessage(Options, JsonSerializer);
+            
+            using var httpRequestMessage = preprocessedRequest.ToHttpRequestMessage(Options, JsonSerializer);
             using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
 
             var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync();
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 6b93cb7b..8b551cf0 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -45,7 +45,8 @@ public class GraphQLHttpClientOptions
         /// <summary>
         /// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
         /// </summary>
-        public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLRequest>> PreprocessRequest { get; set; } = (request, client) => Task.FromResult(request);
+        public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLHttpRequest>> PreprocessRequest { get; set; } = (request, client) =>
+            Task.FromResult(request is GraphQLHttpRequest graphQLHttpRequest ? graphQLHttpRequest : new GraphQLHttpRequest(request));
 
         /// <summary>
         /// This callback is called after successfully establishing a websocket connection but before any regular request is made. 

From f7cda9bb4b12844c0ec80738effba3d2566268e4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Sat, 18 Apr 2020 12:12:46 +0200
Subject: [PATCH 264/455] remove unused using directive

---
 src/GraphQL.Client/GraphQLHttpRequestException.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQLHttpRequestException.cs b/src/GraphQL.Client/GraphQLHttpRequestException.cs
index 3b8230ad..2071da14 100644
--- a/src/GraphQL.Client/GraphQLHttpRequestException.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequestException.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Net;
-using System.Net.Http;
 using System.Net.Http.Headers;
 
 namespace GraphQL.Client.Http

From 7d06d2ddaccec0fb617b1e4fc49e31d18452a2fc Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 19 Apr 2020 00:16:33 +0200
Subject: [PATCH 265/455] Update
 src/GraphQL.Client/GraphQLHttpRequestException.cs

Co-Authored-By: Ivan Maximov <sungam3r@yandex.ru>
---
 src/GraphQL.Client/GraphQLHttpRequestException.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQLHttpRequestException.cs b/src/GraphQL.Client/GraphQLHttpRequestException.cs
index 2071da14..5b3a8b9f 100644
--- a/src/GraphQL.Client/GraphQLHttpRequestException.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequestException.cs
@@ -38,5 +38,4 @@ public GraphQLHttpRequestException(HttpStatusCode statusCode, HttpResponseHeader
             Content = content;
         }
     }
-
 }

From 2ecf6830cbd38752c6315f50df472386604005bf Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 19 Apr 2020 00:20:31 +0200
Subject: [PATCH 266/455] rename method

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index b2e70ed2..1777e0b5 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -73,7 +73,7 @@ public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLR
             if (Options.UseWebSocketForQueriesAndMutations)
                 return await _graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
 
-            return await SendHttpPostRequestAsync<TResponse>(request, cancellationToken);
+            return await SendHttpRequestAsync<TResponse>(request, cancellationToken);
         }
 
         /// <inheritdoc />
@@ -124,7 +124,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
         #region Private Methods
 
-        private async Task<GraphQLHttpResponse<TResponse>> SendHttpPostRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+        private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var preprocessedRequest = await Options.PreprocessRequest(request, this);
             

From 70305e3c14c3eafa68473c89e71001560b93b90a Mon Sep 17 00:00:00 2001
From: Paul Klein <paul@patriotsystems.com>
Date: Sun, 19 Apr 2020 13:59:35 +1200
Subject: [PATCH 267/455] Fix Map array deserialisation in Newtonsoft
 serialiser

Resolves graphql-dotnet/graphql-client#28
---
 src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index f15787e8..dba2a348 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -53,7 +53,7 @@ private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionar
 
         private IEnumerable<object> ReadArray(JToken element)
         {
-            foreach (var item in element.Values())
+            foreach (var item in (JArray)element)
             {
                 if (IsUnsupportedJTokenType(item.Type))
                     continue;

From 1edeae3dfac5fc59d795c6059e59bfd718d1a9ed Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 19 Apr 2020 21:36:36 +0200
Subject: [PATCH 268/455] Update
 src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs

---
 src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index dba2a348..a8c13ff7 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -51,7 +51,7 @@ private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionar
             return result;
         }
 
-        private IEnumerable<object> ReadArray(JToken element)
+        private IEnumerable<object> ReadArray(JArray element)
         {
             foreach (var item in (JArray)element)
             {

From bc098b55dfc1f6e2e6ed49960846b92f989ef3c3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 19 Apr 2020 21:36:45 +0200
Subject: [PATCH 269/455] Update
 src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs

---
 src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index a8c13ff7..c2739b41 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -53,7 +53,7 @@ private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionar
 
         private IEnumerable<object> ReadArray(JArray element)
         {
-            foreach (var item in (JArray)element)
+            foreach (var item in element)
             {
                 if (IsUnsupportedJTokenType(item.Type))
                     continue;

From 29407e0d5b38f315333644d187d103cabed01822 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 19 Apr 2020 21:53:29 +0200
Subject: [PATCH 270/455] change versioning mode to continuous deployment

---
 GitVersion.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/GitVersion.yml b/GitVersion.yml
index 0093d88e..030bf738 100644
--- a/GitVersion.yml
+++ b/GitVersion.yml
@@ -1 +1,4 @@
-mode: Mainline
+mode: ContinuousDeployment
+branches:
+  master:
+    tag: alpha

From 39908f08c457684d31188475b047385c4cca3eaf Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 20 Apr 2020 21:59:10 +0200
Subject: [PATCH 271/455] add action property to configure
 ClientWebsocketOptions to GraphQLHttpClientOptions

---
 src/GraphQL.Client/GraphQLHttpClientOptions.cs       | 6 ++++++
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 8 +++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 8b551cf0..0c6df2ee 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Net.WebSockets;
 using System.Threading.Tasks;
 
 namespace GraphQL.Client.Http
@@ -52,5 +53,10 @@ public class GraphQLHttpClientOptions
         /// This callback is called after successfully establishing a websocket connection but before any regular request is made. 
         /// </summary>
         public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
+
+        /// <summary>
+        /// Configure additional websocket options (i.e. headers). This will not be invoked on Windows 7 when targeting .NET Framework 4.x. 
+        /// </summary>
+        public Action<ClientWebSocketOptions> ConfigureWebsocketOptions { get; set; } = options => { };
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index f0156030..227b53cd 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -399,12 +399,13 @@ public Task InitializeWebSocket()
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
 						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
 						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
-						break;
+                        Options.ConfigureWebsocketOptions(nativeWebSocket.Options);
+                        break;
 					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
 						managedWebSocket.Options.AddSubProtocol("graphql-ws");
 						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
 						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
-						break;
+                        break;
 					default:
 						throw new NotSupportedException($"unknown websocket type {_clientWebSocket.GetType().Name}");
 				}
@@ -413,6 +414,7 @@ public Task InitializeWebSocket()
                 _clientWebSocket.Options.AddSubProtocol("graphql-ws");
                 _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
                 _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+                Options.ConfigureWebsocketOptions(_clientWebSocket.Options);
 #endif
                 return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);
             }
@@ -609,7 +611,7 @@ public void Complete()
         /// Task to await the completion (a.k.a. disposal) of this websocket.
         /// </summary> 
         /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-        public Task Completion { get; private set; }
+        public Task? Completion { get; private set; }
 
         private readonly object _completedLocker = new object();
         private async Task CompleteAsync()

From cbe68e18a6d21ac6a018f7f57424f235d4b15fe5 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 21 Apr 2020 01:10:33 +0300
Subject: [PATCH 272/455] fix build

---
 src/GraphQL.Client/GraphQLHttpRequest.cs                      | 2 ++
 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index abf5d0d3..00f90d4a 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -41,7 +41,9 @@ public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions
                 Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
             };
 
+#pragma warning disable CS0618 // Type or member is obsolete
             PreprocessHttpRequestMessage(message);
+#pragma warning restore CS0618 // Type or member is obsolete
             return message;
         }
     }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 4e9cd45a..5855e626 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -173,7 +173,9 @@ public async void PreprocessHttpRequestMessageIsCalled()
             var callbackTester = new CallbackMonitor<HttpRequestMessage>();
             var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
             {
+#pragma warning disable CS0618 // Type or member is obsolete
                 PreprocessHttpRequestMessage = callbackTester.Invoke
+#pragma warning restore CS0618 // Type or member is obsolete
             };
 
             var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;

From cc131e23e18b6e93ca49b21d34cd3e2162e60f98 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 21 Apr 2020 01:28:04 +0300
Subject: [PATCH 273/455] revert itemgroup

---
 src/GraphQL.Client/GraphQL.Client.csproj | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index f6f7c0fe..febf2911 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -15,6 +15,10 @@
     <DefineConstants>NETFRAMEWORK</DefineConstants>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
+  </ItemGroup>
+  
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
     <PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
   </ItemGroup>

From 7004c126f1c20276e57dda3633aebef84dde7a35 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 21 Apr 2020 22:31:15 +0200
Subject: [PATCH 274/455] Return a list for a JSON array

---
 .../MapConverter.cs                                  |  8 ++++----
 .../MapConverter.cs                                  | 12 ++++++------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index c2739b41..10a687f4 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.Runtime.InteropServices;
+using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
@@ -24,11 +24,11 @@ public override Map ReadJson(JsonReader reader, Type objectType, Map existingVal
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
         }
 
-        private object ReadToken(JToken? token) =>
+        private object? ReadToken(JToken? token) =>
             token switch
             {
                 JObject jObject => ReadDictionary<Dictionary<string, object>>(jObject),
-                JArray jArray => ReadArray(jArray),
+                JArray jArray => ReadArray(jArray).ToList(),
                 JValue jValue => jValue.Value,
                 JConstructor _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
                     "cannot deserialize a JSON constructor"),
@@ -51,7 +51,7 @@ private TDictionary ReadDictionary<TDictionary>(JToken element) where TDictionar
             return result;
         }
 
-        private IEnumerable<object> ReadArray(JArray element)
+        private IEnumerable<object?> ReadArray(JArray element)
         {
             foreach (var item in element)
             {
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
index bbaa2fe9..63d3d9fc 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
@@ -41,7 +41,7 @@ private TDictionary ReadDictionary<TDictionary>(JsonElement element) where TDict
             return result;
         }
 
-        private IEnumerable<object> ReadArray(JsonElement value)
+        private IEnumerable<object?> ReadArray(JsonElement value)
         {
             foreach (var item in value.EnumerateArray())
             {
@@ -49,7 +49,7 @@ private IEnumerable<object> ReadArray(JsonElement value)
             }
         }
 
-        private object ReadValue(JsonElement value)
+        private object? ReadValue(JsonElement value)
             => value.ValueKind switch
             {
                 JsonValueKind.Array => ReadArray(value).ToList(),
@@ -65,15 +65,15 @@ private object ReadValue(JsonElement value)
 
         private object ReadNumber(JsonElement value)
         {
-            if (value.TryGetInt32(out var i))
+            if (value.TryGetInt32(out int i))
                 return i;
-            else if (value.TryGetInt64(out var l))
+            else if (value.TryGetInt64(out long l))
                 return l;
             else if (BigInteger.TryParse(value.GetRawText(), out var bi))
                 return bi;
-            else if (value.TryGetDouble(out var d))
+            else if (value.TryGetDouble(out double d))
                 return d;
-            else if (value.TryGetDecimal(out var dd))
+            else if (value.TryGetDecimal(out decimal dd))
                 return dd;
 
             throw new NotImplementedException($"Unexpected Number value. Raw text was: {value.GetRawText()}");

From 451791baedecb1ceea8c3a33b36c3edabb96bdc2 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 21 Apr 2020 23:04:02 +0200
Subject: [PATCH 275/455] create test for consistency between MapConverters

---
 .../ConsistencyTests.cs                       | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs

diff --git a/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
new file mode 100644
index 00000000..2fe14e7c
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using FluentAssertions;
+using FluentAssertions.Execution;
+using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Client.Serializer.SystemTextJson;
+using Newtonsoft.Json;
+using Xunit;
+
+namespace GraphQL.Client.Serializer.Tests
+{
+    public class ConsistencyTests
+    {
+        [Fact]
+        public void MapConvertersShouldBehaveConsistent()
+        {
+            const string json = @"{
+                ""array"": [
+                  ""some stuff"",
+                  ""something else""
+                ],
+                ""string"": ""this is a string"",
+                ""boolean"": true,
+                ""number"": 1234.567,
+                ""nested object"": {
+                    ""prop1"": false
+                },
+                ""arrayOfObjects"": [
+                  {""number"": 1234.567},
+                  {""number"": 567.8}
+                ]
+            }";
+            
+            var newtonsoftSerializer = new NewtonsoftJsonSerializer();
+            var systemTextJsonSerializer = new SystemTextJsonSerializer();
+
+            var newtonsoftMap = JsonConvert.DeserializeObject<Map>(json, newtonsoftSerializer.JsonSerializerSettings);
+            var systemTextJsonMap = System.Text.Json.JsonSerializer.Deserialize<Map>(json, systemTextJsonSerializer.Options);
+
+
+            using(new AssertionScope())
+            {
+                CompareMaps(newtonsoftMap, systemTextJsonMap);
+            }
+
+            newtonsoftMap.Should().BeEquivalentTo(systemTextJsonMap, options => options
+                .RespectingRuntimeTypes());
+        }
+
+        private void CompareMaps(Dictionary<string, object> first, Dictionary<string, object> second)
+        {
+            foreach (var keyValuePair in first)
+            {
+                second.Should().ContainKey(keyValuePair.Key);
+                second[keyValuePair.Key].Should().BeOfType(keyValuePair.Value.GetType());
+                if(keyValuePair.Value is Dictionary<string, object> map)
+                    CompareMaps(map, (Dictionary<string, object>)second[keyValuePair.Key]);
+                else
+                    keyValuePair.Value.Should().BeEquivalentTo(second[keyValuePair.Key]);
+            }
+        }
+    }
+}

From 1e4a7cbb1083ff42373d0a521c48354d7414433f Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 21 Apr 2020 23:18:48 +0200
Subject: [PATCH 276/455] add non-generic interface and implement it with
 GraphQLResponse

---
 src/GraphQL.Primitives/GraphQLResponse.cs  |  3 ++-
 src/GraphQL.Primitives/IGraphQLResponse.cs | 11 +++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)
 create mode 100644 src/GraphQL.Primitives/IGraphQLResponse.cs

diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 0b2781fd..24d3a4aa 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -6,11 +6,12 @@
 namespace GraphQL
 {
 
-    public class GraphQLResponse<T> : IEquatable<GraphQLResponse<T>?>
+    public class GraphQLResponse<T> : IGraphQLResponse, IEquatable<GraphQLResponse<T>?>
     {
 
         [DataMember(Name = "data")]
         public T Data { get; set; }
+        object IGraphQLResponse.Data => Data;
 
         [DataMember(Name = "errors")]
         public GraphQLError[]? Errors { get; set; }
diff --git a/src/GraphQL.Primitives/IGraphQLResponse.cs b/src/GraphQL.Primitives/IGraphQLResponse.cs
new file mode 100644
index 00000000..789d686f
--- /dev/null
+++ b/src/GraphQL.Primitives/IGraphQLResponse.cs
@@ -0,0 +1,11 @@
+namespace GraphQL
+{
+    public interface IGraphQLResponse
+    {
+        object Data { get; }
+
+        GraphQLError[]? Errors { get; set; }
+
+        Map? Extensions { get; set; }
+    }
+}

From 26e4dc83e20d81dcbdb30c2c620e321682e0264b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 21 Apr 2020 23:19:29 +0200
Subject: [PATCH 277/455] make some resharper-suggested fixes

---
 .../GraphQLRequestTest.cs                     | 22 +++++++++++--------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
index 8fbda085..145ecfa6 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
@@ -75,8 +75,8 @@ public void InEquality1Fact()
         [Fact]
         public void InEquality2Fact()
         {
-            GraphQLRequest graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            GraphQLRequest graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
             Assert.NotEqual(graphQLRequest1, graphQLRequest2);
         }
 
@@ -122,8 +122,11 @@ public void PropertyQueryGetFact()
         [Fact]
         public void PropertyQuerySetFact()
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            graphQLRequest.Query = "{hero{name2}}";
+            var graphQLRequest =
+                new GraphQLRequest("{hero{name}}", new {varName = "varValue1"}, "operationName")
+                {
+                    Query = "{hero{name2}}"
+                };
             Assert.Equal("{hero{name2}}", graphQLRequest.Query);
         }
 
@@ -144,8 +147,10 @@ public void PropertyOperationNameNullGetFact()
         [Fact]
         public void PropertyOperationNameSetFact()
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1");
-            graphQLRequest.OperationName = "operationName2";
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new {varName = "varValue"}, "operationName1")
+            {
+                OperationName = "operationName2"
+            };
             Assert.Equal("operationName2", graphQLRequest.OperationName);
         }
 
@@ -166,10 +171,9 @@ public void PropertyVariableNullGetFact()
         [Fact]
         public void PropertyVariableSetFact()
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1");
-            graphQLRequest.Variables = new
+            var graphQLRequest = new GraphQLRequest("{hero{name}}", new {varName = "varValue1"}, "operationName1")
             {
-                varName = "varValue2"
+                Variables = new {varName = "varValue2"}
             };
             Assert.Equal(new
             {

From c58dc9ea0cd1ebb1a340c2a0e552d74a5b06a3d8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 21 Apr 2020 23:39:24 +0200
Subject: [PATCH 278/455] fix workflow paths in sln

---
 GraphQL.Client.sln | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 24ea23a4..ab95f2ec 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -33,9 +33,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Server.Test", "test
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{05CAF9B2-981E-40C0-AE31-5FA56E351F12}"
 	ProjectSection(SolutionItems) = preProject
-		.github\workflows\branches-ubuntu.yml = .github\workflows\branches-ubuntu.yml
 		.github\workflows\branches.yml = .github\workflows\branches.yml
-		.github\workflows\main.yml = .github\workflows\main.yml
+		.github\workflows\master.yml = .github\workflows\master.yml
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Primitives", "src\GraphQL.Primitives\GraphQL.Primitives.csproj", "{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6}"
@@ -64,7 +63,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Serializer.S
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{89AD33AB-64F6-4F82-822F-21DF7A10CEC0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Example", "examples\GraphQL.Client.Example\GraphQL.Client.Example.csproj", "{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Example", "examples\GraphQL.Client.Example\GraphQL.Client.Example.csproj", "{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

From 2668f816655e84accc3c169e03edec97c0bb9e2b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 22 Apr 2020 00:04:02 +0200
Subject: [PATCH 279/455] Fix #207

---
 src/GraphQL.Client/GraphQLHttpClientExtensions.cs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index 31f29785..71ffe5f6 100644
--- a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -27,11 +27,20 @@ public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<T
                     throw e;
             });
 
+        /// <inheritdoc cref="CreateSubscriptionStream{TResponse}(GraphQL.Client.Abstractions.IGraphQLClient,GraphQL.GraphQLRequest,System.Action{System.Net.WebSockets.WebSocketException})"/>
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
             this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
         {
             _ = defineResponseType;
             return client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
         }
+
+        /// <inheritdoc cref="GraphQLHttpClient.CreateSubscriptionStream{TResponse}(GraphQL.GraphQLRequest)"/>
+        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
+        {
+            _ = defineResponseType;
+            return client.CreateSubscriptionStream<TResponse>(request);
+        }
     }
 }

From 559db232b61a6335350669f00bdc2fba233edfb3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 22 Apr 2020 00:05:52 +0200
Subject: [PATCH 280/455] cleanup

---
 src/GraphQL.Client/GraphQLHttpClientExtensions.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index 71ffe5f6..041ed5c6 100644
--- a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -27,7 +27,7 @@ public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<T
                     throw e;
             });
 
-        /// <inheritdoc cref="CreateSubscriptionStream{TResponse}(GraphQL.Client.Abstractions.IGraphQLClient,GraphQL.GraphQLRequest,System.Action{System.Net.WebSockets.WebSocketException})"/>
+        /// <inheritdoc cref="CreateSubscriptionStream{TResponse}(IGraphQLClient,GraphQLRequest,Action{WebSocketException})"/>
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
             this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
         {
@@ -35,7 +35,7 @@ public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<T
             return client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
         }
 
-        /// <inheritdoc cref="GraphQLHttpClient.CreateSubscriptionStream{TResponse}(GraphQL.GraphQLRequest)"/>
+        /// <inheritdoc cref="GraphQLHttpClient.CreateSubscriptionStream{TResponse}(GraphQLRequest)"/>
         public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
             this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
         {

From 171657a39d7d11184c3378ae9b228daf8f71bec5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 22 Apr 2020 00:09:06 +0200
Subject: [PATCH 281/455] fix #210

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 901fd919..643df77e 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -614,7 +614,8 @@ public void Complete()
         private readonly object _completedLocker = new object();
         private async Task CompleteAsync()
         {
-            Debug.WriteLine($"disposing websocket {_clientWebSocket.GetHashCode()}...");
+            Debug.WriteLine("disposing GraphQLHttpWebSocket...");
+
             _incomingMessagesConnection?.Dispose();
 
             if (!_internalCancellationTokenSource.IsCancellationRequested)
@@ -634,7 +635,7 @@ private async Task CompleteAsync()
             _sendLoopScheduler?.Dispose();
             _receiveLoopScheduler?.Dispose();
 
-            Debug.WriteLine($"websocket {_clientWebSocket.GetHashCode()} disposed");
+            Debug.WriteLine("GraphQLHttpWebSocket disposed");
         }
 
         #endregion

From 561b1d75a64149952c68951fcdf699a5ae4aa01a Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 22 Apr 2020 00:48:35 +0200
Subject: [PATCH 282/455] prevent GraphQL.Client.Tests.Common from creating a
 nuget package

---
 .../GraphQL.Client.Tests.Common.csproj                           | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index c1806363..6aeff4a3 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+		<IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>

From f2baba077f916850083db917237c1673d446b5c8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 6 May 2020 16:12:14 +0200
Subject: [PATCH 283/455] fix example

---
 README.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 60fd2bd1..86826eba 100644
--- a/README.md
+++ b/README.md
@@ -54,18 +54,18 @@ Be careful when using `byte[]` in your variables object, as most JSON serializer
 var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
 
 public class PersonAndFilmsResponse {
-    public PersonContent Person { get; set; }
+    public Person Person { get; set; }
+}
 
-    public class PersonContent {
-        public string Name { get; set; }
-        public FilmConnectionContent FilmConnection { get; set; }
+public class Person {
+    public string Name { get; set; }
+    public FilmConnectionContent FilmConnection { get; set; }
 
-        public class FilmConnectionContent {
-            public List<FilmContent> Films { get; set; }
+    public class FilmConnectionContent {
+        public List<FilmContent> Films { get; set; }
 
-            public class FilmContent {
-                public string Title { get; set; }
-            }
+        public class FilmContent {
+            public string Title { get; set; }
         }
     }
 }

From 64c1d6fd39a9dde7a134b63150ece0f7f864c54c Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 6 May 2020 16:15:54 +0200
Subject: [PATCH 284/455] clarify example in readme readme

---
 README.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 86826eba..08fc6cad 100644
--- a/README.md
+++ b/README.md
@@ -51,8 +51,6 @@ Be careful when using `byte[]` in your variables object, as most JSON serializer
 ### Execute Query/Mutation:
 
 ```csharp
-var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
-
 public class PersonAndFilmsResponse {
     public Person Person { get; set; }
 }
@@ -70,11 +68,18 @@ public class Person {
     }
 }
 
+var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
 var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
 
 var personName = graphQLResponse.Data.Person.Name;
 ```
 
+Using the extension method for anonymously typed responses (namespace `GraphQL.Client.Abstractions`) you could achieve the same result with the following code:
+
+```csharp
+var graphQLResponse = await graphQLClient.SendQueryAsync(personAndFilmsRequest, () => new { person = new Person()} );
+var personName = graphQLResponse.Data.person.Name;
+```
 
 ### Use Subscriptions
 

From fb657d57e075e3da38b67ede30ef834ef206d987 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 6 May 2020 16:24:33 +0200
Subject: [PATCH 285/455] refine example

---
 README.md | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 08fc6cad..f748d12c 100644
--- a/README.md
+++ b/README.md
@@ -51,25 +51,26 @@ Be careful when using `byte[]` in your variables object, as most JSON serializer
 ### Execute Query/Mutation:
 
 ```csharp
-public class PersonAndFilmsResponse {
-    public Person Person { get; set; }
+public class ResponseType 
+{
+    public PersonType Person { get; set; }
 }
 
-public class Person {
+public class PersonType 
+{
     public string Name { get; set; }
-    public FilmConnectionContent FilmConnection { get; set; }
+    public FilmConnectionType FilmConnection { get; set; }    
+}
 
-    public class FilmConnectionContent {
-        public List<FilmContent> Films { get; set; }
+public class FilmConnectionType {
+    public List<FilmContentType> Films { get; set; }    
+}
 
-        public class FilmContent {
-            public string Title { get; set; }
-        }
-    }
+public class FilmContentType {
+    public string Title { get; set; }
 }
 
-var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
-var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
+var graphQLResponse = await graphQLClient.SendQueryAsync<ResponseType>(personAndFilmsRequest);
 
 var personName = graphQLResponse.Data.Person.Name;
 ```
@@ -77,7 +78,7 @@ var personName = graphQLResponse.Data.Person.Name;
 Using the extension method for anonymously typed responses (namespace `GraphQL.Client.Abstractions`) you could achieve the same result with the following code:
 
 ```csharp
-var graphQLResponse = await graphQLClient.SendQueryAsync(personAndFilmsRequest, () => new { person = new Person()} );
+var graphQLResponse = await graphQLClient.SendQueryAsync(personAndFilmsRequest, () => new { person = new PersonType()} );
 var personName = graphQLResponse.Data.person.Name;
 ```
 

From fa8253ebc22f5bb3944c721ba87e46cf968b8144 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 25 May 2020 21:44:22 +0200
Subject: [PATCH 286/455] use SelectMany to serialize calls to
 SendWebSocketRequestAsync

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 643df77e..652e3f77 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -3,6 +3,7 @@
 using System.IO;
 using System.Net.Http;
 using System.Net.WebSockets;
+using System.Reactive;
 using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
@@ -84,7 +85,8 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
 
             _requestSubscription = _requestSubject
                 .ObserveOn(_sendLoopScheduler)
-                .Subscribe(async request => await SendWebSocketRequestAsync(request));
+                .SelectMany(SendWebSocketRequestAsync)
+                .Subscribe();
         }
 
         #region Send requests
@@ -339,14 +341,14 @@ private Task QueueWebSocketRequest(GraphQLWebSocketRequest request)
             return request.SendTask();
         }
 
-        private async Task SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
+        private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
         {
             try
             {
                 if (_internalCancellationToken.IsCancellationRequested)
                 {
                     request.SendCanceled();
-                    return;
+                    return Unit.Default;
                 }
 
                 await InitializeWebSocket();
@@ -362,6 +364,7 @@ await _clientWebSocket.SendAsync(
             {
                 request.SendFailed(e);
             }
+            return Unit.Default;
         }
 
         #endregion

From 7a80649f1d32a517d86f6cb0437a7d57bffa74e7 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 25 May 2020 21:56:46 +0200
Subject: [PATCH 287/455] add default User-Agent header when not set

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 5d8453ef..1f9a3b5a 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -2,7 +2,9 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
@@ -57,6 +59,10 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
             Options = options ?? throw new ArgumentNullException(nameof(options));
             JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
             HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
+
+            if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
+                HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
+
             _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
         }
 

From fc406dfec9a1c02c28a4a246c611ae5ba273746a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 25 May 2020 22:05:47 +0200
Subject: [PATCH 288/455] update GitVersionTask (closes #214)

---
 src/src.props | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/src.props b/src/src.props
index 91497142..c4e46be1 100644
--- a/src/src.props
+++ b/src/src.props
@@ -7,9 +7,8 @@
     <LangVersion>8.0</LangVersion>
   </PropertyGroup>
 
-  <!--TODO: remove condition when https://github.com/GitTools/GitVersion/issues/2063 is fixed-->
-  <ItemGroup Condition=" '$(DEBUG)' != ''">
-    <PackageReference Update="GitVersionTask" Version="5.2.4">
+  <ItemGroup>
+    <PackageReference Update="GitVersionTask" Version="5.3.4">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

From 059b32b2a58aae90a9d4eaff058ff808aac45162 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 25 May 2020 22:12:32 +0200
Subject: [PATCH 289/455] fix error handling in
 GraphQLLocalExecutionClient.ExecuteSubscriptionAsync (closes #236)

---
 .../GraphQLLocalExecutionClient.cs                         | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index d458d20e..f8fe6503 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -79,8 +79,11 @@ private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(Grap
         private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var result = await ExecuteAsync(request, cancellationToken);
-            return ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault()?
-                .SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
+            var stream = ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault();
+            
+            return stream == null
+                ? Observable.Throw<GraphQLResponse<TResponse>>(new InvalidOperationException("the GraphQL execution did not return an observable"))
+                : stream.SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
         }
 
         private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, CancellationToken cancellationToken = default)

From d1b8d228db36e6e6da572b95b8121b1e7018bf05 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 9 May 2020 21:56:32 +0200
Subject: [PATCH 290/455] add reproduction test

---
 .../BaseSerializerTest.cs                     | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 5811823c..32dff92a 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Text;
 using System.Threading;
@@ -118,5 +119,26 @@ public async void CanDoSerializationWithPredefinedTypes()
 
             Assert.Equal(message, response.Data.AddMessage.Content);
         }
+
+        
+        public class WithNullable
+        {
+            public int? NullableInt { get; set; }
+        }
+
+        [Fact]
+        public void CanSerializeNullableInt()
+        {
+            Action action = () => Serializer.SerializeToString(new GraphQLRequest
+            {
+                Query = "{}",
+                Variables = new WithNullable
+                {
+                    NullableInt = 2
+                }
+            });
+
+            action.Should().NotThrow();
+        }
     }
 }

From 191e139c2498b9da33b1de3b36f6e8cb0ce6d795 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 10 May 2020 00:47:57 +0200
Subject: [PATCH 291/455] test example response from spec, fix conversion

---
 .../ConverterHelperExtensions.cs              | 25 +++++++
 .../ErrorPathConverter.cs                     | 48 +++++++++++++
 .../ImmutableConverter.cs                     |  7 ++
 .../MapConverter.cs                           | 26 ++-----
 .../SystemTextJsonSerializer.cs               |  1 +
 src/GraphQL.Primitives/ErrorPath.cs           | 15 ++++
 src/GraphQL.Primitives/GraphQLError.cs        |  2 +-
 .../BaseSerializerTest.cs                     | 40 +++++++++--
 .../TestData/DeserializeResponseTestData.cs   | 71 +++++++++++++++++++
 9 files changed, 210 insertions(+), 25 deletions(-)
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
 create mode 100644 src/GraphQL.Primitives/ErrorPath.cs

diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
new file mode 100644
index 00000000..73daa8cf
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Numerics;
+using System.Text.Json;
+
+namespace GraphQL.Client.Serializer.SystemTextJson
+{
+    public static class ConverterHelperExtensions
+    {
+        public static object ReadNumber(this JsonElement value)
+        {
+            if (value.TryGetInt32(out int i))
+                return i;
+            else if (value.TryGetInt64(out long l))
+                return l;
+            else if (BigInteger.TryParse(value.GetRawText(), out var bi))
+                return bi;
+            else if (value.TryGetDouble(out double d))
+                return d;
+            else if (value.TryGetDecimal(out decimal dd))
+                return dd;
+
+            throw new NotImplementedException($"Unexpected Number value. Raw text was: {value.GetRawText()}");
+        }
+    }
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
new file mode 100644
index 00000000..e760bdd6
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace GraphQL.Client.Serializer.SystemTextJson
+{
+    public class ErrorPathConverter : JsonConverter<ErrorPath>
+    {
+
+        public override ErrorPath Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            using var doc = JsonDocument.ParseValue(ref reader);
+
+            if (doc?.RootElement == null || doc?.RootElement.ValueKind != JsonValueKind.Array)
+            {
+                throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+            }
+
+            return new ErrorPath(ReadArray(doc.RootElement));
+        }
+
+        public override void Write(Utf8JsonWriter writer, ErrorPath value, JsonSerializerOptions options)
+            => throw new NotImplementedException(
+                "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+        
+        private IEnumerable<object?> ReadArray(JsonElement value)
+        {
+            foreach (var item in value.EnumerateArray())
+            {
+                yield return ReadValue(item);
+            }
+        }
+
+        private object? ReadValue(JsonElement value)
+            => value.ValueKind switch
+            {
+                JsonValueKind.Number => value.ReadNumber(),
+                JsonValueKind.True => true,
+                JsonValueKind.False => false,
+                JsonValueKind.String => value.GetString(),
+                JsonValueKind.Null => null,
+                JsonValueKind.Undefined => null,
+                _ => throw new InvalidOperationException($"Unexpected value kind: {value.ValueKind}")
+            };
+    }
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index 4a26f6f2..841b73d4 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -15,6 +15,13 @@ public class ImmutableConverter : JsonConverter<object>
     {
         public override bool CanConvert(Type typeToConvert)
         {
+            if (typeToConvert.IsPrimitive)
+                return false;
+
+            var nullableUnderlyingType = Nullable.GetUnderlyingType(typeToConvert);
+            if (nullableUnderlyingType != null && nullableUnderlyingType.IsPrimitive)
+                return false;
+
             bool result;
             var constructors = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
             if (constructors.Length != 1)
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
index 63d3d9fc..f9f61008 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
@@ -24,16 +24,16 @@ public override Map Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSeri
                 throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
             }
 
-            return ReadDictionary<Map>(doc.RootElement);
+            return ReadDictionary(doc.RootElement, new Map());
         }
 
         public override void Write(Utf8JsonWriter writer, Map value, JsonSerializerOptions options)
             => throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-        private TDictionary ReadDictionary<TDictionary>(JsonElement element) where TDictionary : Dictionary<string, object>
+        private TDictionary ReadDictionary<TDictionary>(JsonElement element, TDictionary result)
+            where TDictionary : Dictionary<string, object>
         {
-            var result = Activator.CreateInstance<TDictionary>();
             foreach (var property in element.EnumerateObject())
             {
                 result[property.Name] = ReadValue(property.Value);
@@ -53,8 +53,8 @@ private TDictionary ReadDictionary<TDictionary>(JsonElement element) where TDict
             => value.ValueKind switch
             {
                 JsonValueKind.Array => ReadArray(value).ToList(),
-                JsonValueKind.Object => ReadDictionary<Dictionary<string, object>>(value),
-                JsonValueKind.Number => ReadNumber(value),
+                JsonValueKind.Object => ReadDictionary(value, new Dictionary<string, object>()),
+                JsonValueKind.Number => value.ReadNumber(),
                 JsonValueKind.True => true,
                 JsonValueKind.False => false,
                 JsonValueKind.String => value.GetString(),
@@ -63,20 +63,6 @@ private TDictionary ReadDictionary<TDictionary>(JsonElement element) where TDict
                 _ => throw new InvalidOperationException($"Unexpected value kind: {value.ValueKind}")
             };
 
-        private object ReadNumber(JsonElement value)
-        {
-            if (value.TryGetInt32(out int i))
-                return i;
-            else if (value.TryGetInt64(out long l))
-                return l;
-            else if (BigInteger.TryParse(value.GetRawText(), out var bi))
-                return bi;
-            else if (value.TryGetDouble(out double d))
-                return d;
-            else if (value.TryGetDecimal(out decimal dd))
-                return dd;
-
-            throw new NotImplementedException($"Unexpected Number value. Raw text was: {value.GetRawText()}");
-        }
+        
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index f5b2e7f4..a1667ec8 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -30,6 +30,7 @@ public SystemTextJsonSerializer(JsonSerializerOptions options)
         private void ConfigureMandatorySerializerOptions()
         {
             // deserialize extensions to Dictionary<string, object>
+            Options.Converters.Insert(0, new ErrorPathConverter());
             Options.Converters.Insert(0, new MapConverter());
             // allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
             Options.PropertyNameCaseInsensitive = true;
diff --git a/src/GraphQL.Primitives/ErrorPath.cs b/src/GraphQL.Primitives/ErrorPath.cs
new file mode 100644
index 00000000..59abdb79
--- /dev/null
+++ b/src/GraphQL.Primitives/ErrorPath.cs
@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+
+namespace GraphQL
+{
+    public class ErrorPath : List<object>
+    {
+        public ErrorPath()
+        {
+        }
+
+        public ErrorPath(IEnumerable<object> collection) : base(collection)
+        {
+        }
+    }
+}
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 9b7cfc99..c76d3f00 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -26,7 +26,7 @@ public class GraphQLError : IEquatable<GraphQLError?>
         /// The Path of the error
         /// </summary>
         [DataMember(Name = "path")]
-        public object[]? Path { get; set; }
+        public ErrorPath? Path { get; set; }
 
         /// <summary>
         /// The extensions of the error
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 32dff92a..e8bd28db 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -1,8 +1,12 @@
 using System;
 using System.IO;
+using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using FluentAssertions;
+using FluentAssertions.Execution;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.LocalExecution;
@@ -49,14 +53,31 @@ public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest re
 
         [Theory]
         [ClassData(typeof(DeserializeResponseTestData))]
-        public async void DeserializeFromUtf8StreamTest(string json, GraphQLResponse<object> expectedResponse)
+        public async void DeserializeFromUtf8StreamTest(string json, IGraphQLResponse expectedResponse)
         {
             var jsonBytes = Encoding.UTF8.GetBytes(json);
             await using var ms = new MemoryStream(jsonBytes);
-            var response = await Serializer.DeserializeFromUtf8StreamAsync<GraphQLResponse<object>>(ms, CancellationToken.None);
+            var response = await DeserializeToUnknownType(expectedResponse.Data?.GetType() ?? typeof(object), ms);
+            //var response = await Serializer.DeserializeFromUtf8StreamAsync<object>(ms, CancellationToken.None);
 
-            response.Data.Should().BeEquivalentTo(expectedResponse.Data);
-            response.Errors.Should().Equal(expectedResponse.Errors);
+            response.Data.Should().BeEquivalentTo(expectedResponse.Data, options => options.WithAutoConversion());
+
+            if (expectedResponse.Errors is null)
+                response.Errors.Should().BeNull();
+            else {
+                using (new AssertionScope())
+                {
+                    response.Errors.Should().NotBeNull();
+                    response.Errors.Should().HaveSameCount(expectedResponse.Errors);
+                    for (int i = 0; i < expectedResponse.Errors.Length; i++)
+                    {
+                        response.Errors[i].Message.Should().BeEquivalentTo(expectedResponse.Errors[i].Message);
+                        response.Errors[i].Locations.Should().BeEquivalentTo(expectedResponse.Errors[i].Locations?.ToList());
+                        response.Errors[i].Path.Should().BeEquivalentTo(expectedResponse.Errors[i].Path);
+                        response.Errors[i].Extensions.Should().BeEquivalentTo(expectedResponse.Errors[i].Extensions);
+                    }
+                }
+            }
 
             if (expectedResponse.Extensions == null)
                 response.Extensions.Should().BeNull();
@@ -70,6 +91,17 @@ public async void DeserializeFromUtf8StreamTest(string json, GraphQLResponse<obj
             }
         }
 
+        public async Task<IGraphQLResponse> DeserializeToUnknownType(Type dataType, Stream stream)
+        {
+            MethodInfo mi = Serializer.GetType().GetMethod("DeserializeFromUtf8StreamAsync", BindingFlags.Instance | BindingFlags.Public);
+            MethodInfo mi2 = mi.MakeGenericMethod(dataType);
+            var task = (Task) mi2.Invoke(Serializer, new object[] { stream, CancellationToken.None });
+            await task;
+            var resultProperty = task.GetType().GetProperty("Result", BindingFlags.Public | BindingFlags.Instance);
+            var result = resultProperty.GetValue(task);
+            return (IGraphQLResponse)result;
+        }
+
         [Fact]
         public async void CanDeserializeExtensions()
         {
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
index 0c6844cf..5f1dcdf5 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -37,8 +37,79 @@ public IEnumerator<object[]> GetEnumerator()
                     }
                 }
             };
+
+            yield return new object[]
+            {
+                @"{
+                    ""errors"": [
+                        {
+                            ""message"": ""Name for character with ID 1002 could not be fetched."",
+                            ""locations"": [
+                                {
+                                    ""line"": 6,
+                                    ""column"": 7
+                                }
+                            ],
+                            ""path"": [
+                                ""hero"",
+                                ""heroFriends"",
+                                1,
+                                ""name""
+                            ]
+                        }
+                    ],
+                    ""data"": {
+                        ""hero"": {
+                            ""name"": ""R2-D2"",
+                            ""heroFriends"": [
+                                {
+                                    ""id"": ""1000"",
+                                    ""name"": ""Luke Skywalker""
+                                },
+                                {
+                                    ""id"": ""1002"",
+                                    ""name"": null
+                                },
+                                {
+                                    ""id"": ""1003"",
+                                    ""name"": ""Leia Organa""
+                                }
+                            ]
+                        }
+                    }
+                }",
+                NewAnonymouslyTypedGraphQLResponse(new
+                    {
+                        hero = new
+                        {
+                            name = "R2-D2",
+                            heroFriends = new List<Friend>
+                            {
+                                new Friend {Id = "1000", Name = "Luke Skywalker"},
+                                new Friend {Id = "1002", Name = null},
+                                new Friend {Id = "1003", Name = "Leia Organa"}
+                            }
+                        }
+                    },
+                    new[] {
+                        new GraphQLError {
+                            Message = "Name for character with ID 1002 could not be fetched.",
+                            Locations = new [] { new GraphQLLocation{Line = 6, Column = 7 }},
+                            Path = new ErrorPath{"hero", "heroFriends", 1, "name"}
+                        }
+                    })
+            };
         }
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        private GraphQLResponse<T> NewAnonymouslyTypedGraphQLResponse<T>(T data, GraphQLError[]? errors = null, Map? extensions = null)
+            => new GraphQLResponse<T> {Data = data, Errors = errors, Extensions = extensions};
+    }
+
+    public class Friend
+    {
+        public string Id { get; set; }
+        public string? Name { get; set; }
     }
 }

From 52dc9bd9edb173cc8ebf6e13aa6e7f18af8d37c1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 25 May 2020 23:04:27 +0200
Subject: [PATCH 292/455] remove usage of evil JsonDocument.ParseValue

---
 .../ConverterHelperExtensions.cs              | 32 +++++---
 .../ErrorPathConverter.cs                     | 49 ++++++------
 .../MapConverter.cs                           | 74 +++++++++++--------
 3 files changed, 93 insertions(+), 62 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
index 73daa8cf..fbb9036d 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
@@ -1,25 +1,37 @@
 using System;
+using System.Buffers;
 using System.Numerics;
+using System.Text;
 using System.Text.Json;
 
 namespace GraphQL.Client.Serializer.SystemTextJson
 {
     public static class ConverterHelperExtensions
     {
-        public static object ReadNumber(this JsonElement value)
+        public static object ReadNumber(this ref Utf8JsonReader reader)
         {
-            if (value.TryGetInt32(out int i))
+            if (reader.TryGetInt32(out int i))
                 return i;
-            else if (value.TryGetInt64(out long l))
+            else if (reader.TryGetInt64(out long l))
                 return l;
-            else if (BigInteger.TryParse(value.GetRawText(), out var bi))
-                return bi;
-            else if (value.TryGetDouble(out double d))
-                return d;
-            else if (value.TryGetDecimal(out decimal dd))
-                return dd;
+            else if (reader.TryGetDouble(out double d))
+                return reader.TryGetBigInteger(out var bi) && bi != new BigInteger(d)
+                    ? bi
+                    : (object)d;
+            else if (reader.TryGetDecimal(out decimal dd))
+                return reader.TryGetBigInteger(out var bi) && bi != new BigInteger(dd)
+                    ? bi
+                    : (object)dd;
 
-            throw new NotImplementedException($"Unexpected Number value. Raw text was: {value.GetRawText()}");
+            throw new NotImplementedException($"Unexpected Number value. Raw text was: {reader.GetRawString()}");
+        }
+
+        public static bool TryGetBigInteger(this ref Utf8JsonReader reader, out BigInteger bi) => BigInteger.TryParse(reader.GetRawString(), out bi);
+
+        public static string GetRawString(this ref Utf8JsonReader reader)
+        {
+            var byteArray = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+            return Encoding.UTF8.GetString(byteArray);
         }
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
index e760bdd6..b2718096 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
@@ -9,40 +9,43 @@ namespace GraphQL.Client.Serializer.SystemTextJson
     public class ErrorPathConverter : JsonConverter<ErrorPath>
     {
 
-        public override ErrorPath Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-        {
-            using var doc = JsonDocument.ParseValue(ref reader);
-
-            if (doc?.RootElement == null || doc?.RootElement.ValueKind != JsonValueKind.Array)
-            {
-                throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
-            }
-
-            return new ErrorPath(ReadArray(doc.RootElement));
-        }
+        public override ErrorPath Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
+            new ErrorPath(ReadArray(ref reader));
 
         public override void Write(Utf8JsonWriter writer, ErrorPath value, JsonSerializerOptions options)
             => throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
         
-        private IEnumerable<object?> ReadArray(JsonElement value)
+        private IEnumerable<object?> ReadArray(ref Utf8JsonReader reader)
         {
-            foreach (var item in value.EnumerateArray())
+            if (reader.TokenType != JsonTokenType.StartArray)
             {
-                yield return ReadValue(item);
+                throw new JsonException("This converter can only parse when the root element is a JSON Array.");
             }
+
+            var array = new List<object?>();
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndArray)
+                    break;
+
+                array.Add(ReadValue(ref reader));
+            }
+
+            return array;
         }
 
-        private object? ReadValue(JsonElement value)
-            => value.ValueKind switch
+        private object? ReadValue(ref Utf8JsonReader reader)
+            => reader.TokenType switch
             {
-                JsonValueKind.Number => value.ReadNumber(),
-                JsonValueKind.True => true,
-                JsonValueKind.False => false,
-                JsonValueKind.String => value.GetString(),
-                JsonValueKind.Null => null,
-                JsonValueKind.Undefined => null,
-                _ => throw new InvalidOperationException($"Unexpected value kind: {value.ValueKind}")
+                JsonTokenType.None => null,
+                JsonTokenType.String => reader.GetString(),
+                JsonTokenType.Number => reader.ReadNumber(),
+                JsonTokenType.True => true,
+                JsonTokenType.False => false,
+                JsonTokenType.Null => null,
+                _ => throw new InvalidOperationException($"Unexpected token type: {reader.TokenType}")
             };
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
index f9f61008..e41c1bf5 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
@@ -15,52 +15,68 @@ namespace GraphQL.Client.Serializer.SystemTextJson
     /// </remarks>
     public class MapConverter : JsonConverter<Map>
     {
-        public override Map Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
-        {
-            using var doc = JsonDocument.ParseValue(ref reader);
-
-            if (doc?.RootElement == null || doc?.RootElement.ValueKind != JsonValueKind.Object)
-            {
-                throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
-            }
-
-            return ReadDictionary(doc.RootElement, new Map());
-        }
+        public override Map Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => ReadDictionary(ref reader, new Map());
 
         public override void Write(Utf8JsonWriter writer, Map value, JsonSerializerOptions options)
             => throw new NotImplementedException(
                 "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-        private TDictionary ReadDictionary<TDictionary>(JsonElement element, TDictionary result)
+        private static TDictionary ReadDictionary<TDictionary>(ref Utf8JsonReader reader, TDictionary result)
             where TDictionary : Dictionary<string, object>
         {
-            foreach (var property in element.EnumerateObject())
+            if (reader.TokenType != JsonTokenType.StartObject)
+                throw new JsonException();
+            
+            while (reader.Read())
             {
-                result[property.Name] = ReadValue(property.Value);
+                if (reader.TokenType == JsonTokenType.EndObject)
+                    break;
+
+                if (reader.TokenType != JsonTokenType.PropertyName)
+                    throw new JsonException();
+
+                string key = reader.GetString();
+
+                // move to property value
+                if (!reader.Read())
+                    throw new JsonException();
+
+                result.Add(key, ReadValue(ref reader));
             }
+
             return result;
         }
 
-        private IEnumerable<object?> ReadArray(JsonElement value)
+        private static List<object> ReadArray(ref Utf8JsonReader reader)
         {
-            foreach (var item in value.EnumerateArray())
+            if (reader.TokenType != JsonTokenType.StartArray)
+                throw new JsonException();
+
+            var result = new List<object>();
+
+            while (reader.Read())
             {
-                yield return ReadValue(item);
+                if (reader.TokenType == JsonTokenType.EndArray)
+                    break;
+
+                result.Add(ReadValue(ref reader));
             }
-        }
 
-        private object? ReadValue(JsonElement value)
-            => value.ValueKind switch
+            return result;
+        }
+        
+        private static object? ReadValue(ref Utf8JsonReader reader)
+            => reader.TokenType switch
             {
-                JsonValueKind.Array => ReadArray(value).ToList(),
-                JsonValueKind.Object => ReadDictionary(value, new Dictionary<string, object>()),
-                JsonValueKind.Number => value.ReadNumber(),
-                JsonValueKind.True => true,
-                JsonValueKind.False => false,
-                JsonValueKind.String => value.GetString(),
-                JsonValueKind.Null => null,
-                JsonValueKind.Undefined => null,
-                _ => throw new InvalidOperationException($"Unexpected value kind: {value.ValueKind}")
+                JsonTokenType.StartArray => ReadArray(ref reader).ToList(),
+                JsonTokenType.StartObject => ReadDictionary(ref reader, new Dictionary<string, object>()),
+                JsonTokenType.Number => reader.ReadNumber(),
+                JsonTokenType.True => true,
+                JsonTokenType.False => false,
+                JsonTokenType.String => reader.GetString(),
+                JsonTokenType.Null => null,
+                JsonTokenType.None => null,
+                _ => throw new InvalidOperationException($"Unexpected value kind: {reader.TokenType}")
             };
 
         

From 99814cc5db72fd0a518d8ab8d970bf0f5e2f70fe Mon Sep 17 00:00:00 2001
From: Marius Wirtherle <marius.wirtherle@siemens-logistics.com>
Date: Tue, 26 May 2020 12:27:57 +0200
Subject: [PATCH 293/455] don't use ImmutableConverter for nullable structs

---
 .../ImmutableConverter.cs                     |  7 ++--
 .../BaseSerializerTest.cs                     | 34 +++++++++++++++----
 2 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index 841b73d4..fa0a3f06 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -19,7 +19,7 @@ public override bool CanConvert(Type typeToConvert)
                 return false;
 
             var nullableUnderlyingType = Nullable.GetUnderlyingType(typeToConvert);
-            if (nullableUnderlyingType != null && nullableUnderlyingType.IsPrimitive)
+            if (nullableUnderlyingType != null && nullableUnderlyingType.IsValueType)
                 return false;
 
             bool result;
@@ -40,7 +40,7 @@ public override bool CanConvert(Type typeToConvert)
                     foreach (var parameter in parameters)
                     {
                         var hasMatchingProperty = properties.Any(p =>
-                            NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous()));
+                                                                     NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous()));
                         if (!hasMatchingProperty)
                         {
                             result = false;
@@ -90,7 +90,7 @@ public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
             {
                 var parameterInfo = parameters[index];
                 var value = valueOfProperty.First(prop =>
-                    NameOfPropertyAndParameter.Matches(prop.Key.Name, parameterInfo.Name, typeToConvert.IsAnonymous())).Value;
+                                                      NameOfPropertyAndParameter.Matches(prop.Key.Name, parameterInfo.Name, typeToConvert.IsAnonymous())).Value;
 
                 parameterValues[index] = value;
             }
@@ -120,6 +120,7 @@ public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOp
                 if (!(converter is ImmutableConverter))
                     strippedOptions.Converters.Add(converter);
             }
+
             JsonSerializer.Serialize(writer, value, strippedOptions);
         }
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index e8bd28db..53cba0c1 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -58,13 +58,15 @@ public async void DeserializeFromUtf8StreamTest(string json, IGraphQLResponse ex
             var jsonBytes = Encoding.UTF8.GetBytes(json);
             await using var ms = new MemoryStream(jsonBytes);
             var response = await DeserializeToUnknownType(expectedResponse.Data?.GetType() ?? typeof(object), ms);
+
             //var response = await Serializer.DeserializeFromUtf8StreamAsync<object>(ms, CancellationToken.None);
 
             response.Data.Should().BeEquivalentTo(expectedResponse.Data, options => options.WithAutoConversion());
 
             if (expectedResponse.Errors is null)
                 response.Errors.Should().BeNull();
-            else {
+            else
+            {
                 using (new AssertionScope())
                 {
                     response.Errors.Should().NotBeNull();
@@ -95,7 +97,7 @@ public async Task<IGraphQLResponse> DeserializeToUnknownType(Type dataType, Stre
         {
             MethodInfo mi = Serializer.GetType().GetMethod("DeserializeFromUtf8StreamAsync", BindingFlags.Instance | BindingFlags.Public);
             MethodInfo mi2 = mi.MakeGenericMethod(dataType);
-            var task = (Task) mi2.Invoke(Serializer, new object[] { stream, CancellationToken.None });
+            var task = (Task)mi2.Invoke(Serializer, new object[] { stream, CancellationToken.None });
             await task;
             var resultProperty = task.GetType().GetProperty("Result", BindingFlags.Public | BindingFlags.Instance);
             var result = resultProperty.GetValue(task);
@@ -105,9 +107,8 @@ public async Task<IGraphQLResponse> DeserializeToUnknownType(Type dataType, Stre
         [Fact]
         public async void CanDeserializeExtensions()
         {
-
             var response = await ChatClient.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
-                    () => new { extensionsTest = "" })
+                                                           () => new { extensionsTest = "" })
                 ;
 
             response.Errors.Should().NotBeNull();
@@ -134,8 +135,8 @@ query Droid($id: String!) {
 				    name
 				  }
 				}",
-                new { id = id.ToString() },
-                "Human");
+                                                    new { id = id.ToString() },
+                                                    "Human");
 
             var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
@@ -152,7 +153,6 @@ public async void CanDoSerializationWithPredefinedTypes()
             Assert.Equal(message, response.Data.AddMessage.Content);
         }
 
-        
         public class WithNullable
         {
             public int? NullableInt { get; set; }
@@ -172,5 +172,25 @@ public void CanSerializeNullableInt()
 
             action.Should().NotThrow();
         }
+
+        public class WithNullableStruct
+        {
+            public DateTime? NullableStruct { get; set; }
+        }
+
+        [Fact]
+        public void CanSerializeNullableStruct()
+        {
+            Action action = () => Serializer.SerializeToString(new GraphQLRequest
+            {
+                Query = "{}",
+                Variables = new WithNullableStruct
+                {
+                    NullableStruct = DateTime.Now
+                }
+            });
+
+            action.Should().NotThrow();
+        }
     }
 }

From b5331ff25a580f1a38030f4720c6d0cad8c5e100 Mon Sep 17 00:00:00 2001
From: Eilon Lipton <Eilon@users.noreply.github.com>
Date: Mon, 1 Jun 2020 15:32:21 -0700
Subject: [PATCH 294/455] Readme updates

- Changed HTTP URL to HTTPS
- Fixed list formatting
- Added sample to show creation of GraphQLHttpClient
---
 README.md | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index f748d12c..1e787251 100644
--- a/README.md
+++ b/README.md
@@ -6,11 +6,19 @@ A GraphQL Client for .NET Standard over HTTP.
 
 ## Specification:
 The Library will try to follow the following standards and documents:
-[GraphQL Specification](https://facebook.github.io/graphql/June2018)
-[GraphQL HomePage](http://graphql.org/learn)
+
+* [GraphQL Specification](https://facebook.github.io/graphql/June2018)
+* [GraphQL HomePage](https://graphql.org/learn)
 
 ## Usage:
 
+### Create a GraphQLHttpClient
+
+```csharp
+// To use NewtonsoftJsonSerializer, add a reference to NuGet package GraphQL.Client.Serializer.Newtonsoft
+var graphQLClient = new GraphQLHttpClient("https://api.example.com/graphql", new NewtonsoftJsonSerializer());
+```
+
 ### Create a GraphQLRequest:
 #### Simple Request:
 ```csharp
@@ -124,9 +132,10 @@ subscription.Dispose();
 ```
 
 ## Useful Links:
-[StarWars Example Server (GitHub)](https://github.com/graphql/swapi-graphql)
-[StarWars Example Server (EndPoint)](https://swapi.apis.guru/)
 
-[GitHub GraphQL API Docs](https://developer.github.com/v4/guides/forming-calls/)
-[GitHub GraphQL Explorer](https://developer.github.com/v4/explorer/)
-[GitHub GraphQL Endpoint](https://api.github.com/graphql)
+* [StarWars Example Server (GitHub)](https://github.com/graphql/swapi-graphql)
+* [StarWars Example Server (EndPoint)](https://swapi.apis.guru/)
+
+* [GitHub GraphQL API Docs](https://developer.github.com/v4/guides/forming-calls/)
+* [GitHub GraphQL Explorer](https://developer.github.com/v4/explorer/)
+* [GitHub GraphQL Endpoint](https://api.github.com/graphql)

From 87dbf3efc0d5d63851c6f37d4383670e3240ee66 Mon Sep 17 00:00:00 2001
From: Colony5 <53336327+Maydayof@users.noreply.github.com>
Date: Wed, 17 Jun 2020 09:56:49 +0200
Subject: [PATCH 295/455] Create new GraphQLHttpWebSocket instance if needed

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 1f9a3b5a..5288da0a 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -15,7 +15,7 @@ namespace GraphQL.Client.Http
 {
     public class GraphQLHttpClient : IGraphQLClient
     {
-        private readonly GraphQLHttpWebSocket _graphQlHttpWebSocket;
+        private readonly GraphQLHttpWebSocket _graphQlHttpWebSocket = null;
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
 
@@ -63,7 +63,8 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
             if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
                 HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
 
-            _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
+            if (options.UseWebSocketForQueriesAndMutations)
+                _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
         }
 
         #endregion
@@ -186,7 +187,7 @@ protected virtual void Dispose(bool disposing)
                 Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
                 _cancellationTokenSource.Cancel();
                 HttpClient.Dispose();
-                _graphQlHttpWebSocket.Dispose();
+                _graphQlHttpWebSocket?.Dispose();
                 _cancellationTokenSource.Dispose();
             }
         }

From 5dd4bfcdb56368d759dfcc47e8387b7d1a7132bc Mon Sep 17 00:00:00 2001
From: Colony5 <53336327+Maydayof@users.noreply.github.com>
Date: Wed, 17 Jun 2020 12:26:56 +0200
Subject: [PATCH 296/455] Subscriptions always use websocket connection

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 5288da0a..a9cd48e0 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -15,7 +15,7 @@ namespace GraphQL.Client.Http
 {
     public class GraphQLHttpClient : IGraphQLClient
     {
-        private readonly GraphQLHttpWebSocket _graphQlHttpWebSocket = null;
+        private GraphQLHttpWebSocket _graphQlHttpWebSocket = null;
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
 
@@ -37,12 +37,12 @@ public class GraphQLHttpClient : IGraphQLClient
         /// <summary>
         /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
         /// </summary>
-        public IObservable<Exception> WebSocketReceiveErrors => _graphQlHttpWebSocket.ReceiveErrors;
+        public IObservable<Exception> WebSocketReceiveErrors => GetGraphQLHttpWebSocket().ReceiveErrors;
 
         /// <summary>
         /// the websocket connection state
         /// </summary>
-        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => _graphQlHttpWebSocket.ConnectionState;
+        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => GetGraphQLHttpWebSocket().ConnectionState;
 
         #region Constructors
 
@@ -75,7 +75,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
         public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             if (Options.UseWebSocketForQueriesAndMutations)
-                return await _graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
+                return await GetGraphQLHttpWebSocket().SendRequest<TResponse>(request, cancellationToken);
 
             return await SendHttpRequestAsync<TResponse>(request, cancellationToken);
         }
@@ -96,7 +96,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
             if (_subscriptionStreams.ContainsKey(key))
                 return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
+            var observable = GetGraphQLHttpWebSocket().CreateSubscriptionStream<TResponse>(request);
 
             _subscriptionStreams.TryAdd(key, observable);
             return observable;
@@ -113,7 +113,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
             if (_subscriptionStreams.ContainsKey(key))
                 return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+            var observable = GetGraphQLHttpWebSocket().CreateSubscriptionStream<TResponse>(request, exceptionHandler);
             _subscriptionStreams.TryAdd(key, observable);
             return observable;
         }
@@ -124,7 +124,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         /// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
         /// </summary>
         /// <returns></returns>
-        public Task InitializeWebsocketConnection() => _graphQlHttpWebSocket.InitializeWebSocket();
+        public Task InitializeWebsocketConnection() => GetGraphQLHttpWebSocket().InitializeWebSocket();
 
         #region Private Methods
 
@@ -158,6 +158,15 @@ private Uri GetWebSocketUri()
             return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}");
         }
 
+        private GraphQLHttpWebSocket GetGraphQLHttpWebSocket()
+        {
+            //no instance
+            if (_graphQlHttpWebSocket == null)
+                _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
+
+            return _graphQlHttpWebSocket;
+        }
+
         #endregion
 
         #region IDisposable

From 3106d0e5109d0d5a1cd0d77d3dffaaab0d93076a Mon Sep 17 00:00:00 2001
From: Colony5 <53336327+Maydayof@users.noreply.github.com>
Date: Mon, 22 Jun 2020 13:49:03 +0200
Subject: [PATCH 297/455] Use Lazy<GraphQLHttpWebSocket> instead of singleton
 pattern

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 30 +++++++++----------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index a9cd48e0..8d312baa 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -15,7 +15,9 @@ namespace GraphQL.Client.Http
 {
     public class GraphQLHttpClient : IGraphQLClient
     {
-        private GraphQLHttpWebSocket _graphQlHttpWebSocket = null;
+        private readonly Lazy<GraphQLHttpWebSocket> _lazyHttpWebSocket;
+        private GraphQLHttpWebSocket _graphQlHttpWebSocket => _lazyHttpWebSocket.Value;
+
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
 
@@ -37,12 +39,12 @@ public class GraphQLHttpClient : IGraphQLClient
         /// <summary>
         /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
         /// </summary>
-        public IObservable<Exception> WebSocketReceiveErrors => GetGraphQLHttpWebSocket().ReceiveErrors;
+        public IObservable<Exception> WebSocketReceiveErrors => _graphQlHttpWebSocket.ReceiveErrors;
 
         /// <summary>
         /// the websocket connection state
         /// </summary>
-        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => GetGraphQLHttpWebSocket().ConnectionState;
+        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => _graphQlHttpWebSocket.ConnectionState;
 
         #region Constructors
 
@@ -63,8 +65,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
             if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
                 HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
 
-            if (options.UseWebSocketForQueriesAndMutations)
-                _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
+            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(() => new GraphQLHttpWebSocket(GetWebSocketUri(), this));
         }
 
         #endregion
@@ -75,7 +76,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
         public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             if (Options.UseWebSocketForQueriesAndMutations)
-                return await GetGraphQLHttpWebSocket().SendRequest<TResponse>(request, cancellationToken);
+                return await _graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
 
             return await SendHttpRequestAsync<TResponse>(request, cancellationToken);
         }
@@ -96,7 +97,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
             if (_subscriptionStreams.ContainsKey(key))
                 return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = GetGraphQLHttpWebSocket().CreateSubscriptionStream<TResponse>(request);
+            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
 
             _subscriptionStreams.TryAdd(key, observable);
             return observable;
@@ -113,7 +114,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
             if (_subscriptionStreams.ContainsKey(key))
                 return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = GetGraphQLHttpWebSocket().CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
             _subscriptionStreams.TryAdd(key, observable);
             return observable;
         }
@@ -124,7 +125,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         /// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
         /// </summary>
         /// <returns></returns>
-        public Task InitializeWebsocketConnection() => GetGraphQLHttpWebSocket().InitializeWebSocket();
+        public Task InitializeWebsocketConnection() => _graphQlHttpWebSocket.InitializeWebSocket();
 
         #region Private Methods
 
@@ -158,15 +159,6 @@ private Uri GetWebSocketUri()
             return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}");
         }
 
-        private GraphQLHttpWebSocket GetGraphQLHttpWebSocket()
-        {
-            //no instance
-            if (_graphQlHttpWebSocket == null)
-                _graphQlHttpWebSocket = new GraphQLHttpWebSocket(GetWebSocketUri(), this);
-
-            return _graphQlHttpWebSocket;
-        }
-
         #endregion
 
         #region IDisposable
@@ -196,7 +188,7 @@ protected virtual void Dispose(bool disposing)
                 Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
                 _cancellationTokenSource.Cancel();
                 HttpClient.Dispose();
-                _graphQlHttpWebSocket?.Dispose();
+                _lazyHttpWebSocket?.Value.Dispose();
                 _cancellationTokenSource.Dispose();
             }
         }

From d644f032b359a9547348358e1864c1254230ebff Mon Sep 17 00:00:00 2001
From: Maydayof <53336327+Maydayof@users.noreply.github.com>
Date: Mon, 22 Jun 2020 15:15:00 +0200
Subject: [PATCH 298/455] Update src/GraphQL.Client/GraphQLHttpClient.cs

Dispose if has value

Co-authored-by: Alexander Rose <alex@rose-a.de>
---
 src/GraphQL.Client/GraphQLHttpClient.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 8d312baa..3ecb12b1 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -188,7 +188,7 @@ protected virtual void Dispose(bool disposing)
                 Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
                 _cancellationTokenSource.Cancel();
                 HttpClient.Dispose();
-                _lazyHttpWebSocket?.Value.Dispose();
+                if(_lazyHttpWebSocket?.HasValue) _lazyHttpWebSocket?.Value.Dispose();
                 _cancellationTokenSource.Dispose();
             }
         }

From 1de57669101a4d7687d0440059a442cd915037cf Mon Sep 17 00:00:00 2001
From: Colony5 <53336327+Maydayof@users.noreply.github.com>
Date: Mon, 22 Jun 2020 15:25:35 +0200
Subject: [PATCH 299/455] Dispose HttpWebSocket if created

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 3ecb12b1..f4c62977 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -188,7 +188,8 @@ protected virtual void Dispose(bool disposing)
                 Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
                 _cancellationTokenSource.Cancel();
                 HttpClient.Dispose();
-                if(_lazyHttpWebSocket?.HasValue) _lazyHttpWebSocket?.Value.Dispose();
+                if ( (bool)(_lazyHttpWebSocket?.IsValueCreated) )
+                    _lazyHttpWebSocket?.Value.Dispose();
                 _cancellationTokenSource.Dispose();
             }
         }

From e11d0674f59162bd2f65c0f5ddbbf61b810b9366 Mon Sep 17 00:00:00 2001
From: Colony5 <53336327+Maydayof@users.noreply.github.com>
Date: Mon, 22 Jun 2020 15:34:57 +0200
Subject: [PATCH 300/455] _lazyHttpWebSocket is not null

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index f4c62977..ea828ec1 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -188,8 +188,8 @@ protected virtual void Dispose(bool disposing)
                 Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
                 _cancellationTokenSource.Cancel();
                 HttpClient.Dispose();
-                if ( (bool)(_lazyHttpWebSocket?.IsValueCreated) )
-                    _lazyHttpWebSocket?.Value.Dispose();
+                if ( _lazyHttpWebSocket.IsValueCreated )
+                    _lazyHttpWebSocket.Value.Dispose();
                 _cancellationTokenSource.Dispose();
             }
         }

From e0000105b070acacce0866291217ec70705abb8c Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 15 Aug 2020 10:32:19 +0200
Subject: [PATCH 301/455] add data provided by bjorg to deserializaiton test

---
 .../TestData/DeserializeResponseTestData.cs   | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
index 5f1dcdf5..31d02eed 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -99,6 +99,21 @@ public IEnumerator<object[]> GetEnumerator()
                         }
                     })
             };
+
+            // add test for github issue #230 : https://github.com/graphql-dotnet/graphql-client/issues/230
+            yield return new object[] {
+                "{\"data\":{\"getMyModelType\":{\"id\":\"foo\",\"title\":\"The best Foo movie!\"}}}",
+                new GraphQLResponse<GetMyModelTypeResponse> {
+                    Data = new GetMyModelTypeResponse
+                    {
+                        getMyModelType = new Movie
+                        {
+                            id = "foo",
+                            title = "The best Foo movie!"
+                        }
+                    },
+                }
+            };
         }
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
@@ -112,4 +127,16 @@ public class Friend
         public string Id { get; set; }
         public string? Name { get; set; }
     }
+
+    public class GetMyModelTypeResponse
+    {
+        //--- Properties ---
+        public Movie getMyModelType { get; set; }
+    }
+    public class Movie
+    {
+        //--- Properties ---
+        public string id { get; set; }
+        public string title { get; set; }
+    }
 }

From 73ce1f2377b547f27ca5352cd09375831473d564 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 15 Aug 2020 11:30:30 +0200
Subject: [PATCH 302/455] migitate issue by using string.IsNullOrEmpty instead
 of null comparison

---
 .../ImmutableConverter.cs                     | 46 ++++++++-----------
 1 file changed, 18 insertions(+), 28 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index fa0a3f06..7355970d 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -32,21 +32,13 @@ public override bool CanConvert(Type typeToConvert)
             {
                 var constructor = constructors[0];
                 var parameters = constructor.GetParameters();
-                var hasParameters = parameters.Length > 0;
-                if (hasParameters)
+
+                if (parameters.Length > 0)
                 {
                     var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
-                    result = true;
-                    foreach (var parameter in parameters)
-                    {
-                        var hasMatchingProperty = properties.Any(p =>
-                                                                     NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous()));
-                        if (!hasMatchingProperty)
-                        {
-                            result = false;
-                            break;
-                        }
-                    }
+                    result = parameters
+                        .Select(parameter => properties.Any(p => NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous())))
+                        .All(hasMatchingProperty => hasMatchingProperty);
                 }
                 else
                 {
@@ -69,8 +61,8 @@ public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
                     break;
                 }
 
-                var jsonPropName = reader.GetString();
-                var normalizedPropName = ConvertAndNormalizeName(jsonPropName, options);
+                string jsonPropName = reader.GetString();
+                string normalizedPropName = ConvertAndNormalizeName(jsonPropName, options);
                 if (!namedPropertiesMapping.TryGetValue(normalizedPropName, out var obProp))
                 {
                     reader.Read();
@@ -86,7 +78,7 @@ public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
             var ctor = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First();
             var parameters = ctor.GetParameters();
             var parameterValues = new object[parameters.Length];
-            for (var index = 0; index < parameters.Length; index++)
+            for (int index = 0; index < parameters.Length; index++)
             {
                 var parameterInfo = parameters[index];
                 var value = valueOfProperty.First(prop =>
@@ -142,7 +134,7 @@ private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(Json
                     name = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
                 }
 
-                var normalizedName = NormalizeName(name, options);
+                string normalizedName = NormalizeName(name, options);
                 result.Add(normalizedName, property);
             }
 
@@ -151,8 +143,8 @@ private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(Json
 
         private static string ConvertAndNormalizeName(string name, JsonSerializerOptions options)
         {
-            var convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;
-            return options.PropertyNameCaseInsensitive ? convertedName.ToLowerInvariant() : convertedName;
+            string convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;
+            return NormalizeName(convertedName, options);
         }
 
         private static string NormalizeName(string name, JsonSerializerOptions options) => options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
@@ -162,12 +154,12 @@ internal static class NameOfPropertyAndParameter
     {
         public static bool Matches(string propertyName, string parameterName, bool anonymousType)
         {
-            if (propertyName is null && parameterName is null)
+            if (string.IsNullOrEmpty(propertyName))
             {
-                return true;
+                return string.IsNullOrEmpty(parameterName);
             }
 
-            if (propertyName is null || parameterName is null)
+            if (string.IsNullOrEmpty(parameterName))
             {
                 return false;
             }
@@ -176,12 +168,10 @@ public static bool Matches(string propertyName, string parameterName, bool anony
             {
                 return propertyName.Equals(parameterName, StringComparison.Ordinal);
             }
-            else
-            {
-                var xRight = propertyName.AsSpan(1);
-                var yRight = parameterName.AsSpan(1);
-                return char.ToLowerInvariant(propertyName[0]).CompareTo(parameterName[0]) == 0 && xRight.Equals(yRight, StringComparison.Ordinal);
-            }
+
+            var xRight = propertyName.AsSpan(1);
+            var yRight = parameterName.AsSpan(1);
+            return char.ToLowerInvariant(propertyName[0]).CompareTo(parameterName[0]) == 0 && xRight.Equals(yRight, StringComparison.Ordinal);
         }
     }
 

From a9c7a346f09042f90fbe2339ce4f9f6037224bc3 Mon Sep 17 00:00:00 2001
From: Eilon Lipton <Eilon@users.noreply.github.com>
Date: Mon, 17 Aug 2020 16:35:59 -0700
Subject: [PATCH 303/455] Update README.md

Co-authored-by: Ivan Maximov <sungam3r@yandex.ru>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1e787251..274e92e4 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@ A GraphQL Client for .NET Standard over HTTP.
 ## Specification:
 The Library will try to follow the following standards and documents:
 
-* [GraphQL Specification](https://facebook.github.io/graphql/June2018)
+* [GraphQL Specification](https://spec.graphql.org/June2018/)
 * [GraphQL HomePage](https://graphql.org/learn)
 
 ## Usage:

From 3fa088ab614dda2d7223ddd89a0335f89106101d Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Aug 2020 09:59:47 +0200
Subject: [PATCH 304/455] remove eventloop scheduler from send subscription

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 652e3f77..de25ed28 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -84,8 +84,8 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
                 Debug.WriteLine($"receive loop scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
             _requestSubscription = _requestSubject
-                .ObserveOn(_sendLoopScheduler)
-                .SelectMany(SendWebSocketRequestAsync)
+                .Select(SendWebSocketRequestAsync)
+                .Concat()
                 .Subscribe();
         }
 

From 8c763ad9b4e8d9405d5556495ed51ef0486ae12e Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Aug 2020 10:19:40 +0200
Subject: [PATCH 305/455] ignore nuget dir

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index be040ad5..5c6b0a7c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@
 bin/
 obj/
 *.user
+nuget/
\ No newline at end of file

From 9e4e2d71067d98ccba01eafcce6d17a821084dfa Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Aug 2020 10:40:27 +0200
Subject: [PATCH 306/455] remove all reactive schedulers

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index de25ed28..d60d35fd 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -30,8 +30,6 @@ internal class GraphQLHttpWebSocket : IDisposable
         private readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject =
             new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
         private readonly IDisposable _requestSubscription;
-        private readonly EventLoopScheduler _receiveLoopScheduler = new EventLoopScheduler();
-        private readonly EventLoopScheduler _sendLoopScheduler = new EventLoopScheduler();
 
         private int _connectionAttempt = 0;
         private IConnectableObservable<WebsocketMessageWrapper> _incomingMessages;
@@ -80,8 +78,6 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
             _client = client;
             _buffer = new ArraySegment<byte>(new byte[8192]);
             IncomingMessageStream = GetMessageStream();
-            _receiveLoopScheduler.Schedule(() =>
-                Debug.WriteLine($"receive loop scheduler thread id: {Thread.CurrentThread.ManagedThreadId}"));
 
             _requestSubscription = _requestSubject
                 .Select(SendWebSocketRequestAsync)
@@ -436,7 +432,7 @@ private async Task ConnectAsync(CancellationToken token)
 
                 // create receiving observable
                 _incomingMessages = Observable
-                    .Defer(() => GetReceiveTask().ToObservable().ObserveOn(_receiveLoopScheduler))
+                    .Defer(() => GetReceiveTask().ToObservable())
                     .Repeat()
                     // complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
                     .Catch<WebsocketMessageWrapper, OperationCanceledException>(exception => Observable.Empty<WebsocketMessageWrapper>())
@@ -489,13 +485,13 @@ private Task BackOff()
         }
 
         private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
-            Observable.Using(() => new EventLoopScheduler(), scheduler =>
-                Observable.Create<WebsocketMessageWrapper>(async observer =>
+            Observable.Create<WebsocketMessageWrapper>(async observer =>
                 {
                     // make sure the websocket is connected
                     await InitializeWebSocket();
                     // subscribe observer to message stream
-                    var subscription = new CompositeDisposable(_incomingMessages.ObserveOn(scheduler).Subscribe(observer))
+                    var subscription = new CompositeDisposable(_incomingMessages
+                        .Subscribe(observer))
                     {
                         // register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
                         _internalCancellationTokenSource.Token.Register(observer.OnCompleted)
@@ -507,7 +503,7 @@ private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
                     Debug.WriteLine($"new incoming message subscription {hashCode} created");
 
                     return subscription;
-                }));
+                });
 
         private Task<WebsocketMessageWrapper> _receiveAsyncTask = null;
         private readonly object _receiveTaskLocker = new object();
@@ -634,10 +630,7 @@ private async Task CompleteAsync()
             _exceptionSubject?.OnCompleted();
             _exceptionSubject?.Dispose();
             _internalCancellationTokenSource.Dispose();
-
-            _sendLoopScheduler?.Dispose();
-            _receiveLoopScheduler?.Dispose();
-
+            
             Debug.WriteLine("GraphQLHttpWebSocket disposed");
         }
 

From bcbb26f8dd99e2d3fcd489eccc2f964af3384917 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Mon, 24 Aug 2020 15:42:10 +0200
Subject: [PATCH 307/455] adapt test to create 2 subscriptions as
 simultaneously as possible

---
 .../Websocket/GraphQLHttpWebSocket.cs         |  1 -
 .../WebsocketTests/Base.cs                    | 23 +++++++++++++++++--
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index d60d35fd..b61ab9b9 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -4,7 +4,6 @@
 using System.Net.Http;
 using System.Net.WebSockets;
 using System.Reactive;
-using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 00b884d3..51857ea2 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Net.WebSockets;
@@ -257,8 +258,26 @@ public async void CanConnectTwoSubscriptionsSimultaneously()
             var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(_subscriptionRequest2, callbackTester2.Invoke);
 
             Debug.WriteLine("subscribing...");
-            var messagesMonitor = observable1.Observe();
-            var joinedMonitor = observable2.Observe();
+            var blocker = new ManualResetEventSlim(false);
+            FluentTestObserver<GraphQLResponse<MessageAddedSubscriptionResult>> messagesMonitor = null;
+            FluentTestObserver<GraphQLResponse<UserJoinedSubscriptionResult>> joinedMonitor = null;
+
+            var tasks = new List<Task>
+            {
+                Task.Run(() =>
+                {
+                    blocker.Wait();
+                    messagesMonitor = observable1.Observe();
+                }),
+                Task.Run(() =>
+                {
+                    blocker.Wait();
+                    joinedMonitor = observable2.Observe();
+                })
+            };
+
+            blocker.Set();
+            await Task.WhenAll(tasks);
 
             await messagesMonitor.Should().PushAsync(1);
             messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);

From f6dc549f3fd0ec304fd10f56334dd24b308608c3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 27 Aug 2020 08:55:02 +0200
Subject: [PATCH 308/455] invoke SendWebSocketRequestAsync with
 Observable.FromAsync

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index b61ab9b9..663a7f0d 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -79,7 +79,7 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
             IncomingMessageStream = GetMessageStream();
 
             _requestSubscription = _requestSubject
-                .Select(SendWebSocketRequestAsync)
+                .Select(request => Observable.FromAsync(() => SendWebSocketRequestAsync(request)))
                 .Concat()
                 .Subscribe();
         }

From 3f17623da2487ce3b924af5893dbd153bab657a0 Mon Sep 17 00:00:00 2001
From: "Steve G. Bjorg" <steve.bjorg@gmail.com>
Date: Sun, 6 Sep 2020 01:02:25 -0700
Subject: [PATCH 309/455] added try-catch handlers for unsupported properties

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 663a7f0d..66b6edd3 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -407,8 +407,22 @@ public Task InitializeWebSocket()
 #else
                 _clientWebSocket = new ClientWebSocket();
                 _clientWebSocket.Options.AddSubProtocol("graphql-ws");
-                _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
-                _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+                try
+                {
+                    _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                }
+                catch(PlatformNotSupportedException)
+                {
+                    Debug.WriteLine("unable to set Options.ClientCertificates property; platform does not support it");
+                }
+                try
+                {
+                    _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+                }
+                catch(PlatformNotSupportedException)
+                {
+                    Debug.WriteLine("unable to set Options.UseDefaultCredentials property; platform does not support it");
+                }
                 Options.ConfigureWebsocketOptions(_clientWebSocket.Options);
 #endif
                 return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);
@@ -605,7 +619,7 @@ public void Complete()
 
         /// <summary>
         /// Task to await the completion (a.k.a. disposal) of this websocket.
-        /// </summary> 
+        /// </summary>
         /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
         public Task? Completion { get; private set; }
 
@@ -629,7 +643,7 @@ private async Task CompleteAsync()
             _exceptionSubject?.OnCompleted();
             _exceptionSubject?.Dispose();
             _internalCancellationTokenSource.Dispose();
-            
+
             Debug.WriteLine("GraphQLHttpWebSocket disposed");
         }
 

From 4beeea32ed6f711dcb3d90bfd3762ec754a3f545 Mon Sep 17 00:00:00 2001
From: "Steve G. Bjorg" <steve.bjorg@gmail.com>
Date: Sun, 6 Sep 2020 01:08:58 -0700
Subject: [PATCH 310/455] fix whitespace changes

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 66b6edd3..b64e93aa 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -619,7 +619,7 @@ public void Complete()
 
         /// <summary>
         /// Task to await the completion (a.k.a. disposal) of this websocket.
-        /// </summary>
+        /// </summary> 
         /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
         public Task? Completion { get; private set; }
 
@@ -643,7 +643,7 @@ private async Task CompleteAsync()
             _exceptionSubject?.OnCompleted();
             _exceptionSubject?.Dispose();
             _internalCancellationTokenSource.Dispose();
-
+            
             Debug.WriteLine("GraphQLHttpWebSocket disposed");
         }
 

From d63b1d5fc106b56d7206fc1a1c4936bda29f7c83 Mon Sep 17 00:00:00 2001
From: "Steve G. Bjorg" <steve.bjorg@gmail.com>
Date: Tue, 8 Sep 2020 07:48:07 -0700
Subject: [PATCH 311/455] formatting

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index b64e93aa..fec76d34 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -411,7 +411,7 @@ public Task InitializeWebSocket()
                 {
                     _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
                 }
-                catch(PlatformNotSupportedException)
+                catch (PlatformNotSupportedException)
                 {
                     Debug.WriteLine("unable to set Options.ClientCertificates property; platform does not support it");
                 }
@@ -419,7 +419,7 @@ public Task InitializeWebSocket()
                 {
                     _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                 }
-                catch(PlatformNotSupportedException)
+                catch (PlatformNotSupportedException)
                 {
                     Debug.WriteLine("unable to set Options.UseDefaultCredentials property; platform does not support it");
                 }

From 9ee154377cfdb6a41af6569db398ddd7135e3e72 Mon Sep 17 00:00:00 2001
From: "Steve G. Bjorg" <steve.bjorg@gmail.com>
Date: Tue, 8 Sep 2020 12:22:53 -0700
Subject: [PATCH 312/455] allow wss:// scheme, preserve uri query parameters

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index ea828ec1..9b3b86ae 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -66,6 +66,10 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
                 HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
 
             _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(() => new GraphQLHttpWebSocket(GetWebSocketUri(), this));
+            if ((Options.EndPoint?.Scheme == "wss") || (Options.EndPoint?.Scheme == "ws"))
+            {
+                Options.UseWebSocketForQueriesAndMutations = true;
+            }
         }
 
         #endregion
@@ -155,8 +159,12 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TRespons
 
         private Uri GetWebSocketUri()
         {
-            string webSocketSchema = Options.EndPoint.Scheme == "https" ? "wss" : "ws";
-            return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}");
+            string webSocketSchema = Options.EndPoint.Scheme == "https"
+                ? "wss"
+                : Options.EndPoint.Scheme == "http"
+                ? "ws"
+                : Options.EndPoint.Scheme;
+            return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}{Options.EndPoint.Query}");
         }
 
         #endregion

From ab826c3002f5497b810fd7bd5a9b64a8cd9fda27 Mon Sep 17 00:00:00 2001
From: "Steve G. Bjorg" <steve.bjorg@gmail.com>
Date: Tue, 8 Sep 2020 12:37:36 -0700
Subject: [PATCH 313/455] Revert "allow wss:// scheme, preserve uri query
 parameters"

This reverts commit 9ee154377cfdb6a41af6569db398ddd7135e3e72.
---
 src/GraphQL.Client/GraphQLHttpClient.cs | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 9b3b86ae..ea828ec1 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -66,10 +66,6 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
                 HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
 
             _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(() => new GraphQLHttpWebSocket(GetWebSocketUri(), this));
-            if ((Options.EndPoint?.Scheme == "wss") || (Options.EndPoint?.Scheme == "ws"))
-            {
-                Options.UseWebSocketForQueriesAndMutations = true;
-            }
         }
 
         #endregion
@@ -159,12 +155,8 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TRespons
 
         private Uri GetWebSocketUri()
         {
-            string webSocketSchema = Options.EndPoint.Scheme == "https"
-                ? "wss"
-                : Options.EndPoint.Scheme == "http"
-                ? "ws"
-                : Options.EndPoint.Scheme;
-            return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}{Options.EndPoint.Query}");
+            string webSocketSchema = Options.EndPoint.Scheme == "https" ? "wss" : "ws";
+            return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}");
         }
 
         #endregion

From d1199a11db6943a7cda3d587d335cf50c926a0e2 Mon Sep 17 00:00:00 2001
From: "Steve G. Bjorg" <steve.bjorg@gmail.com>
Date: Tue, 8 Sep 2020 20:10:03 -0700
Subject: [PATCH 314/455] added readme note

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 274e92e4..32d35da0 100644
--- a/README.md
+++ b/README.md
@@ -139,3 +139,9 @@ subscription.Dispose();
 * [GitHub GraphQL API Docs](https://developer.github.com/v4/guides/forming-calls/)
 * [GitHub GraphQL Explorer](https://developer.github.com/v4/explorer/)
 * [GitHub GraphQL Endpoint](https://api.github.com/graphql)
+
+## Blazor WebAssembly Limitations
+
+Blazor WebAssembly differs from other platforms as it does not support all features of other .NET runtime implementations. For instance, the following WebSocket options properties are not supported and will not be set:
+* [ClientCertificates](https://docs.microsoft.com/en-us/dotnet/api/system.net.websockets.clientwebsocketoptions.clientcertificates?view=netcore-3.1#System_Net_WebSockets_ClientWebSocketOptions_ClientCertificates)
+* [UseDefaultCredentials](https://docs.microsoft.com/en-us/dotnet/api/system.net.websockets.clientwebsocketoptions.usedefaultcredentials?view=netcore-3.1)

From 94a1e32520fc20d7829aecfc2d4ca5f97456f62e Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 15 Sep 2020 22:02:34 +0200
Subject: [PATCH 315/455] handle WebSocket url scheme

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 15 ++++---------
 src/GraphQL.Client/UriExtensions.cs     | 28 +++++++++++++++++++++++++
 2 files changed, 32 insertions(+), 11 deletions(-)
 create mode 100644 src/GraphQL.Client/UriExtensions.cs

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index ea828ec1..21485f01 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -55,7 +55,7 @@ public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serialize
         public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer) : this(configure.New(), serializer) { }
 
         public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer) : this(options, serializer, new HttpClient(options.HttpMessageHandler)) { }
-        
+
         public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
         {
             Options = options ?? throw new ArgumentNullException(nameof(options));
@@ -65,7 +65,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
             if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
                 HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
 
-            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(() => new GraphQLHttpWebSocket(GetWebSocketUri(), this));
+            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(() => new GraphQLHttpWebSocket(Options.EndPoint.GetWebSocketUri(), this));
         }
 
         #endregion
@@ -75,7 +75,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
         /// <inheritdoc />
         public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
-            if (Options.UseWebSocketForQueriesAndMutations)
+            if (Options.UseWebSocketForQueriesAndMutations || Options.EndPoint.HasWebSocketScheme())
                 return await _graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
 
             return await SendHttpRequestAsync<TResponse>(request, cancellationToken);
@@ -132,7 +132,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var preprocessedRequest = await Options.PreprocessRequest(request, this);
-            
+
             using var httpRequestMessage = preprocessedRequest.ToHttpRequestMessage(Options, JsonSerializer);
             using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
 
@@ -152,13 +152,6 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TRespons
 
             throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
         }
-
-        private Uri GetWebSocketUri()
-        {
-            string webSocketSchema = Options.EndPoint.Scheme == "https" ? "wss" : "ws";
-            return new Uri($"{webSocketSchema}://{Options.EndPoint.Host}:{Options.EndPoint.Port}{Options.EndPoint.AbsolutePath}");
-        }
-
         #endregion
 
         #region IDisposable
diff --git a/src/GraphQL.Client/UriExtensions.cs b/src/GraphQL.Client/UriExtensions.cs
new file mode 100644
index 00000000..77156a4b
--- /dev/null
+++ b/src/GraphQL.Client/UriExtensions.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace GraphQL.Client.Http
+{
+    public static class UriExtensions
+    {
+        /// <summary>
+        /// Returns true if <see cref="Uri.Scheme"/> equals "wss" or "ws"
+        /// </summary>
+        /// <param name="uri"></param>
+        /// <returns></returns>
+        public static bool HasWebSocketScheme(this Uri uri) => uri.Scheme.Equals("wss") || uri.Scheme.Equals("ws");
+
+        /// <summary>
+        /// Infers the websocket uri from <paramref name="uri"/>.
+        /// </summary>
+        /// <param name="uri"></param>
+        /// <returns></returns>
+        public static Uri GetWebSocketUri(this Uri uri)
+        {
+            if (uri.HasWebSocketScheme())
+                return uri;
+
+            string webSocketScheme = uri.Scheme == "https" ? "wss" : "ws";
+            return new Uri($"{webSocketScheme}://{uri.Host}:{uri.Port}{uri.AbsolutePath}");
+        }
+    }
+}

From b5b036583f89a728ed6cfa75c480881545956cb6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 15 Sep 2020 22:13:30 +0200
Subject: [PATCH 316/455] add test for websocket scheme

---
 tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 51857ea2..4f90c1a5 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -70,6 +70,16 @@ public async void CanSendRequestViaWebsocket()
             response.Data.AddMessage.Content.Should().Be(message);
         }
 
+        [Fact]
+        public async void CanUseWebSocketScheme()
+        {
+            ChatClient.Options.EndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
+            await ChatClient.InitializeWebsocketConnection();
+            const string message = "some random testing message";
+            var response = await ChatClient.AddMessageAsync(message);
+            response.Data.AddMessage.Content.Should().Be(message);
+        }
+
         [Fact]
         public async void WebsocketRequestCanBeCancelled()
         {

From fa944ec4f417ef2ad60e78be4f8b1c3505ecf39b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 15 Sep 2020 22:22:58 +0200
Subject: [PATCH 317/455] append query in GetWebSocketUri()

---
 src/GraphQL.Client/UriExtensions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/UriExtensions.cs b/src/GraphQL.Client/UriExtensions.cs
index 77156a4b..a3ab2b04 100644
--- a/src/GraphQL.Client/UriExtensions.cs
+++ b/src/GraphQL.Client/UriExtensions.cs
@@ -22,7 +22,7 @@ public static Uri GetWebSocketUri(this Uri uri)
                 return uri;
 
             string webSocketScheme = uri.Scheme == "https" ? "wss" : "ws";
-            return new Uri($"{webSocketScheme}://{uri.Host}:{uri.Port}{uri.AbsolutePath}");
+            return new Uri($"{webSocketScheme}://{uri.Host}:{uri.Port}{uri.PathAndQuery}");
         }
     }
 }

From c62301b4bc9b7075fab2c7f702e1bbd7788b417d Mon Sep 17 00:00:00 2001
From: Dimitrie Stefanescu <didimitrie@gmail.com>
Date: Sat, 29 Aug 2020 11:49:28 +0100
Subject: [PATCH 318/455] fix(ws): added switch statement to handle close
 message events

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 27 ++++++++++++-------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index fec76d34..da9e8a9e 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -114,6 +114,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         {
                             Id = startRequest.Id,
                             Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+                            Payload = new GraphQLRequest()
                         };
 
                         var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
@@ -563,16 +564,22 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
                 _internalCancellationToken.ThrowIfCancellationRequested();
                 ms.Seek(0, SeekOrigin.Begin);
 
-                if (webSocketReceiveResult.MessageType == WebSocketMessageType.Text)
+                switch (webSocketReceiveResult.MessageType)
                 {
-                    var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
-                    response.MessageBytes = ms.ToArray();
-                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
-                    return response;
-                }
-                else
-                {
-                    throw new NotSupportedException("binary websocket messages are not supported");
+                    case WebSocketMessageType.Text:
+                        var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+                        response.MessageBytes = ms.ToArray();
+                        Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+                        return response;
+
+                    case WebSocketMessageType.Close:
+                        var closeResponse = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+                        closeResponse.MessageBytes = ms.ToArray();
+                        Debug.WriteLine($"Connection closed by the server.");
+                        throw new Exception("Connection closed by the server.");
+
+                    case WebSocketMessageType.Binary:
+                        throw new NotSupportedException("binary websocket messages are not supported");
                 }
             }
             catch (Exception e)
@@ -643,7 +650,7 @@ private async Task CompleteAsync()
             _exceptionSubject?.OnCompleted();
             _exceptionSubject?.Dispose();
             _internalCancellationTokenSource.Dispose();
-            
+
             Debug.WriteLine("GraphQLHttpWebSocket disposed");
         }
 

From 15c5e3668d9e6c91192e8cccbcad0a8ee5e47b99 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 15 Sep 2020 22:40:40 +0200
Subject: [PATCH 319/455] cherrypick webSocketReceiveResult default case from
 pr 272

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index da9e8a9e..2f4a86f4 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -578,8 +578,9 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
                         Debug.WriteLine($"Connection closed by the server.");
                         throw new Exception("Connection closed by the server.");
 
-                    case WebSocketMessageType.Binary:
-                        throw new NotSupportedException("binary websocket messages are not supported");
+                    default:
+                        throw new NotSupportedException($"Websocket message type {webSocketReceiveResult.MessageType} not supported.");
+
                 }
             }
             catch (Exception e)

From 501ba3c26c2a1c9cc13d930bfacd4588e53a0b60 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 16 Sep 2020 20:39:26 +0200
Subject: [PATCH 320/455] fix uri conversion and add some tests to prove its
 working

---
 src/GraphQL.Client/UriExtensions.cs           | 14 ++++--
 .../UriExtensionTests.cs                      | 47 +++++++++++++++++++
 2 files changed, 58 insertions(+), 3 deletions(-)
 create mode 100644 tests/GraphQL.Integration.Tests/UriExtensionTests.cs

diff --git a/src/GraphQL.Client/UriExtensions.cs b/src/GraphQL.Client/UriExtensions.cs
index a3ab2b04..ad40a5bf 100644
--- a/src/GraphQL.Client/UriExtensions.cs
+++ b/src/GraphQL.Client/UriExtensions.cs
@@ -9,7 +9,7 @@ public static class UriExtensions
         /// </summary>
         /// <param name="uri"></param>
         /// <returns></returns>
-        public static bool HasWebSocketScheme(this Uri uri) => uri.Scheme.Equals("wss") || uri.Scheme.Equals("ws");
+        public static bool HasWebSocketScheme(this Uri uri) => uri.Scheme.Equals("wss", StringComparison.OrdinalIgnoreCase) || uri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase);
 
         /// <summary>
         /// Infers the websocket uri from <paramref name="uri"/>.
@@ -21,8 +21,16 @@ public static Uri GetWebSocketUri(this Uri uri)
             if (uri.HasWebSocketScheme())
                 return uri;
 
-            string webSocketScheme = uri.Scheme == "https" ? "wss" : "ws";
-            return new Uri($"{webSocketScheme}://{uri.Host}:{uri.Port}{uri.PathAndQuery}");
+            string webSocketScheme;
+
+            if (uri.Scheme == Uri.UriSchemeHttps)
+                webSocketScheme = "wss";
+            else if (uri.Scheme == Uri.UriSchemeHttp)
+                webSocketScheme = "ws";
+            else
+                throw new NotSupportedException($"cannot infer websocket uri from uri scheme {uri.Scheme}");
+
+            return new UriBuilder(uri){Scheme = webSocketScheme}.Uri;
         }
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
new file mode 100644
index 00000000..29c98c6a
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
@@ -0,0 +1,47 @@
+using System;
+using FluentAssertions;
+using GraphQL.Client.Http;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+    public class UriExtensionTests
+    {
+        [Theory]
+        [InlineData("http://thats-not-a-websocket-url.net", false)]
+        [InlineData("https://thats-not-a-websocket-url.net", false)]
+        [InlineData("ftp://thats-not-a-websocket-url.net", false)]
+        [InlineData("ws://that-is-a-websocket-url.net", true)]
+        [InlineData("wss://that-is-a-websocket-url.net", true)]
+        [InlineData("WS://that-is-a-websocket-url.net", true)]
+        [InlineData("WSS://that-is-a-websocket-url.net", true)]
+        public void HasWebSocketSchemaTest(string url, bool result)
+        {
+            new Uri(url).HasWebSocketScheme().Should().Be(result);
+        }
+
+        [Theory]
+        [InlineData("http://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
+        [InlineData("https://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
+        [InlineData("HTTP://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
+        [InlineData("HTTPS://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
+        [InlineData("ws://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
+        [InlineData("wss://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
+        [InlineData("https://this-url-can-be-converted.net/and/all/elements/?are#preserved", true, "wss://this-url-can-be-converted.net/and/all/elements/?are#preserved")]
+        [InlineData("ftp://this-url-can-be-converted.net", false, null)]
+        // AppSync example
+        [InlineData("wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=", true, "wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=")]
+        public void GetWebSocketUriTest(string input, bool canConvert, string result)
+        {
+            var inputUri = new Uri(input);
+            if (canConvert)
+            {
+                inputUri.GetWebSocketUri().Should().BeEquivalentTo(new Uri(result));
+            }
+            else
+            {
+                inputUri.Invoking(uri => uri.GetWebSocketUri()).Should().Throw<NotSupportedException>();
+            }
+        }
+    }
+}

From 01367df92c0b01e68713086880dc84e41ec6a472 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 16 Sep 2020 20:43:56 +0200
Subject: [PATCH 321/455] fix uri in test

---
 tests/GraphQL.Integration.Tests/UriExtensionTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
index 29c98c6a..1298ca11 100644
--- a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
+++ b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
@@ -28,7 +28,7 @@ public void HasWebSocketSchemaTest(string url, bool result)
         [InlineData("ws://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
         [InlineData("wss://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
         [InlineData("https://this-url-can-be-converted.net/and/all/elements/?are#preserved", true, "wss://this-url-can-be-converted.net/and/all/elements/?are#preserved")]
-        [InlineData("ftp://this-url-can-be-converted.net", false, null)]
+        [InlineData("ftp://this-url-cannot-be-converted.net", false, null)]
         // AppSync example
         [InlineData("wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=", true, "wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=")]
         public void GetWebSocketUriTest(string input, bool canConvert, string result)

From a80c995e5e63cd54b2843e0aea88856f63621de4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 16 Sep 2020 22:05:16 +0200
Subject: [PATCH 322/455] add constant case enum converters for both
 serializers

---
 .../GraphQL.Client.LocalExecution.csproj         |  1 +
 .../GraphQLLocalExecutionClient.cs               |  7 ++++---
 .../ConstantCaseEnumConverter.cs}                |  8 ++++----
 .../GraphQL.Client.Serializer.Newtonsoft.csproj  |  1 +
 .../NewtonsoftJsonSerializer.cs                  |  3 ++-
 .../ConstantCaseJsonNamingPolicy.cs              | 10 ++++++++++
 ...aphQL.Client.Serializer.SystemTextJson.csproj |  4 ++++
 .../SystemTextJsonSerializer.cs                  |  4 +++-
 .../NewtonsoftSerializerTest.cs                  |  2 +-
 .../SystemTextJsonSerializerTests.cs             |  3 ++-
 .../TestData/SerializeToStringTestData.cs        | 16 ++++++++++++++++
 11 files changed, 48 insertions(+), 11 deletions(-)
 rename src/{GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs => GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs} (82%)
 create mode 100644 src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index ebef7ea0..e8e162cb 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -15,6 +15,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
+    <ProjectReference Include="..\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index f8fe6503..65098ae8 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
+using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Subscription;
 using GraphQL.Types;
 using Newtonsoft.Json;
@@ -31,7 +32,7 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             Converters = new List<JsonConverter>
             {
-                new GraphQLEnumConverter()
+                new ConstantCaseEnumConverter()
             }
         };
 
@@ -50,7 +51,7 @@ public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serial
                 Schema.Initialize();
             _documentExecuter = new DocumentExecuter();
         }
-        
+
         public void Dispose() { }
 
         public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
@@ -80,7 +81,7 @@ private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionA
         {
             var result = await ExecuteAsync(request, cancellationToken);
             var stream = ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault();
-            
+
             return stream == null
                 ? Observable.Throw<GraphQLResponse<TResponse>>(new InvalidOperationException("the GraphQL execution did not return an observable"))
                 : stream.SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
similarity index 82%
rename from src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
rename to src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
index a02cf935..5eb45f73 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLEnumConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
@@ -1,13 +1,13 @@
 using System;
 using System.Linq;
 using System.Reflection;
-using GraphQL.Utilities;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
+using Panic.StringUtils.Extensions;
 
-namespace GraphQL.Client.LocalExecution
+namespace GraphQL.Client.Serializer.Newtonsoft
 {
-    public class GraphQLEnumConverter : StringEnumConverter
+    public class ConstantCaseEnumConverter : StringEnumConverter
     {
         public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
         {
@@ -29,7 +29,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
                 }
                 else
                 {
-                    writer.WriteValue(StringUtils.ToConstantCase(memberName));
+                    writer.WriteValue(memberName.ToConstantCase());
                 }
             }
         }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index 4bbcb784..f603fc93 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -9,6 +9,7 @@
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Panic.StringUtils" Version="1.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 5ec06c1a..e7cae90f 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -15,7 +15,8 @@ public class NewtonsoftJsonSerializer : IGraphQLWebsocketJsonSerializer
         public static JsonSerializerSettings DefaultJsonSerializerSettings => new JsonSerializerSettings
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
-            MissingMemberHandling = MissingMemberHandling.Ignore
+            MissingMemberHandling = MissingMemberHandling.Ignore,
+            Converters = { new ConstantCaseEnumConverter() }
         };
 
         public JsonSerializerSettings JsonSerializerSettings { get; }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
new file mode 100644
index 00000000..b2ea49eb
--- /dev/null
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
@@ -0,0 +1,10 @@
+using System.Text.Json;
+using Panic.StringUtils.Extensions;
+
+namespace GraphQL.Client.Serializer.SystemTextJson
+{
+    public class ConstantCaseJsonNamingPolicy: JsonNamingPolicy
+    {
+        public override string ConvertName(string name) => name.ToConstantCase();
+    }
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index 9433b8dd..93fe58af 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -15,4 +15,8 @@
     <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Panic.StringUtils" Version="1.0.1" />
+  </ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index a1667ec8..d0325464 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
@@ -12,7 +13,8 @@ public class SystemTextJsonSerializer : IGraphQLWebsocketJsonSerializer
     {
         public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions
         {
-            PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}
         }.SetupImmutableConverter();
 
         public JsonSerializerOptions Options { get; }
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 00b6d03b..43ade957 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -11,6 +11,6 @@ public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
     public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
     {
         public NewtonsoftSerializeNoCamelCaseTest()
-            : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings())) { }
+            : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings(){ Converters = { new ConstantCaseEnumConverter() } })) { }
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index 217c9da1..153bcd4d 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using GraphQL.Client.Serializer.SystemTextJson;
 
 namespace GraphQL.Client.Serializer.Tests
@@ -11,6 +12,6 @@ public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) {
     public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
     {
         public SystemTextJsonSerializeNoCamelCaseTest()
-            : base(new SystemTextJsonSerializer(new JsonSerializerOptions().SetupImmutableConverter())) { }
+            : base(new SystemTextJsonSerializer(new JsonSerializerOptions(){Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter())) { }
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 06208c21..e5285681 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -1,5 +1,7 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace GraphQL.Client.Serializer.Tests.TestData
 {
@@ -19,8 +21,22 @@ public IEnumerator<object[]> GetEnumerator()
                 "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"authentication\":\"an-authentication-token\"}",
                 new GraphQLRequest("simple query string"){{"authentication", "an-authentication-token"}}
             };
+            yield return new object[] {
+                "{\"query\":\"enumtest\",\"variables\":{\"enums\":[\"REGULAR\",\"PASCAL_CASE\",\"CAMEL_CASE\",\"LOWER\",\"UPPER\",\"CONSTANT_CASE\"]},\"operationName\":null}",
+                new GraphQLRequest("enumtest", new { enums = Enum.GetValues(typeof(TestEnum)).Cast<TestEnum>()})
+            };
         }
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public enum TestEnum
+        {
+            Regular,
+            PascalCase,
+            camelCase,
+            lower,
+            UPPER,
+            CONSTANT_CASE
+        }
     }
 }

From 7fe7137ff9715254be083115e29685d4c9f1aabd Mon Sep 17 00:00:00 2001
From: Steve Bjorg <steve.bjorg@gmail.com>
Date: Thu, 17 Sep 2020 08:54:24 -0700
Subject: [PATCH 323/455] check if running in WebAssembly instead of catching
 PlatformNotSupportedException

---
 .../Websocket/GraphQLHttpWebSocket.cs            | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 2f4a86f4..aba35e8f 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -408,22 +408,12 @@ public Task InitializeWebSocket()
 #else
                 _clientWebSocket = new ClientWebSocket();
                 _clientWebSocket.Options.AddSubProtocol("graphql-ws");
-                try
+                if(!System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Create("WEBASSEMBLY")))
                 {
+                    // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
                     _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
-                }
-                catch (PlatformNotSupportedException)
-                {
-                    Debug.WriteLine("unable to set Options.ClientCertificates property; platform does not support it");
-                }
-                try
-                {
                     _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                 }
-                catch (PlatformNotSupportedException)
-                {
-                    Debug.WriteLine("unable to set Options.UseDefaultCredentials property; platform does not support it");
-                }
                 Options.ConfigureWebsocketOptions(_clientWebSocket.Options);
 #endif
                 return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);
@@ -627,7 +617,7 @@ public void Complete()
 
         /// <summary>
         /// Task to await the completion (a.k.a. disposal) of this websocket.
-        /// </summary> 
+        /// </summary>
         /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
         public Task? Completion { get; private set; }
 

From c1fc64ac1eed1d9b3d7536c2a699741ce6713baf Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 17 Sep 2020 19:59:04 +0200
Subject: [PATCH 324/455] remove Panic.StringUtils dependency

---
 .../GraphQL.Client.Abstractions.csproj        |   4 +
 .../Utilities/StringExtensions.cs             |  37 ++++
 .../Utilities/StringUtils.cs                  | 193 ++++++++++++++++++
 .../ConstantCaseEnumConverter.cs              |   2 +-
 ...raphQL.Client.Serializer.Newtonsoft.csproj |   1 -
 .../ConstantCaseJsonNamingPolicy.cs           |   2 +-
 ...QL.Client.Serializer.SystemTextJson.csproj |   4 -
 7 files changed, 236 insertions(+), 7 deletions(-)
 create mode 100644 src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
 create mode 100644 src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs

diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index d7678b66..8e1faee1 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -15,4 +15,8 @@
     <PackageReference Include="System.Reactive" Version="4.3.2" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Utilities" />
+  </ItemGroup>
+
 </Project>
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
new file mode 100644
index 00000000..38c718a8
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+
+namespace GraphQL.Client.Abstractions.Utilities
+{
+    /// <summary>
+    /// Copied from https://github.com/jquense/StringUtils
+    /// </summary>
+    public static class StringExtensions
+    {
+        public static string StripIndent(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.StripIndent(str);
+
+        public static IEnumerable<string> ToWords(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToWords(str);
+
+        public static string ToUpperFirst(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToUpperFirst(str);
+
+        public static string ToLowerFirst(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToLowerFirst(str);
+
+        public static string Capitalize(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.Capitalize(str);
+
+        public static string ToCamelCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToCamelCase(str);
+
+        public static string ToConstantCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToConstantCase(str);
+
+        public static string ToUpperCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToUpperCase(str);
+
+        public static string ToLowerCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToLowerCase(str);
+
+
+        public static string ToPascalCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToPascalCase(str);
+
+
+        public static string ToKebabCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToKebabCase(str);
+
+
+        public static string ToSnakeCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToSnakeCase(str);
+    }
+}
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
new file mode 100644
index 00000000..c643fd23
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
@@ -0,0 +1,193 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace GraphQL.Client.Abstractions.Utilities
+{
+    /// <summary>
+    /// Copied from https://github.com/jquense/StringUtils
+    /// </summary>
+    public static class StringUtils
+    {
+        private static readonly Regex _reWords = new Regex(@"[A-Z\xc0-\xd6\xd8-\xde]?[a-z\xdf-\xf6\xf8-\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde]|$)|(?:[A-Z\xc0-\xd6\xd8-\xde]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde](?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])|$)|[A-Z\xc0-\xd6\xd8-\xde]?(?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\xc0-\xd6\xd8-\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\d+|(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?)*");
+        private static readonly Regex _reIndent = new Regex(@"^[ \t]*(?=\S)", RegexOptions.Multiline);
+
+        /// <summary>
+        /// Removes the leading indent from a multi-line string
+        /// </summary>
+        /// <param name="str">String</param>
+        /// <returns></returns>
+        public static string StripIndent(string str)
+        {
+            int indent = _reIndent.Matches(str).Cast<Match>().Select(m => m.Value.Length).Min();
+            return new Regex(@"^[ \t]{" + indent + "}", RegexOptions.Multiline).Replace(str, "");
+        }
+
+        /// <summary>
+        /// Split a cased string into a series of "words" excluding the seperator.
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static IEnumerable<string> ToWords(string str)
+        {
+            foreach (Match match in _reWords.Matches(str))
+            {
+                yield return match.Value;
+            }
+        }
+
+        /// <summary>
+        /// Uppercase the first character in a string, leaving the rest of the string as is
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns>a string with the first character uppercased</returns>
+        public static string ToUpperFirst(string str) => ChangeCaseFirst(str, c => c.ToUpperInvariant());
+
+        /// <summary>
+        /// Lowercase the first character in a string, leaving the rest of the string as is
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns>a string with the first character lowercased</returns>
+        public static string ToLowerFirst(string str) => ChangeCaseFirst(str, c => c.ToLowerInvariant());
+
+        /// <summary>
+        /// Capitalizes a string, lowercasing the entire string and uppercasing the first character
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns>a capitalized string</returns>
+        public static string Capitalize(string str) => ToUpperFirst(str.ToLowerInvariant());
+
+        /// <summary>
+        /// Converts a string to camelCase.
+        /// </summary>
+        /// <example>
+        ///     <code>StringUtils.ToCamelCase("FOOBAR")  // "foobar"</code>
+        ///     <code>StringUtils.ToCamelCase("FOO_BAR") // "fooBar"</code>
+        ///     <code>StringUtils.ToCamelCase("FooBar")  // "fooBar"</code>
+        ///     <code>StringUtils.ToCamelCase("foo bar") // "fooBar"</code>
+        /// </example>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string ToCamelCase(string str) =>
+            ChangeCase(str, (word, index) =>
+                (index == 0 ? word.ToLowerInvariant() : Capitalize(word)));
+
+        /// <summary>
+        /// Convert a string to CONSTANT_CASE
+        /// </summary>
+        /// <example>
+        ///     <code>StringUtils.ToConstantCase("fOo BaR") // "FOO_BAR"</code>
+        ///     <code>StringUtils.ToConstantCase("FooBar")  // "FOO_BAR"</code>
+        ///     <code>StringUtils.ToConstantCase("Foo Bar") // "FOO_BAR"</code>
+        /// </example>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string ToConstantCase(string str) => ChangeCase(str, "_", w => w.ToUpperInvariant());
+
+        /// <summary>
+        /// Convert a string to UPPERCASE
+        /// </summary>
+        /// <example>
+        ///     <code>StringUtils.ToUpperCase("foobar")  // "FOOBAR"</code>
+        ///     <code>StringUtils.ToUpperCase("FOO_BAR") // "FOO BAR"</code>
+        ///     <code>StringUtils.ToUpperCase("FooBar")  // "FOO BAR"</code>
+        ///     <code>StringUtils.ToUpperCase("Foo Bar") // "FOO BAR"</code>
+        /// </example>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string ToUpperCase(string str) => ChangeCase(str, " ", (word) => word.ToUpperInvariant());
+
+        /// <summary>
+        /// Convert a string to lowercase
+        /// </summary>
+        /// <example>
+        ///     <code>StringUtils.ToLowerCase("FOOBAR")  // "foobar"</code>
+        ///     <code>StringUtils.ToLowerCase("FOO_BAR") // "foo bar"</code>
+        ///     <code>StringUtils.ToLowerCase("FooBar")  // "foo bar"</code>
+        ///     <code>StringUtils.ToLowerCase("Foo Bar") // "foo bar"</code>
+        /// </example>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string ToLowerCase(string str) => ChangeCase(str, " ", word => word.ToLowerInvariant());
+
+        /// <summary>
+        /// convert a string to PascalCase
+        /// </summary>
+        /// <example>
+        ///     <code>StringUtils.ToPascalCase("FOOBAR")  // "FooBar"</code>
+        ///     <code>StringUtils.ToPascalCase("FOO_BAR") // "FooBar"</code>
+        ///     <code>StringUtils.ToPascalCase("fooBar")  // "FooBar"</code>
+        ///     <code>StringUtils.ToPascalCase("Foo Bar") // "FooBar"</code>
+        /// </example>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string ToPascalCase(string str) => ChangeCase(str, Capitalize);
+
+        /// <summary>
+        /// convert a string to kebab-case
+        /// </summary>
+        /// <example>
+        ///     <code>StringUtils.ToKebabCase("FOOBAR")  // "foo-bar"</code>
+        ///     <code>StringUtils.ToKebabCase("FOO_BAR") // "foo-bar"</code>
+        ///     <code>StringUtils.ToKebabCase("fooBar")  // "foo-bar"</code>
+        ///     <code>StringUtils.ToKebabCase("Foo Bar") // "foo-bar"</code>
+        /// </example>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string ToKebabCase(string str) => ChangeCase(str, "-", word => word.ToLowerInvariant());
+
+        /// <summary>
+        /// convert a string to snake_case
+        /// </summary>
+        /// <example>
+        ///     <code>StringUtils.ToSnakeCase("FOOBAR")  // "foo_bar"</code>
+        ///     <code>StringUtils.ToSnakeCase("FOO_BAR") // "foo_bar"</code>
+        ///     <code>StringUtils.ToSnakeCase("fooBar")  // "foo_bar"</code>
+        ///     <code>StringUtils.ToSnakeCase("Foo Bar") // "foo_bar"</code>
+        /// </example>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string ToSnakeCase(string str) => ChangeCase(str, "_", word => word.ToLowerInvariant());
+
+        public static string ChangeCase(string str, Func<string, string> composer) => ChangeCase(str, "", composer);
+
+        public static string ChangeCase(string str, string sep, Func<string, string> composer) => ChangeCase(str, sep, (w, i) => composer(w));
+
+        public static string ChangeCase(string str, Func<string, int, string> composer) => ChangeCase(str, "", composer);
+
+        /// <summary>
+        /// Convert a string to a new case
+        /// </summary>
+        /// <example>
+        /// Convert a string to inverse camelCase: CAMELcASE
+        ///     <code>
+        ///         StringUtils.ChangeCase("my string", "", (word, index) => {
+        ///             word = word.ToUpperInvariant();
+        ///             if (index > 0)
+        ///                 word = StringUtils.toLowerFirst(word);
+        ///             return word
+        ///         });
+        ///         // "MYsTRING"
+        ///     </code>
+        /// </example>
+        /// <param name="str">an input string </param>
+        /// <param name="sep">a seperator string used between "words" in the string</param>
+        /// <param name="composer">a function that converts individual words to a new case</param>
+        /// <returns></returns>
+        public static string ChangeCase(string str, string sep, Func<string, int, string> composer)
+        {
+            string result = "";
+            int index = 0;
+
+            foreach (string word in ToWords(str))
+            {
+                result += ((index == 0 ? "" : sep) + composer(word, index++));
+            }
+
+            return result;
+        }
+
+        private static string ChangeCaseFirst(string str, Func<string, string> change) => change(str.Substring(0, 1)) + str.Substring(1);
+    }
+}
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
index 5eb45f73..d618a490 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
@@ -1,9 +1,9 @@
 using System;
 using System.Linq;
 using System.Reflection;
+using GraphQL.Client.Abstractions.Utilities;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
-using Panic.StringUtils.Extensions;
 
 namespace GraphQL.Client.Serializer.Newtonsoft
 {
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index f603fc93..4bbcb784 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -9,7 +9,6 @@
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="Panic.StringUtils" Version="1.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
index b2ea49eb..138b0276 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
@@ -1,5 +1,5 @@
 using System.Text.Json;
-using Panic.StringUtils.Extensions;
+using GraphQL.Client.Abstractions.Utilities;
 
 namespace GraphQL.Client.Serializer.SystemTextJson
 {
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index 93fe58af..9433b8dd 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -15,8 +15,4 @@
     <ProjectReference Include="..\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Panic.StringUtils" Version="1.0.1" />
-  </ItemGroup>
-
 </Project>

From 43407c5438c08adee07bf675a95b4b3f36f8bc7c Mon Sep 17 00:00:00 2001
From: Steve Bjorg <steve.bjorg@gmail.com>
Date: Tue, 6 Oct 2020 13:19:29 -0700
Subject: [PATCH 325/455] fix Blazor WASM check

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index aba35e8f..d8476b72 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -408,7 +408,7 @@ public Task InitializeWebSocket()
 #else
                 _clientWebSocket = new ClientWebSocket();
                 _clientWebSocket.Options.AddSubProtocol("graphql-ws");
-                if(!System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Create("WEBASSEMBLY")))
+                if(!System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Create("BROWSER")))
                 {
                     // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
                     _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;

From 0dcc99517e4b997efe07980efdec249b23c34542 Mon Sep 17 00:00:00 2001
From: Steve Bjorg <steve.bjorg@gmail.com>
Date: Tue, 6 Oct 2020 13:25:46 -0700
Subject: [PATCH 326/455] always use Debug.WriteLine()

---
 .../Websocket/GraphQLHttpWebSocket.cs         | 21 ++++++++++++-------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index aba35e8f..365c53ad 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -136,6 +136,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                                         var typedResponse =
                                             _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
                                                 response.MessageBytes);
+                                        Debug.WriteLine($"payload => {System.Text.Encoding.UTF8.GetString(response.MessageBytes)}");
                                         o.OnNext(typedResponse.Payload);
 
                                         // in case of a GraphQL error, terminate the sequence after the response has been posted
@@ -194,7 +195,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         }
                         catch (Exception e)
                         {
-                            Console.WriteLine(e);
+                            Debug.WriteLine(e);
                             throw;
                         }
 
@@ -206,7 +207,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         }
                         catch (Exception e)
                         {
-                            Console.WriteLine(e);
+                            Debug.WriteLine(e);
                             throw;
                         }
 
@@ -255,14 +256,18 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                 // unwrap and push results or throw wrapped exceptions
                 .SelectMany(t =>
                 {
-                    Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId}");
                     // if the result contains an exception, throw it on the observable
                     if (t.Item2 != null)
+                    {
+                        Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId} => {t.Item2}");
                         return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
-
-                    return t.Item1 == null
-                        ? Observable.Empty<GraphQLResponse<TResponse>>()
-                        : Observable.Return(t.Item1);
+                    }
+                    if (t.Item1 == null)
+                    {
+                        Debug.WriteLine($"empty item thread id: {Thread.CurrentThread.ManagedThreadId}");
+                        return Observable.Empty<GraphQLResponse<TResponse>>();
+                    }
+                    return Observable.Return(t.Item1);
                 })
                 // transform to hot observable and auto-connect
                 .Publish().RefCount();
@@ -319,7 +324,7 @@ public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest re
                     }
                     catch (Exception e)
                     {
-                        Console.WriteLine(e);
+                        Debug.WriteLine(e);
                         throw;
                     }
 

From 151e733342f78bf1ba2a4cc3007eac2a04f615e5 Mon Sep 17 00:00:00 2001
From: Steve Bjorg <steve.bjorg@gmail.com>
Date: Tue, 6 Oct 2020 13:44:58 -0700
Subject: [PATCH 327/455] preserve all entries in GraphQLRequest

---
 src/GraphQL.Client/GraphQLHttpRequest.cs |  2 +-
 src/GraphQL.Primitives/GraphQLRequest.cs | 10 +++++++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 00f90d4a..eb3aac14 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -16,7 +16,7 @@ public GraphQLHttpRequest(string query, object? variables = null, string? operat
         {
         }
 
-        public GraphQLHttpRequest(GraphQLRequest other): base(other.Query, other.Variables, other.OperationName)
+        public GraphQLHttpRequest(GraphQLRequest other): base(other)
         {
         }
 
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 72033552..19c7fded 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -49,6 +49,14 @@ public GraphQLRequest(string query, object? variables = null, string? operationN
             OperationName = operationName;
         }
 
+        public GraphQLRequest(IEnumerable<KeyValuePair<string, object>> values)
+        {
+            foreach(var kv in values)
+            {
+                Add(kv.Key, kv.Value);
+            }
+        }
+
         /// <summary>
         /// Returns a value that indicates whether this instance is equal to a specified object
         /// </summary>
@@ -86,7 +94,7 @@ public override int GetHashCode()
         {
             unchecked
             {
-                var hashCode = Query.GetHashCode();
+                var hashCode = Query?.GetHashCode() ?? 0;
                 hashCode = (hashCode * 397) ^ OperationName?.GetHashCode() ?? 0;
                 hashCode = (hashCode * 397) ^ Variables?.GetHashCode() ?? 0;
                 return hashCode;

From 840da16ec92416bc34a495942d2f396695894408 Mon Sep 17 00:00:00 2001
From: Steve Bjorg <steve.bjorg@gmail.com>
Date: Tue, 6 Oct 2020 14:53:31 -0700
Subject: [PATCH 328/455] make copy constructor more specific

---
 src/GraphQL.Primitives/GraphQLRequest.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 19c7fded..22074321 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -49,9 +49,9 @@ public GraphQLRequest(string query, object? variables = null, string? operationN
             OperationName = operationName;
         }
 
-        public GraphQLRequest(IEnumerable<KeyValuePair<string, object>> values)
+        public GraphQLRequest(GraphQLRequest other)
         {
-            foreach(var kv in values)
+            foreach(var kv in other)
             {
                 Add(kv.Key, kv.Value);
             }

From da8299212a42bcc4000130067a15aa8a8d608931 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 7 Oct 2020 21:53:20 +0200
Subject: [PATCH 329/455] add ConnectionParams object

---
 .../GraphQLWebSocketRequest.cs                            | 4 ++--
 src/GraphQL.Client/GraphQLHttpClientOptions.cs            | 6 ++++++
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs      | 8 ++++----
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index 623e4271..c71b4e28 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -34,9 +34,9 @@ public string Type
         /// <summary>
         /// The payload of the websocket request
         /// </summary>
-        public GraphQLRequest Payload
+        public object Payload
         {
-            get => ContainsKey(PAYLOAD_KEY) ? (GraphQLRequest)this[PAYLOAD_KEY] : null;
+            get => ContainsKey(PAYLOAD_KEY) ? this[PAYLOAD_KEY] : null;
             set => this[PAYLOAD_KEY] = value;
         }
 
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 6e2c3a46..ff36808f 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -56,5 +56,11 @@ public class GraphQLHttpClientOptions
         /// Configure additional websocket options (i.e. headers). This will not be invoked on Windows 7 when targeting .NET Framework 4.x. 
         /// </summary>
         public Action<ClientWebSocketOptions> ConfigureWebsocketOptions { get; set; } = options => { };
+
+        /// <summary>
+        /// The `ConnectionParams` object sent with the GQL_CONNECTION_INIT message on establishing a websocket connection.
+        /// See https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_connection_init.
+        /// </summary>
+        public object? WebSocketConnectionParams { get; set; } = null;
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index dfdf39c4..8bf8adee 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -105,7 +105,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                             Type = GraphQLWebSocketMessageType.GQL_START,
                             Payload = request
                         };
-                        var closeRequest = new GraphQLWebSocketRequest
+                        var stopRequest = new GraphQLWebSocketRequest
                         {
                             Id = startRequest.Id,
                             Type = GraphQLWebSocketMessageType.GQL_STOP
@@ -114,7 +114,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         {
                             Id = startRequest.Id,
                             Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                            Payload = new GraphQLRequest()
+                            Payload = Options.WebSocketConnectionParams
                         };
 
                         var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
@@ -179,8 +179,8 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
                                 try
                                 {
-                                    Debug.WriteLine($"sending close message on subscription {startRequest.Id}");
-                                    await QueueWebSocketRequest(closeRequest);
+                                    Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
+                                    await QueueWebSocketRequest(stopRequest);
                                 }
                                 // do not break on disposing
                                 catch (OperationCanceledException) { }

From 3b79495526f64f04826c33ccb15e1bdba1a74460 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 7 Oct 2020 23:40:41 +0200
Subject: [PATCH 330/455] use TryGetValue

---
 .../GraphQLWebSocketRequest.cs                              | 6 +++---
 src/GraphQL.Primitives/GraphQLRequest.cs                    | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index c71b4e28..d1ea99d5 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -18,7 +18,7 @@ public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<Gr
         /// </summary>
         public string Id
         {
-            get => ContainsKey(ID_KEY) ? (string)this[ID_KEY] : null;
+            get => TryGetValue(ID_KEY, out object value) ? (string)value : null;
             set => this[ID_KEY] = value;
         }
 
@@ -27,7 +27,7 @@ public string Id
         /// </summary>
         public string Type
         {
-            get => ContainsKey(TYPE_KEY) ? (string)this[TYPE_KEY] : null;
+            get => TryGetValue(TYPE_KEY, out object value) ? (string)value : null;
             set => this[TYPE_KEY] = value;
         }
 
@@ -36,7 +36,7 @@ public string Type
         /// </summary>
         public object Payload
         {
-            get => ContainsKey(PAYLOAD_KEY) ? this[PAYLOAD_KEY] : null;
+            get => TryGetValue(PAYLOAD_KEY, out object value) ? value : null;
             set => this[PAYLOAD_KEY] = value;
         }
 
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 72033552..7727272d 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -18,7 +18,7 @@ public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequ
         /// </summary>
         public string Query
         {
-            get => ContainsKey(QUERY_KEY) ? (string)this[QUERY_KEY] : null;
+            get => TryGetValue(QUERY_KEY, out object value) ? (string)value : null;
             set => this[QUERY_KEY] = value;
         }
 
@@ -27,7 +27,7 @@ public string Query
         /// </summary>
         public string? OperationName
         {
-            get => ContainsKey(OPERATION_NAME_KEY) ? (string)this[OPERATION_NAME_KEY] : null;
+            get => TryGetValue(OPERATION_NAME_KEY, out object value) ? (string)value : null;
             set => this[OPERATION_NAME_KEY] = value;
         }
 
@@ -36,7 +36,7 @@ public string? OperationName
         /// </summary>
         public object? Variables
         {
-            get => ContainsKey(VARIABLES_KEY) ? this[VARIABLES_KEY] : null;
+            get => TryGetValue(VARIABLES_KEY, out object value) ? value : null;
             set => this[VARIABLES_KEY] = value;
         }
 

From 5816b208427e5e07d7b8982253bf8fa11e53895f Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 7 Oct 2020 23:51:27 +0200
Subject: [PATCH 331/455] Use Func instead of static object to configure

---
 .../GraphQLWebSocketRequest.cs                             | 4 ++--
 src/GraphQL.Client/GraphQLHttpClientOptions.cs             | 2 +-
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs       | 7 ++++---
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index d1ea99d5..f83fe5aa 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -14,7 +14,7 @@ public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<Gr
         public const string PAYLOAD_KEY = "payload";
 
         /// <summary>
-        /// The Identifier of the Response
+        /// The Identifier of the request
         /// </summary>
         public string Id
         {
@@ -34,7 +34,7 @@ public string Type
         /// <summary>
         /// The payload of the websocket request
         /// </summary>
-        public object Payload
+        public object? Payload
         {
             get => TryGetValue(PAYLOAD_KEY, out object value) ? value : null;
             set => this[PAYLOAD_KEY] = value;
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index ff36808f..be249baa 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -61,6 +61,6 @@ public class GraphQLHttpClientOptions
         /// The `ConnectionParams` object sent with the GQL_CONNECTION_INIT message on establishing a websocket connection.
         /// See https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_connection_init.
         /// </summary>
-        public object? WebSocketConnectionParams { get; set; } = null;
+        public Func<object?> SetWebSocketConnectionParams { get; set; } = () => null;
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 8bf8adee..74647c5d 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -98,12 +98,13 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                     Observable.Create<GraphQLResponse<TResponse>>(async observer =>
                     {
                         Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
-                        await _client.Options.PreprocessRequest(request, _client);
+                        var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client);
+
                         var startRequest = new GraphQLWebSocketRequest
                         {
                             Id = Guid.NewGuid().ToString("N"),
                             Type = GraphQLWebSocketMessageType.GQL_START,
-                            Payload = request
+                            Payload = preprocessedRequest
                         };
                         var stopRequest = new GraphQLWebSocketRequest
                         {
@@ -114,7 +115,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         {
                             Id = startRequest.Id,
                             Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                            Payload = Options.WebSocketConnectionParams
+                            Payload = Options.SetWebSocketConnectionParams()
                         };
 
                         var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>

From 0ca0ce9f1885ac44db912d678aa5783987f5557a Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Wed, 7 Oct 2020 23:53:36 +0200
Subject: [PATCH 332/455] fix naming

---
 src/GraphQL.Client/GraphQLHttpClientOptions.cs       | 4 ++--
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index be249baa..ab8949c6 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -58,9 +58,9 @@ public class GraphQLHttpClientOptions
         public Action<ClientWebSocketOptions> ConfigureWebsocketOptions { get; set; } = options => { };
 
         /// <summary>
-        /// The `ConnectionParams` object sent with the GQL_CONNECTION_INIT message on establishing a websocket connection.
+        /// Sets the `ConnectionParams` object sent with the GQL_CONNECTION_INIT message on establishing a GraphQL websocket connection.
         /// See https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_connection_init.
         /// </summary>
-        public Func<object?> SetWebSocketConnectionParams { get; set; } = () => null;
+        public Func<object?> SetWebSocketConnectionInitPayload { get; set; } = () => null;
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 74647c5d..f26e3e54 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -115,7 +115,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         {
                             Id = startRequest.Id,
                             Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                            Payload = Options.SetWebSocketConnectionParams()
+                            Payload = Options.SetWebSocketConnectionInitPayload()
                         };
 
                         var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>

From 937dc9ca78e29fe5e91a30a1e35c64e1ef724efa Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 8 Oct 2020 23:07:26 +0200
Subject: [PATCH 333/455] add options as context for init payload

---
 src/GraphQL.Client/GraphQLHttpClientOptions.cs       | 2 +-
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index ab8949c6..c0054813 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -61,6 +61,6 @@ public class GraphQLHttpClientOptions
         /// Sets the `ConnectionParams` object sent with the GQL_CONNECTION_INIT message on establishing a GraphQL websocket connection.
         /// See https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_connection_init.
         /// </summary>
-        public Func<object?> SetWebSocketConnectionInitPayload { get; set; } = () => null;
+        public Func<GraphQLHttpClientOptions, object?> ConfigureWebSocketConnectionInitPayload { get; set; } = options => null;
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index f26e3e54..28af82d6 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -115,7 +115,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         {
                             Id = startRequest.Id,
                             Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                            Payload = Options.SetWebSocketConnectionInitPayload()
+                            Payload = Options.ConfigureWebSocketConnectionInitPayload(Options)
                         };
 
                         var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>

From bb8bcfe27b0efcfa171d9123cd40f902eb69b301 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 8 Oct 2020 22:29:54 +0200
Subject: [PATCH 334/455] send connection_init and await connection_ack

---
 .../GraphQLWebSocketMessageType.cs            |  3 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 69 ++++++++++++-------
 .../GraphQLWebsocketConnectionException.cs    | 25 +++++++
 3 files changed, 69 insertions(+), 28 deletions(-)
 create mode 100644 src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
index daa83114..3b0e0499 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
@@ -38,8 +38,7 @@ public static class GraphQLWebSocketMessageType
         public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
 
         /// <summary>
-        ///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-        ///     id: string : operation id
+        ///     Client sends this message to terminate the connection.
         /// </summary>
         public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
 
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 28af82d6..aaf25046 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -8,6 +8,7 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
@@ -111,12 +112,6 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                             Id = startRequest.Id,
                             Type = GraphQLWebSocketMessageType.GQL_STOP
                         };
-                        var initRequest = new GraphQLWebSocketRequest
-                        {
-                            Id = startRequest.Id,
-                            Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                            Payload = Options.ConfigureWebSocketConnectionInitPayload(Options)
-                        };
 
                         var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
                             IncomingMessageStream
@@ -187,20 +182,8 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                                 catch (OperationCanceledException) { }
                             })
                         );
-
-                        // send connection init
-                        Debug.WriteLine($"sending connection init on subscription {startRequest.Id}");
-                        try
-                        {
-                            await QueueWebSocketRequest(initRequest);
-                        }
-                        catch (Exception e)
-                        {
-                            Debug.WriteLine(e);
-                            throw;
-                        }
-
-                        Debug.WriteLine($"sending initial message on subscription {startRequest.Id}");
+                        
+                        Debug.WriteLine($"sending start message on subscription {startRequest.Id}");
                         // send subscription request
                         try
                         {
@@ -354,12 +337,7 @@ private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest reque
                 }
 
                 await InitializeWebSocket();
-                var requestBytes = _client.JsonSerializer.SerializeToBytes(request);
-                await _clientWebSocket.SendAsync(
-                    new ArraySegment<byte>(requestBytes),
-                    WebSocketMessageType.Text,
-                    true,
-                    _internalCancellationToken);
+                await SendWebSocketMessageAsync(request, _internalCancellationToken);
                 request.SendCompleted();
             }
             catch (Exception e)
@@ -369,6 +347,16 @@ await _clientWebSocket.SendAsync(
             return Unit.Default;
         }
 
+        private async Task SendWebSocketMessageAsync(GraphQLWebSocketRequest request, CancellationToken cancellationToken = default)
+        {
+            var requestBytes = _client.JsonSerializer.SerializeToBytes(request);
+            await _clientWebSocket.SendAsync(
+                new ArraySegment<byte>(requestBytes),
+                WebSocketMessageType.Text,
+                true,
+                cancellationToken);
+        }
+
         #endregion
 
         public Task InitializeWebSocket()
@@ -469,9 +457,38 @@ private async Task ConnectAsync(CancellationToken token)
                 Debug.WriteLine($"new incoming message stream {_incomingMessages.GetHashCode()} created");
 
                 _incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
+                
+                var initRequest = new GraphQLWebSocketRequest
+                {
+                    Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+                    Payload = Options.ConfigureWebSocketConnectionInitPayload(Options)
+                };
+
+                // setup task to await connection_ack message
+                var ackTask = _incomingMessages
+                    .Where(response => response != null )
+                    .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
+                                           response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
+                    .FirstAsync()
+                    .ToTask();
+
+                // send connection init
+                Debug.WriteLine($"sending connection init message");
+                await SendWebSocketMessageAsync(initRequest);
+                var response = await ackTask;
+
+                if (response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
+                    Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
+                else
+                {
+                    var errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
+                    Debug.WriteLine($"connection error received: {errorPayload}");
+                    throw new GraphQLWebsocketConnectionException(errorPayload);
+                }
             }
             catch (Exception e)
             {
+                Debug.WriteLine($"failed to establish websocket connection");
                 _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
                 _exceptionSubject.OnNext(e);
                 throw;
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
new file mode 100644
index 00000000..c6b2e831
--- /dev/null
+++ b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace GraphQL.Client.Http.Websocket
+{
+    [Serializable]
+    public class GraphQLWebsocketConnectionException: Exception
+    {
+        public GraphQLWebsocketConnectionException()
+        {
+        }
+
+        protected GraphQLWebsocketConnectionException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+
+        public GraphQLWebsocketConnectionException(string message) : base(message)
+        {
+        }
+
+        public GraphQLWebsocketConnectionException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

From 1a4fc38b9bc16512ef63d95591b942ee7c84d8df Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 8 Oct 2020 22:42:15 +0200
Subject: [PATCH 335/455] send connection_terminate message on close

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index aaf25046..350aae6a 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -617,6 +617,9 @@ private async Task CloseAsync()
                 return;
             }
 
+            Debug.WriteLine($"send \"connection_terminate\" message");
+            await SendWebSocketMessageAsync(new GraphQLWebSocketRequest{Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE});
+
             Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
             await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
             _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);

From 75b07442c9d9492d18aa5090fe5e73ea42bd25b7 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 12 Oct 2020 21:47:46 +0200
Subject: [PATCH 336/455] fix syntax for environment vars

---
 .github/workflows/branches.yml | 8 ++++----
 .github/workflows/master.yml   | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 2db62d5a..f1e31304 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -23,12 +23,12 @@ jobs:
     - name: Fetch complete repository including tags
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
-      run: dotnet gitversion /output json > gitversion.json && cat gitversion.json
+      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> gitversion.env && cat gitversion.env
     - name: Upload version info file
       uses: actions/upload-artifact@v1
       with:
         name: gitversion
-        path: gitversion.json
+        path: gitversion.env
 
   build:
     name: Build
@@ -43,7 +43,7 @@ jobs:
         name: gitversion
         path: ./
     - name: Inject version info into environment
-      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
+      run: cat ./gitversion.env >> $GITHUB_ENV
     - name: Build solution
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
     - name: Create NuGet packages
@@ -67,6 +67,6 @@ jobs:
         name: gitversion
         path: ./
     - name: Inject version info into environment
-      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
+      run: cat ./gitversion.env >> $GITHUB_ENV
     - name: Run tests
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index e7e29460..407156d8 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -26,12 +26,12 @@ jobs:
     - name: Fetch complete repository including tags
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
-      run: dotnet gitversion /output json > gitversion.json && cat gitversion.json
+      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> gitversion.env && cat gitversion.env
     - name: Upload version info file
       uses: actions/upload-artifact@v1
       with:
         name: gitversion
-        path: gitversion.json
+        path: gitversion.env
 
   build:
     name: Build
@@ -46,7 +46,7 @@ jobs:
         name: gitversion
         path: ./
     - name: Inject version info into environment
-      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
+      run: cat ./gitversion.env >> $GITHUB_ENV
     - name: Build solution
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
     - name: Create NuGet packages
@@ -70,7 +70,7 @@ jobs:
         name: gitversion
         path: ./
     - name: Inject version info into environment
-      run: jq -r 'to_entries|map("::set-env name=GitVersion_\(.key)::\(.value|tostring)")|.[]' gitversion.json
+      run: cat ./gitversion.env >> $GITHUB_ENV
     - name: Run tests
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release
 

From d00f169961647e3ab2fb249a7ade7b8add201f70 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 12 Oct 2020 22:00:05 +0200
Subject: [PATCH 337/455] add detailed package shields

---
 README.md | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 32d35da0..0866ef7a 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,19 @@
 # GraphQL.Client
-[![NuGet](https://img.shields.io/nuget/v/GraphQL.Client.svg)](https://www.nuget.org/packages/GraphQL.Client)
-[![NuGet](https://img.shields.io/nuget/vpre/GraphQL.Client.svg)](https://www.nuget.org/packages/GraphQL.Client)
 
 A GraphQL Client for .NET Standard over HTTP.
 
+Provides the following packages:
+
+| Package | Downloads | Nuget Latest | 
+|---------|-----------|--------------|
+| GraphQL.Client | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Client)](https://www.nuget.org/packages/GraphQL.Client/) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Client)](https://www.nuget.org/packages/GraphQL.Client) | 
+| GraphQL.Client.Abstractions | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Client.Abstractions)](https://www.nuget.org/packages/GraphQL.Client.Abstractions) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Client.Abstractions)](https://www.nuget.org/packages/GraphQL.Client.Abstractions) |
+| GraphQL.Client.Abstractions.Websocket | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Client.Abstractions.Websocket)](https://www.nuget.org/packages/GraphQL.Client.Abstractions.Websocket) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Client.Abstractions.Websocket)](https://www.nuget.org/packages/GraphQL.Client.Abstractions.Websocket) |
+| GraphQL.Client.LocalExecution | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Client.LocalExecution)](https://www.nuget.org/packages/GraphQL.Client.LocalExecution) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Client.LocalExecution)](https://www.nuget.org/packages/GraphQL.Client.LocalExecution) | 
+| GraphQL.Client.Serializer.Newtonsoft | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Client.Serializer.Newtonsoft)](https://www.nuget.org/packages/GraphQL.Client.Serializer.Newtonsoft) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Client.Serializer.Newtonsoft)](https://www.nuget.org/packages/GraphQL.Client.Serializer.Newtonsoft) | 
+| GraphQL.Client.Serializer.SystemTextJson | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Client.Serializer.SystemTextJson)](https://www.nuget.org/packages/GraphQL.Client.Serializer.SystemTextJson) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Client.Serializer.SystemTextJson)](https://www.nuget.org/packages/GraphQL.Client.Serializer.SystemTextJson) | 
+| GraphQL.Primitives | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Primitives)](https://www.nuget.org/packages/GraphQL.Primitives/) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Primitives)](https://www.nuget.org/packages/GraphQL.Primitives) | 
+
 ## Specification:
 The Library will try to follow the following standards and documents:
 

From 2dd397d20dd0de60fbddceba6f59dbefbeb98d37 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 15 Oct 2020 10:02:00 +0200
Subject: [PATCH 338/455] use Dictionary copy constructor on new GraphQLRequest
 constructor

---
 src/GraphQL.Primitives/GraphQLRequest.cs | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 22074321..7e0c2dea 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -49,13 +49,7 @@ public GraphQLRequest(string query, object? variables = null, string? operationN
             OperationName = operationName;
         }
 
-        public GraphQLRequest(GraphQLRequest other)
-        {
-            foreach(var kv in other)
-            {
-                Add(kv.Key, kv.Value);
-            }
-        }
+        public GraphQLRequest(GraphQLRequest other): base(other) { }
 
         /// <summary>
         /// Returns a value that indicates whether this instance is equal to a specified object

From 15f10451437dde34bb6b7f98f0cf5069d2d75f56 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 15 Oct 2020 10:03:02 +0200
Subject: [PATCH 339/455] fix GraphQLRequest.GetHastCode()

---
 src/GraphQL.Primitives/GraphQLRequest.cs | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 7e0c2dea..d471077f 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -84,16 +84,7 @@ public virtual bool Equals(GraphQLRequest? other)
         /// <summary>
         /// <inheritdoc cref="object.GetHashCode"/>
         /// </summary>
-        public override int GetHashCode()
-        {
-            unchecked
-            {
-                var hashCode = Query?.GetHashCode() ?? 0;
-                hashCode = (hashCode * 397) ^ OperationName?.GetHashCode() ?? 0;
-                hashCode = (hashCode * 397) ^ Variables?.GetHashCode() ?? 0;
-                return hashCode;
-            }
-        }
+        public override int GetHashCode() => (Query, OperationName, Variables).GetHashCode();
 
         /// <summary>
         /// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent

From d786f80ea1ec87e2106d7a00f43fccc0c73854f8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Thu, 15 Oct 2020 11:56:04 +0200
Subject: [PATCH 340/455] allow configuration of dedicated websocket endpoint

---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 21 +++++++++++++---
 .../GraphQLHttpClientOptions.cs               |  7 +++++-
 src/GraphQL.Client/UriExtensions.cs           |  9 +++++--
 .../WebsocketTests/Base.cs                    | 24 +++++++++++++++++++
 4 files changed, 55 insertions(+), 6 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 21485f01..269eebda 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -64,8 +64,8 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
 
             if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
                 HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
-
-            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(() => new GraphQLHttpWebSocket(Options.EndPoint.GetWebSocketUri(), this));
+            
+            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
         }
 
         #endregion
@@ -75,7 +75,9 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
         /// <inheritdoc />
         public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
-            if (Options.UseWebSocketForQueriesAndMutations || Options.EndPoint.HasWebSocketScheme())
+            if (Options.UseWebSocketForQueriesAndMutations ||
+                !(Options.WebSocketEndPoint is null) && Options.EndPoint is null ||
+                Options.EndPoint.HasWebSocketScheme())
                 return await _graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
 
             return await SendHttpRequestAsync<TResponse>(request, cancellationToken);
@@ -152,6 +154,19 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TRespons
 
             throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
         }
+
+        private GraphQLHttpWebSocket CreateGraphQLHttpWebSocket()
+        {
+            if(Options.WebSocketEndPoint is null && Options.EndPoint is null)
+                throw new InvalidOperationException("no endpoint configured");
+
+            var webSocketEndpoint = Options.WebSocketEndPoint ?? Options.EndPoint.GetWebSocketUri();
+            if (!webSocketEndpoint.HasWebSocketScheme())
+                throw new InvalidOperationException($"uri \"{webSocketEndpoint}\" is not a websocket endpoint");
+
+            return new GraphQLHttpWebSocket(webSocketEndpoint, this);
+        }
+
         #endregion
 
         #region IDisposable
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index c0054813..dac7c4f1 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -14,7 +14,12 @@ public class GraphQLHttpClientOptions
         /// <summary>
         /// The GraphQL EndPoint to be used
         /// </summary>
-        public Uri EndPoint { get; set; }
+        public Uri? EndPoint { get; set; }
+
+        /// <summary>
+        /// The GraphQL EndPoint to be used for websocket connections
+        /// </summary>
+        public Uri? WebSocketEndPoint { get; set; } = null;
 
         /// <summary>
         /// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
diff --git a/src/GraphQL.Client/UriExtensions.cs b/src/GraphQL.Client/UriExtensions.cs
index ad40a5bf..296eb052 100644
--- a/src/GraphQL.Client/UriExtensions.cs
+++ b/src/GraphQL.Client/UriExtensions.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace GraphQL.Client.Http
 {
@@ -9,7 +9,9 @@ public static class UriExtensions
         /// </summary>
         /// <param name="uri"></param>
         /// <returns></returns>
-        public static bool HasWebSocketScheme(this Uri uri) => uri.Scheme.Equals("wss", StringComparison.OrdinalIgnoreCase) || uri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase);
+        public static bool HasWebSocketScheme(this Uri? uri) =>
+            !(uri is null) &&
+            (uri.Scheme.Equals("wss", StringComparison.OrdinalIgnoreCase) || uri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase));
 
         /// <summary>
         /// Infers the websocket uri from <paramref name="uri"/>.
@@ -18,6 +20,9 @@ public static class UriExtensions
         /// <returns></returns>
         public static Uri GetWebSocketUri(this Uri uri)
         {
+            if (uri is null)
+                throw new ArgumentNullException(nameof(uri));
+
             if (uri.HasWebSocketScheme())
                 return uri;
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 4f90c1a5..ba3ccb17 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -79,6 +79,30 @@ public async void CanUseWebSocketScheme()
             var response = await ChatClient.AddMessageAsync(message);
             response.Data.AddMessage.Content.Should().Be(message);
         }
+        
+        [Fact]
+        public async void CanUseDedicatedWebSocketEndpoint()
+        {
+            ChatClient.Options.WebSocketEndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
+            ChatClient.Options.EndPoint = new Uri("http://bad-endpoint.test");
+            ChatClient.Options.UseWebSocketForQueriesAndMutations = true;
+            await ChatClient.InitializeWebsocketConnection();
+            const string message = "some random testing message";
+            var response = await ChatClient.AddMessageAsync(message);
+            response.Data.AddMessage.Content.Should().Be(message);
+        }
+        
+        [Fact]
+        public async void CanUseDedicatedWebSocketEndpointWithoutHttpEndpoint()
+        {
+            ChatClient.Options.WebSocketEndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
+            ChatClient.Options.EndPoint = null;
+            ChatClient.Options.UseWebSocketForQueriesAndMutations = false;
+            await ChatClient.InitializeWebsocketConnection();
+            const string message = "some random testing message";
+            var response = await ChatClient.AddMessageAsync(message);
+            response.Data.AddMessage.Content.Should().Be(message);
+        }
 
         [Fact]
         public async void WebsocketRequestCanBeCancelled()

From 14f30c99c65d00f0be681c9e0f70fce22ee964a5 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 7 Jan 2021 21:04:37 +0100
Subject: [PATCH 341/455] catch PlatformNotSupportedException for unsupported
 Options properties

---
 .../Websocket/GraphQLHttpWebSocket.cs          | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 350aae6a..8e474693 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -402,12 +402,26 @@ public Task InitializeWebSocket()
 #else
                 _clientWebSocket = new ClientWebSocket();
                 _clientWebSocket.Options.AddSubProtocol("graphql-ws");
-                if(!System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Create("BROWSER")))
+
+                // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
+                try
                 {
-                    // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
                     _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                }
+                catch (PlatformNotSupportedException)
+                {
+                    Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not supported by current platform");
+                }
+
+                try
+                {
                     _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                 }
+                catch (PlatformNotSupportedException)
+                {
+                    Debug.WriteLine("Property 'ClientWebSocketOptions.UseDefaultCredentials' not supported by current platform");
+                }
+
                 Options.ConfigureWebsocketOptions(_clientWebSocket.Options);
 #endif
                 return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);

From 4d9c6b84784fa53160de6c06ac82715acf0622e3 Mon Sep 17 00:00:00 2001
From: David Welch <david@davidwelch.co>
Date: Sun, 31 Jan 2021 10:57:28 -0700
Subject: [PATCH 342/455] Catch NotImplementedException #324

Fixes #324
---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 8e474693..f63bf17c 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -408,6 +408,10 @@ public Task InitializeWebSocket()
                 {
                     _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
                 }
+                catch (NotImplementedException)
+                {
+                    Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not implemented by current platform");                
+                }
                 catch (PlatformNotSupportedException)
                 {
                     Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not supported by current platform");
@@ -417,6 +421,10 @@ public Task InitializeWebSocket()
                 {
                     _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                 }
+                catch (NotImplementedException)
+                {
+                    Debug.WriteLine("property 'ClientWebSocketOptions.UseDefaultCredentials' not implemented by current platform");    
+                }
                 catch (PlatformNotSupportedException)
                 {
                     Debug.WriteLine("Property 'ClientWebSocketOptions.UseDefaultCredentials' not supported by current platform");

From 436912d4a9df1940cd32c6bdcdacd8d7d78918d3 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 2 Apr 2021 10:37:40 +0200
Subject: [PATCH 343/455] fix property name

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 269eebda..f8d3640d 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -16,7 +16,7 @@ namespace GraphQL.Client.Http
     public class GraphQLHttpClient : IGraphQLClient
     {
         private readonly Lazy<GraphQLHttpWebSocket> _lazyHttpWebSocket;
-        private GraphQLHttpWebSocket _graphQlHttpWebSocket => _lazyHttpWebSocket.Value;
+        private GraphQLHttpWebSocket GraphQlHttpWebSocket => _lazyHttpWebSocket.Value;
 
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
@@ -39,12 +39,12 @@ public class GraphQLHttpClient : IGraphQLClient
         /// <summary>
         /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
         /// </summary>
-        public IObservable<Exception> WebSocketReceiveErrors => _graphQlHttpWebSocket.ReceiveErrors;
+        public IObservable<Exception> WebSocketReceiveErrors => GraphQlHttpWebSocket.ReceiveErrors;
 
         /// <summary>
         /// the websocket connection state
         /// </summary>
-        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => _graphQlHttpWebSocket.ConnectionState;
+        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => GraphQlHttpWebSocket.ConnectionState;
 
         #region Constructors
 
@@ -78,7 +78,7 @@ public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLR
             if (Options.UseWebSocketForQueriesAndMutations ||
                 !(Options.WebSocketEndPoint is null) && Options.EndPoint is null ||
                 Options.EndPoint.HasWebSocketScheme())
-                return await _graphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
+                return await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
 
             return await SendHttpRequestAsync<TResponse>(request, cancellationToken);
         }
@@ -99,7 +99,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
             if (_subscriptionStreams.ContainsKey(key))
                 return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
+            var observable = GraphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
 
             _subscriptionStreams.TryAdd(key, observable);
             return observable;
@@ -116,7 +116,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
             if (_subscriptionStreams.ContainsKey(key))
                 return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
 
-            var observable = _graphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+            var observable = GraphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
             _subscriptionStreams.TryAdd(key, observable);
             return observable;
         }
@@ -127,7 +127,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         /// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
         /// </summary>
         /// <returns></returns>
-        public Task InitializeWebsocketConnection() => _graphQlHttpWebSocket.InitializeWebSocket();
+        public Task InitializeWebsocketConnection() => GraphQlHttpWebSocket.InitializeWebSocket();
 
         #region Private Methods
 

From a1c009fbb3f998674b8f390ffb2ae72156163104 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 2 Apr 2021 10:42:26 +0200
Subject: [PATCH 344/455] only dispose HttpClient with GraphQLHttpClient if it
 was created internally

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index f8d3640d..9d2aac47 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -21,6 +21,8 @@ public class GraphQLHttpClient : IGraphQLClient
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
 
+        private readonly bool _disposeHttpClient = false;
+
         /// <summary>
         /// the json serializer
         /// </summary>
@@ -54,7 +56,12 @@ public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serialize
 
         public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer) : this(configure.New(), serializer) { }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer) : this(options, serializer, new HttpClient(options.HttpMessageHandler)) { }
+        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer) : this(
+            options, serializer, new HttpClient(options.HttpMessageHandler))
+        {
+            // set this flag to dispose the internally created HttpClient when GraphQLHttpClient gets disposed
+            _disposeHttpClient = true;
+        }
 
         public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
         {
@@ -195,7 +202,8 @@ protected virtual void Dispose(bool disposing)
             {
                 Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
                 _cancellationTokenSource.Cancel();
-                HttpClient.Dispose();
+                if(_disposeHttpClient)
+                    HttpClient.Dispose();
                 if ( _lazyHttpWebSocket.IsValueCreated )
                     _lazyHttpWebSocket.Value.Dispose();
                 _cancellationTokenSource.Dispose();

From c9bd6665d3501c6b84331248305b4fcd466d6042 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 2 Apr 2021 11:24:09 +0200
Subject: [PATCH 345/455] update gitversion

---
 dotnet-tools.json | 2 +-
 src/src.props     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dotnet-tools.json b/dotnet-tools.json
index 133edefa..3c532709 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -8,7 +8,7 @@
       ]
     },
     "gitversion.tool": {
-      "version": "5.2.4",
+      "version": "5.6.7",
       "commands": [
         "dotnet-gitversion"
       ]
diff --git a/src/src.props b/src/src.props
index c4e46be1..37933c88 100644
--- a/src/src.props
+++ b/src/src.props
@@ -8,7 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Update="GitVersionTask" Version="5.3.4">
+    <PackageReference Update="GitVersionTask" Version="5.6.7">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

From 35d6d118fdf1591708763ad5889d94b87f4820f6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sun, 6 Jun 2021 20:33:19 +0200
Subject: [PATCH 346/455] fix task to await connection_ack websocket message

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index f63bf17c..ec4ac4b7 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -491,7 +491,7 @@ private async Task ConnectAsync(CancellationToken token)
                     .Where(response => response != null )
                     .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
                                            response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
-                    .FirstAsync()
+                    .LastAsync()
                     .ToTask();
 
                 // send connection init

From ce649f78b556f34663216f1adc155924e94a1b96 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 13 Sep 2021 14:50:51 +0200
Subject: [PATCH 347/455] update dependencies of integration tests

---
 .../Chat/AddMessageVariables.cs               |  2 +-
 .../Chat/GraphQLClientChatExtensions.cs       |  4 +--
 .../Chat/Schema/ChatMutation.cs               |  2 +-
 .../Chat/Schema/ChatSchema.cs                 | 13 +++++----
 .../Chat/Schema/ChatSubscriptions.cs          | 10 +++----
 .../Chat/Schema/MessageType.cs                |  2 +-
 tests/GraphQL.Client.Tests.Common/Common.cs   |  2 --
 .../GraphQL.Client.Tests.Common.csproj        | 10 +++----
 .../GraphQL.Integration.Tests.csproj          |  4 +--
 .../WebsocketTests/Base.cs                    |  5 ++++
 .../IntegrationTestServer.csproj              | 11 ++-----
 .../Properties/launchSettings.json            |  4 +--
 tests/IntegrationTestServer/Startup.cs        | 29 +++++++++----------
 13 files changed, 47 insertions(+), 51 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
index 0a330007..887c55cd 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
@@ -12,7 +12,7 @@ public class AddMessageInput
 
             public string Content { get; set; }
 
-            public DateTime SentAt { get; set; }
+            public string SentAt { get; set; }
         }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index f4417860..07648f06 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -10,7 +10,7 @@ public static class GraphQLClientChatExtensions
 @"mutation($input: MessageInputType){
   addMessage(message: $input){
     content
-  }  
+  }
 }";
 
         public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message)
@@ -21,7 +21,7 @@ public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(th
                 {
                     FromId = "2",
                     Content = message,
-                    SentAt = DateTime.Now
+                    SentAt = DateTime.Now.ToString("s")
                 }
             };
 
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
index 1d2cdd28..b005ebc2 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
@@ -36,7 +36,7 @@ public MessageInputType()
         {
             Field<StringGraphType>("fromId");
             Field<StringGraphType>("content");
-            Field<DateGraphType>("sentAt");
+            Field<DateTimeGraphType>("sentAt");
         }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
index 49126f8a..fbdfedf1 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
@@ -1,13 +1,16 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+
 namespace GraphQL.Client.Tests.Common.Chat.Schema
 {
     public class ChatSchema : Types.Schema
     {
-        public ChatSchema(IDependencyResolver resolver)
-            : base(resolver)
+        public ChatSchema(IServiceProvider services)
+            : base(services)
         {
-            Query = resolver.Resolve<ChatQuery>();
-            Mutation = resolver.Resolve<ChatMutation>();
-            Subscription = resolver.Resolve<ChatSubscriptions>();
+            Query = services.GetRequiredService<ChatQuery>();
+            Mutation = services.GetRequiredService<ChatMutation>();
+            Subscription = services.GetRequiredService<ChatSubscriptions>();
         }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
index f0d08efb..b15ba334 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
@@ -61,9 +61,9 @@ public ChatSubscriptions(IChat chat)
             });
         }
 
-        private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
+        private IObservable<Message> SubscribeById(IResolveEventStreamContext context)
         {
-            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var messageContext = (MessageHandlingContext) context.UserContext;
             var user = messageContext.Get<ClaimsPrincipal>("user");
 
             var sub = "Anonymous";
@@ -76,16 +76,16 @@ private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
             return messages.Where(message => message.From.Id == id);
         }
 
-        private Message ResolveMessage(ResolveFieldContext context)
+        private Message ResolveMessage(IResolveFieldContext context)
         {
             var message = context.Source as Message;
 
             return message;
         }
 
-        private IObservable<Message> Subscribe(ResolveEventStreamContext context)
+        private IObservable<Message> Subscribe(IResolveEventStreamContext context)
         {
-            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var messageContext = (MessageHandlingContext) context.UserContext;
             var user = messageContext.Get<ClaimsPrincipal>("user");
 
             var sub = "Anonymous";
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
index 2636390c..e72a0067 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
@@ -12,7 +12,7 @@ public MessageType()
             Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
         }
 
-        private MessageFrom ResolveFrom(ResolveFieldContext<Message> context)
+        private MessageFrom ResolveFrom(IResolveFieldContext<Message> context)
         {
             var message = context.Source;
             return message.From;
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
index 97dd30fe..af437bad 100644
--- a/tests/GraphQL.Client.Tests.Common/Common.cs
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -13,7 +13,6 @@ public static class Common
         public static StarWarsSchema GetStarWarsSchema()
         {
             var services = new ServiceCollection();
-            services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
             services.AddStarWarsSchema();
             return services.BuildServiceProvider().GetRequiredService<StarWarsSchema>();
         }
@@ -21,7 +20,6 @@ public static StarWarsSchema GetStarWarsSchema()
         public static ChatSchema GetChatSchema()
         {
             var services = new ServiceCollection();
-            services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
             services.AddChatSchema();
             return services.BuildServiceProvider().GetRequiredService<ChatSchema>();
         }
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 6aeff4a3..f2fefe45 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,13 +7,11 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="GraphQL" Version="2.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
+    <PackageReference Include="GraphQL" Version="4.6.0" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="5.0.2" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.3" />
-    <PackageReference Include="Microsoft.Reactive.Testing" Version="4.3.2" />
-    <PackageReference Include="System.Reactive" Version="4.3.2" />
-    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
+    <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 3cc7fd29..6aca8a5b 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -8,9 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
-    <PackageReference Include="Microsoft.Reactive.Testing" Version="4.3.2" />
-    <PackageReference Include="System.Reactive" Version="4.3.2" />
-    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+    <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index ba3ccb17..4bedde89 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -67,6 +67,7 @@ public async void CanSendRequestViaWebsocket()
             await ChatClient.InitializeWebsocketConnection();
             const string message = "some random testing message";
             var response = await ChatClient.AddMessageAsync(message);
+            response.Errors.Should().BeNullOrEmpty();
             response.Data.AddMessage.Content.Should().Be(message);
         }
 
@@ -77,6 +78,7 @@ public async void CanUseWebSocketScheme()
             await ChatClient.InitializeWebsocketConnection();
             const string message = "some random testing message";
             var response = await ChatClient.AddMessageAsync(message);
+            response.Errors.Should().BeNullOrEmpty();
             response.Data.AddMessage.Content.Should().Be(message);
         }
         
@@ -89,6 +91,7 @@ public async void CanUseDedicatedWebSocketEndpoint()
             await ChatClient.InitializeWebsocketConnection();
             const string message = "some random testing message";
             var response = await ChatClient.AddMessageAsync(message);
+            response.Errors.Should().BeNullOrEmpty();
             response.Data.AddMessage.Content.Should().Be(message);
         }
         
@@ -174,10 +177,12 @@ public async void CanCreateObservableSubscription()
             Debug.WriteLine("subscribing...");
             using var observer = observable.Observe();
             await observer.Should().PushAsync(1);
+            observer.RecordedMessages.Last().Errors.Should().BeNullOrEmpty();
             observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             var response = await ChatClient.AddMessageAsync(message1);
+            response.Errors.Should().BeNullOrEmpty();
             response.Data.AddMessage.Content.Should().Be(message1);
             await observer.Should().PushAsync(2);
             observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index da280f0f..2eaf45ba 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -10,15 +10,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Ui.Playground" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.4.0" />
+    <PackageReference Include="GraphQL.Server.All" Version="5.0.2" />
     <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
-    <PackageReference Include="System.Reactive" Version="4.3.2" />
-    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+    <PackageReference Include="System.Reactive" Version="5.0.0" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/IntegrationTestServer/Properties/launchSettings.json b/tests/IntegrationTestServer/Properties/launchSettings.json
index cd6aedd6..987589b7 100644
--- a/tests/IntegrationTestServer/Properties/launchSettings.json
+++ b/tests/IntegrationTestServer/Properties/launchSettings.json
@@ -22,7 +22,7 @@
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       },
-      "applicationUrl": "http://localhost:5005/"
+      "applicationUrl": "http://localhost:5005"
     }
   }
-}
\ No newline at end of file
+}
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 49586dc0..5faae7f7 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -2,6 +2,7 @@
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Server;
+using GraphQL.Server.Ui.Altair;
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.Server.Ui.Playground;
 using GraphQL.StarWars;
@@ -12,6 +13,7 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 
 namespace IntegrationTestServer
 {
@@ -32,16 +34,21 @@ public Startup(IConfiguration configuration, IWebHostEnvironment environment)
         public void ConfigureServices(IServiceCollection services)
         {
             services.Configure<KestrelServerOptions>(options => options.AllowSynchronousIO = true);
-
-            services.AddTransient<IDependencyResolver>(provider => new FuncDependencyResolver(provider.GetService));
+            //
             services.AddChatSchema();
             services.AddStarWarsSchema();
-            services.AddGraphQL(options =>
+            services.AddSingleton<IDocumentExecuter, SubscriptionDocumentExecuter>();
+            services.AddGraphQL((options, services) =>
             {
                 options.EnableMetrics = true;
-                options.ExposeExceptions = Environment.IsDevelopment();
+                var logger = services.GetRequiredService<ILogger<Startup>>();
+                options.UnhandledExceptionDelegate = ctx => logger.LogError("{Error} occurred", ctx.OriginalException.Message);
             })
-                .AddWebSockets();
+                .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = Environment.IsDevelopment())
+                .AddSystemTextJson()
+                .AddWebSockets()
+                .AddGraphTypes(typeof(ChatSchema))
+                .AddGraphTypes(typeof(StarWarsSchema));
         }
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
@@ -57,16 +64,8 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
             ConfigureGraphQLSchema<ChatSchema>(app, Common.CHAT_ENDPOINT);
             ConfigureGraphQLSchema<StarWarsSchema>(app, Common.STAR_WARS_ENDPOINT);
 
-            app.UseGraphiQLServer(new GraphiQLOptions
-            {
-                GraphiQLPath = "/ui/graphiql",
-                GraphQLEndPoint = Common.STAR_WARS_ENDPOINT
-            });
-            app.UseGraphQLPlayground(new GraphQLPlaygroundOptions
-            {
-                Path = "/ui/playground",
-                GraphQLEndPoint = Common.CHAT_ENDPOINT
-            });
+            app.UseGraphQLGraphiQL(new GraphiQLOptions { GraphQLEndPoint = Common.STAR_WARS_ENDPOINT });
+            app.UseGraphQLAltair(new AltairOptions { GraphQLEndPoint = Common.CHAT_ENDPOINT });
         }
 
         private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema : Schema

From fe110b6201d6165bb1bcad6065b738921137c98f Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 14 Sep 2021 10:36:52 +0200
Subject: [PATCH 348/455] add StarWars schema classes, fix local execution
 client

---
 .../GraphQL.Client.LocalExecution.csproj      |  6 +-
 .../GraphQLLocalExecutionClient.cs            | 10 ++-
 .../BaseSerializerTest.cs                     |  1 +
 tests/GraphQL.Client.Tests.Common/Common.cs   |  4 +-
 .../GraphQL.Client.Tests.Common.csproj        |  1 -
 .../ResolveFieldContextExtensions.cs          | 65 ++++++++++++++
 .../StarWars/StarWarsData.cs                  | 90 +++++++++++++++++++
 .../StarWars/StarWarsMutation.cs              | 35 ++++++++
 .../StarWars/StarWarsQuery.cs                 | 33 +++++++
 .../StarWars/StarWarsSchema.cs                | 18 ++++
 .../StarWars/{ => TestData}/StarWarsHumans.cs |  5 +-
 .../StarWars/Types/CharacterInterface.cs      | 20 +++++
 .../StarWars/Types/DroidType.cs               | 30 +++++++
 .../StarWars/Types/EpisodeEnum.cs             | 23 +++++
 .../StarWars/Types/HumanInputType.cs          | 14 +++
 .../StarWars/Types/HumanType.cs               | 30 +++++++
 .../StarWars/Types/StarWarsCharacter.cs       | 23 +++++
 .../QueryAndMutationTests/Base.cs             |  1 +
 .../IntegrationTestServer.csproj              |  1 -
 tests/IntegrationTestServer/Startup.cs        |  3 +-
 20 files changed, 400 insertions(+), 13 deletions(-)
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
 rename tests/GraphQL.Client.Tests.Common/StarWars/{ => TestData}/StarWarsHumans.cs (76%)
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
 create mode 100644 tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index e8e162cb..d69fc21b 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -8,9 +8,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL" Version="2.4.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="System.Reactive.Compatibility" Version="4.3.2" />
+    <PackageReference Include="GraphQL" Version="4.6.0" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="4.6.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 65098ae8..f2c077f6 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -9,6 +9,7 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.NewtonsoftJson;
 using GraphQL.Subscription;
 using GraphQL.Types;
 using Newtonsoft.Json;
@@ -41,6 +42,7 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
         public IGraphQLJsonSerializer Serializer { get; }
 
         private readonly DocumentExecuter _documentExecuter;
+        private readonly DocumentWriter _documentWriter;
 
         public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer)
         {
@@ -50,6 +52,7 @@ public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serial
             if (!Schema.Initialized)
                 Schema.Initialize();
             _documentExecuter = new DocumentExecuter();
+            _documentWriter = new DocumentWriter();
         }
 
         public void Dispose() { }
@@ -109,12 +112,13 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
             return result;
         }
 
-        private Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponse<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
+        private async Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponse<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
         {
+            string json = await _documentWriter.WriteToStringAsync(executionResult);
             // serialize result into utf8 byte stream
-            var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(executionResult, _variablesSerializerSettings)));
+            var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
             // deserialize using the provided serializer
-            return Serializer.DeserializeFromUtf8StreamAsync<TResponse>(resultStream, cancellationToken);
+            return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(resultStream, cancellationToken);
         }
 
         #endregion
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 53cba0c1..863974ae 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -16,6 +16,7 @@
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Client.Tests.Common.StarWars;
+using GraphQL.Client.Tests.Common.StarWars.TestData;
 using Xunit;
 
 namespace GraphQL.Client.Serializer.Tests
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
index af437bad..269ea257 100644
--- a/tests/GraphQL.Client.Tests.Common/Common.cs
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -1,6 +1,6 @@
 using GraphQL.Client.Tests.Common.Chat.Schema;
-using GraphQL.StarWars;
-using GraphQL.StarWars.Types;
+using GraphQL.Client.Tests.Common.StarWars;
+using GraphQL.Client.Tests.Common.StarWars.Types;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace GraphQL.Client.Tests.Common
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index f2fefe45..24cbf419 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -9,7 +9,6 @@
     <PackageReference Include="FluentAssertions" Version="5.10.3" />
     <PackageReference Include="GraphQL" Version="4.6.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="5.0.2" />
-    <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
new file mode 100644
index 00000000..44ba5895
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GraphQL.Builders;
+using GraphQL.Client.Tests.Common.StarWars.Types;
+using GraphQL.Types.Relay.DataObjects;
+
+namespace GraphQL.Client.Tests.Common.StarWars.Extensions
+{
+    public static class ResolveFieldContextExtensions
+    {
+        public static Connection<U> GetPagedResults<T, U>(this IResolveConnectionContext<T> context, StarWarsData data, List<string> ids) where U : StarWarsCharacter
+        {
+            List<string> idList;
+            List<U> list;
+            string cursor;
+            string endCursor;
+            var pageSize = context.PageSize ?? 20;
+
+            if (context.IsUnidirectional || context.After != null || context.Before == null)
+            {
+                if (context.After != null)
+                {
+                    idList = ids
+                        .SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.After))
+                        .Take(context.First ?? pageSize).ToList();
+                }
+                else
+                {
+                    idList = ids
+                        .Take(context.First ?? pageSize).ToList();
+                }
+            }
+            else
+            {
+                if (context.Before != null)
+                {
+                    idList = ids.Reverse<string>()
+                        .SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.Before))
+                        .Take(context.Last ?? pageSize).ToList();
+                }
+                else
+                {
+                    idList = ids.Reverse<string>()
+                        .Take(context.Last ?? pageSize).ToList();
+                }
+            }
+
+            list = data.GetCharactersAsync(idList).Result as List<U> ?? throw new InvalidOperationException($"GetCharactersAsync method should return list of '{typeof(U).Name}' items.");
+            cursor = list.Count > 0 ? list.Last().Cursor : null;
+            endCursor = ids.Count > 0 ? Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(ids.Last())) : null;
+
+            return new Connection<U>
+            {
+                Edges = list.Select(x => new Edge<U> { Cursor = x.Cursor, Node = x }).ToList(),
+                TotalCount = list.Count,
+                PageInfo = new PageInfo
+                {
+                    EndCursor = endCursor,
+                    HasNextPage = endCursor == null ? false : cursor != endCursor,
+                }
+            };
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
new file mode 100644
index 00000000..f561ed87
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
@@ -0,0 +1,90 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using GraphQL.Client.Tests.Common.StarWars.Types;
+
+namespace GraphQL.Client.Tests.Common.StarWars
+{
+    public class StarWarsData
+    {
+        private readonly List<StarWarsCharacter> _characters = new List<StarWarsCharacter>();
+
+        public StarWarsData()
+        {
+            _characters.Add(new Human
+            {
+                Id = "1",
+                Name = "Luke",
+                Friends = new List<string> { "3", "4" },
+                AppearsIn = new[] { 4, 5, 6 },
+                HomePlanet = "Tatooine",
+                Cursor = "MQ=="
+            });
+            _characters.Add(new Human
+            {
+                Id = "2",
+                Name = "Vader",
+                AppearsIn = new[] { 4, 5, 6 },
+                HomePlanet = "Tatooine",
+                Cursor = "Mg=="
+            });
+
+            _characters.Add(new Droid
+            {
+                Id = "3",
+                Name = "R2-D2",
+                Friends = new List<string> { "1", "4" },
+                AppearsIn = new[] { 4, 5, 6 },
+                PrimaryFunction = "Astromech",
+                Cursor = "Mw=="
+            });
+            _characters.Add(new Droid
+            {
+                Id = "4",
+                Name = "C-3PO",
+                AppearsIn = new[] { 4, 5, 6 },
+                PrimaryFunction = "Protocol",
+                Cursor = "NA=="
+            });
+        }
+
+        public IEnumerable<StarWarsCharacter> GetFriends(StarWarsCharacter character)
+        {
+            if (character == null)
+            {
+                return null;
+            }
+
+            var friends = new List<StarWarsCharacter>();
+            var lookup = character.Friends;
+            if (lookup != null)
+            {
+                foreach (var c in _characters.Where(h => lookup.Contains(h.Id)))
+                    friends.Add(c);
+            }
+            return friends;
+        }
+
+        public StarWarsCharacter AddCharacter(StarWarsCharacter character)
+        {
+            character.Id = _characters.Count.ToString();
+            _characters.Add(character);
+            return character;
+        }
+
+        public Task<Human> GetHumanByIdAsync(string id)
+        {
+            return Task.FromResult(_characters.FirstOrDefault(h => h.Id == id && h is Human) as Human);
+        }
+
+        public Task<Droid> GetDroidByIdAsync(string id)
+        {
+            return Task.FromResult(_characters.FirstOrDefault(h => h.Id == id && h is Droid) as Droid);
+        }
+
+        public Task<List<StarWarsCharacter>> GetCharactersAsync(List<string> guids)
+        {
+            return Task.FromResult(_characters.Where(c => guids.Contains(c.Id)).ToList());
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
new file mode 100644
index 00000000..cd577688
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
@@ -0,0 +1,35 @@
+using GraphQL.Client.Tests.Common.StarWars.Types;
+using GraphQL.Types;
+
+namespace GraphQL.Client.Tests.Common.StarWars
+{
+    /// <example>
+    /// This is an example JSON request for a mutation
+    /// {
+    ///   "query": "mutation ($human:HumanInput!){ createHuman(human: $human) { id name } }",
+    ///   "variables": {
+    ///     "human": {
+    ///       "name": "Boba Fett"
+    ///     }
+    ///   }
+    /// }
+    /// </example>
+    public class StarWarsMutation : ObjectGraphType<object>
+    {
+        public StarWarsMutation(StarWarsData data)
+        {
+            Name = "Mutation";
+
+            Field<HumanType>(
+                "createHuman",
+                arguments: new QueryArguments(
+                    new QueryArgument<NonNullGraphType<HumanInputType>> { Name = "human" }
+                ),
+                resolve: context =>
+                {
+                    var human = context.GetArgument<Human>("human");
+                    return data.AddCharacter(human);
+                });
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
new file mode 100644
index 00000000..c416e8c5
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
@@ -0,0 +1,33 @@
+using System;
+using GraphQL.Client.Tests.Common.StarWars.Types;
+using GraphQL.Types;
+
+namespace GraphQL.Client.Tests.Common.StarWars
+{
+    public class StarWarsQuery : ObjectGraphType<object>
+    {
+        public StarWarsQuery(StarWarsData data)
+        {
+            Name = "Query";
+
+            Field<CharacterInterface>("hero", resolve: context => data.GetDroidByIdAsync("3"));
+            Field<HumanType>(
+                "human",
+                arguments: new QueryArguments(
+                    new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the human" }
+                ),
+                resolve: context => data.GetHumanByIdAsync(context.GetArgument<string>("id"))
+            );
+
+            Func<IResolveFieldContext, string, object> func = (context, id) => data.GetDroidByIdAsync(id);
+
+            FieldDelegate<DroidType>(
+                "droid",
+                arguments: new QueryArguments(
+                    new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the droid" }
+                ),
+                resolve: func
+            );
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
new file mode 100644
index 00000000..eff7cff4
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
@@ -0,0 +1,18 @@
+using System;
+using GraphQL.Types;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GraphQL.Client.Tests.Common.StarWars
+{
+    public class StarWarsSchema : Schema
+    {
+        public StarWarsSchema(IServiceProvider serviceProvider)
+            : base(serviceProvider)
+        {
+            Query = serviceProvider.GetRequiredService<StarWarsQuery>();
+            Mutation = serviceProvider.GetRequiredService<StarWarsMutation>();
+
+            Description = "Example StarWars universe schema";
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs b/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
similarity index 76%
rename from tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
rename to tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
index 88c64759..1e93ccb6 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsHumans.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
@@ -1,8 +1,11 @@
 using System.Collections;
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Tests.Common.StarWars
+namespace GraphQL.Client.Tests.Common.StarWars.TestData
 {
+    /// <summary>
+    /// Test data object
+    /// </summary>
     public class StarWarsHumans : IEnumerable<object[]>
     {
         public IEnumerator<object[]> GetEnumerator()
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
new file mode 100644
index 00000000..e45db3d4
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
@@ -0,0 +1,20 @@
+using GraphQL.Types;
+using GraphQL.Types.Relay;
+
+namespace GraphQL.Client.Tests.Common.StarWars.Types
+{
+    public class CharacterInterface : InterfaceGraphType<StarWarsCharacter>
+    {
+        public CharacterInterface()
+        {
+            Name = "Character";
+
+            Field<NonNullGraphType<StringGraphType>>("id", "The id of the character.", resolve: context => context.Source.Id);
+            Field<StringGraphType>("name", "The name of the character.", resolve: context => context.Source.Name);
+
+            Field<ListGraphType<CharacterInterface>>("friends");
+            Field<ConnectionType<CharacterInterface, EdgeType<CharacterInterface>>>("friendsConnection");
+            Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
new file mode 100644
index 00000000..8d8fc867
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
@@ -0,0 +1,30 @@
+using GraphQL.Client.Tests.Common.StarWars.Extensions;
+using GraphQL.Types;
+
+namespace GraphQL.Client.Tests.Common.StarWars.Types
+{
+    public class DroidType : ObjectGraphType<Droid>
+    {
+        public DroidType(StarWarsData data)
+        {
+            Name = "Droid";
+            Description = "A mechanical creature in the Star Wars universe.";
+
+            Field<NonNullGraphType<StringGraphType>>("id", "The id of the droid.", resolve: context => context.Source.Id);
+            Field<StringGraphType>("name", "The name of the droid.", resolve: context => context.Source.Name);
+
+            Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
+
+            Connection<CharacterInterface>()
+                .Name("friendsConnection")
+                .Description("A list of a character's friends.")
+                .Bidirectional()
+                .Resolve(context => context.GetPagedResults<Droid, StarWarsCharacter>(data, context.Source.Friends));
+
+            Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
+            Field<StringGraphType>("primaryFunction", "The primary function of the droid.", resolve: context => context.Source.PrimaryFunction);
+
+            Interface<CharacterInterface>();
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
new file mode 100644
index 00000000..6823376e
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
@@ -0,0 +1,23 @@
+using GraphQL.Types;
+
+namespace GraphQL.Client.Tests.Common.StarWars.Types
+{
+    public class EpisodeEnum : EnumerationGraphType
+    {
+        public EpisodeEnum()
+        {
+            Name = "Episode";
+            Description = "One of the films in the Star Wars Trilogy.";
+            AddValue("NEWHOPE", "Released in 1977.", 4);
+            AddValue("EMPIRE", "Released in 1980.", 5);
+            AddValue("JEDI", "Released in 1983.", 6);
+        }
+    }
+
+    public enum Episodes
+    {
+        NEWHOPE = 4,
+        EMPIRE = 5,
+        JEDI = 6
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs
new file mode 100644
index 00000000..c44c381c
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs
@@ -0,0 +1,14 @@
+using GraphQL.Types;
+
+namespace GraphQL.Client.Tests.Common.StarWars.Types
+{
+    public class HumanInputType : InputObjectGraphType
+    {
+        public HumanInputType()
+        {
+            Name = "HumanInput";
+            Field<NonNullGraphType<StringGraphType>>("name");
+            Field<StringGraphType>("homePlanet");
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
new file mode 100644
index 00000000..93da8165
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
@@ -0,0 +1,30 @@
+using GraphQL.Client.Tests.Common.StarWars.Extensions;
+using GraphQL.Types;
+
+namespace GraphQL.Client.Tests.Common.StarWars.Types
+{
+    public class HumanType : ObjectGraphType<Human>
+    {
+        public HumanType(StarWarsData data)
+        {
+            Name = "Human";
+
+            Field<NonNullGraphType<StringGraphType>>("id", "The id of the human.", resolve: context => context.Source.Id);
+            Field<StringGraphType>("name", "The name of the human.", resolve: context => context.Source.Name);
+
+            Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
+
+            Connection<CharacterInterface>()
+                .Name("friendsConnection")
+                .Description("A list of a character's friends.")
+                .Bidirectional()
+                .Resolve(context => context.GetPagedResults<Human, StarWarsCharacter>(data, context.Source.Friends));
+
+            Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
+
+            Field<StringGraphType>("homePlanet", "The home planet of the human.", resolve: context => context.Source.HomePlanet);
+
+            Interface<CharacterInterface>();
+        }
+    }
+}
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
new file mode 100644
index 00000000..b39d4cdc
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace GraphQL.Client.Tests.Common.StarWars.Types
+{
+    public abstract class StarWarsCharacter
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public List<string> Friends { get; set; }
+        public int[] AppearsIn { get; set; }
+        public string Cursor { get; set; }
+    }
+
+    public class Human : StarWarsCharacter
+    {
+        public string HomePlanet { get; set; }
+    }
+
+    public class Droid : StarWarsCharacter
+    {
+        public string PrimaryFunction { get; set; }
+    }
+}
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 5855e626..b1f56e62 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -9,6 +9,7 @@
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Client.Tests.Common.StarWars;
+using GraphQL.Client.Tests.Common.StarWars.TestData;
 using GraphQL.Integration.Tests.Helpers;
 using Microsoft.Extensions.DependencyInjection;
 using Xunit;
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 2eaf45ba..fab13b6e 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,7 +11,6 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.Server.All" Version="5.0.2" />
-    <PackageReference Include="GraphQL.StarWars" Version="1.0.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
     <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
   </ItemGroup>
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 5faae7f7..f41856d7 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -1,11 +1,10 @@
 using GraphQL;
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Chat.Schema;
+using GraphQL.Client.Tests.Common.StarWars;
 using GraphQL.Server;
 using GraphQL.Server.Ui.Altair;
 using GraphQL.Server.Ui.GraphiQL;
-using GraphQL.Server.Ui.Playground;
-using GraphQL.StarWars;
 using GraphQL.Types;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;

From fd2d88d1470782dff9865d07df6347f1e35ab0bc Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 29 Oct 2021 14:38:08 +0200
Subject: [PATCH 349/455] improve DI capabilities of
 GraphQLLocalExecutionClient

---
 .../GraphQL.Client.LocalExecution.csproj      |  3 +-
 .../GraphQLLocalExecutionClient.cs            | 33 +++++++++----------
 .../ServiceCollectionExtensions.cs            | 18 ++++++++++
 3 files changed, 36 insertions(+), 18 deletions(-)
 create mode 100644 src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index d69fc21b..00ef36b3 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -8,8 +8,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL" Version="4.6.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="4.6.1" />
     <PackageReference Include="GraphQL.NewtonsoftJson" Version="4.6.0" />
+    <PackageReference Include="GraphQL.SystemReactive" Version="4.1.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index f2c077f6..624526f3 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -21,7 +21,7 @@ namespace GraphQL.Client.LocalExecution
     public static class GraphQLLocalExecutionClient
     {
         public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer serializer) where TSchema : ISchema
-            => new GraphQLLocalExecutionClient<TSchema>(schema, serializer);
+            => new GraphQLLocalExecutionClient<TSchema>(schema, serializer, new SubscriptionDocumentExecuter(), new DocumentWriter());
     }
 
     public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
@@ -41,18 +41,18 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
 
         public IGraphQLJsonSerializer Serializer { get; }
 
-        private readonly DocumentExecuter _documentExecuter;
-        private readonly DocumentWriter _documentWriter;
+        private readonly IDocumentExecuter _documentExecuter;
+        private readonly IDocumentWriter _documentWriter;
 
-        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer)
+        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer, IDocumentExecuter documentExecuter, IDocumentWriter documentWriter)
         {
             Schema = schema ?? throw new ArgumentNullException(nameof(schema), "no schema configured");
             Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
 
             if (!Schema.Initialized)
                 Schema.Initialize();
-            _documentExecuter = new DocumentExecuter();
-            _documentWriter = new DocumentWriter();
+            _documentExecuter = documentExecuter;
+            _documentWriter = documentWriter;
         }
 
         public void Dispose() { }
@@ -78,7 +78,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken)
         {
             var executionResult = await ExecuteAsync(request, cancellationToken);
-            return await ExecutionResultToGraphQLResponse<TResponse>(executionResult, cancellationToken);
+            return await ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, cancellationToken);
         }
         private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
@@ -87,12 +87,12 @@ private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionA
 
             return stream == null
                 ? Observable.Throw<GraphQLResponse<TResponse>>(new InvalidOperationException("the GraphQL execution did not return an observable"))
-                : stream.SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponse<TResponse>(executionResult, token)));
+                : stream.SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, token)));
         }
 
         private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
-            var serializedRequest = Serializer.SerializeToString(request);
+            string serializedRequest = Serializer.SerializeToString(request);
 
             var deserializedRequest = JsonConvert.DeserializeObject<GraphQLRequest>(serializedRequest);
             var inputs = deserializedRequest.Variables != null
@@ -103,8 +103,8 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
             var result = await _documentExecuter.ExecuteAsync(options =>
             {
                 options.Schema = Schema;
-                options.OperationName = request.OperationName;
-                options.Query = request.Query;
+                options.OperationName = deserializedRequest?.OperationName;
+                options.Query = deserializedRequest?.Query;
                 options.Inputs = inputs;
                 options.CancellationToken = cancellationToken;
             });
@@ -112,13 +112,12 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
             return result;
         }
 
-        private async Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponse<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
+        private async Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponseAsync<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
         {
-            string json = await _documentWriter.WriteToStringAsync(executionResult);
-            // serialize result into utf8 byte stream
-            var resultStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
-            // deserialize using the provided serializer
-            return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(resultStream, cancellationToken);
+            using var stream = new MemoryStream();
+            await _documentWriter.WriteAsync(stream, executionResult, cancellationToken);
+            stream.Seek(0, SeekOrigin.Begin);
+            return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(stream, cancellationToken);
         }
 
         #endregion
diff --git a/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
new file mode 100644
index 00000000..3d961d14
--- /dev/null
+++ b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
@@ -0,0 +1,18 @@
+using GraphQL.Client.Abstractions;
+using GraphQL.DI;
+using GraphQL.MicrosoftDI;
+using GraphQL.Types;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GraphQL.Client.LocalExecution
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IGraphQLBuilder AddGraphQLLocalExecutionClient<TSchema>(this IServiceCollection services) where TSchema : ISchema
+        {
+            services.AddSingleton<GraphQLLocalExecutionClient<TSchema>>();
+            services.AddSingleton<IGraphQLClient, GraphQLLocalExecutionClient<TSchema>>();
+            return services.AddGraphQL();
+        }
+    }
+}

From 7cb148e98ecc5b6c34d05c714f161a7fdc008e76 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Fri, 29 Oct 2021 14:40:28 +0200
Subject: [PATCH 350/455] fix preprocessing of queries and mutations when sent
 via websocket

---
 .../GraphQLLocalExecutionClient.cs            |  1 -
 .../Websocket/GraphQLHttpWebSocket.cs         | 98 +++++++++----------
 2 files changed, 49 insertions(+), 50 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 624526f3..bd2b54fa 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -4,7 +4,6 @@
 using System.Linq;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index ec4ac4b7..9f12d5bf 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -182,7 +182,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                                 catch (OperationCanceledException) { }
                             })
                         );
-                        
+
                         Debug.WriteLine($"sending start message on subscription {startRequest.Id}");
                         // send subscription request
                         try
@@ -265,55 +265,55 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         /// <returns></returns>
         public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) =>
             Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+            {
+                var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client);
+                var websocketRequest = new GraphQLWebSocketRequest
                 {
-                    await _client.Options.PreprocessRequest(request, _client);
-                    var websocketRequest = new GraphQLWebSocketRequest
+                    Id = Guid.NewGuid().ToString("N"),
+                    Type = GraphQLWebSocketMessageType.GQL_START,
+                    Payload = preprocessedRequest
+                };
+                var observable = IncomingMessageStream
+                    .Where(response => response != null && response.Id == websocketRequest.Id)
+                    .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                    .Select(response =>
                     {
-                        Id = Guid.NewGuid().ToString("N"),
-                        Type = GraphQLWebSocketMessageType.GQL_START,
-                        Payload = request
-                    };
-                    var observable = IncomingMessageStream
-                        .Where(response => response != null && response.Id == websocketRequest.Id)
-                        .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-                        .Select(response =>
-                        {
-                            Debug.WriteLine($"received response for request {websocketRequest.Id}");
-                            var typedResponse =
-                                _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-                                    response.MessageBytes);
-                            return typedResponse.Payload;
-                        });
+                        Debug.WriteLine($"received response for request {websocketRequest.Id}");
+                        var typedResponse =
+                            _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                response.MessageBytes);
+                        return typedResponse.Payload;
+                    });
 
-                    try
-                    {
-                        // initialize websocket (completes immediately if socket is already open)
-                        await InitializeWebSocket();
-                    }
-                    catch (Exception e)
-                    {
-                        // subscribe observer to failed observable
-                        return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-                    }
+                try
+                {
+                    // initialize websocket (completes immediately if socket is already open)
+                    await InitializeWebSocket();
+                }
+                catch (Exception e)
+                {
+                    // subscribe observer to failed observable
+                    return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+                }
 
-                    var disposable = new CompositeDisposable(
-                        observable.Subscribe(observer)
-                    );
+                var disposable = new CompositeDisposable(
+                    observable.Subscribe(observer)
+                );
 
-                    Debug.WriteLine($"submitting request {websocketRequest.Id}");
-                    // send request
-                    try
-                    {
-                        await QueueWebSocketRequest(websocketRequest);
-                    }
-                    catch (Exception e)
-                    {
-                        Debug.WriteLine(e);
-                        throw;
-                    }
+                Debug.WriteLine($"submitting request {websocketRequest.Id}");
+                // send request
+                try
+                {
+                    await QueueWebSocketRequest(websocketRequest);
+                }
+                catch (Exception e)
+                {
+                    Debug.WriteLine(e);
+                    throw;
+                }
 
-                    return disposable;
-                })
+                return disposable;
+            })
                 // complete sequence on OperationCanceledException, this is triggered by the cancellation token
                 .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
                     Observable.Empty<GraphQLResponse<TResponse>>())
@@ -410,7 +410,7 @@ public Task InitializeWebSocket()
                 }
                 catch (NotImplementedException)
                 {
-                    Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not implemented by current platform");                
+                    Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not implemented by current platform");
                 }
                 catch (PlatformNotSupportedException)
                 {
@@ -423,7 +423,7 @@ public Task InitializeWebSocket()
                 }
                 catch (NotImplementedException)
                 {
-                    Debug.WriteLine("property 'ClientWebSocketOptions.UseDefaultCredentials' not implemented by current platform");    
+                    Debug.WriteLine("property 'ClientWebSocketOptions.UseDefaultCredentials' not implemented by current platform");
                 }
                 catch (PlatformNotSupportedException)
                 {
@@ -479,7 +479,7 @@ private async Task ConnectAsync(CancellationToken token)
                 Debug.WriteLine($"new incoming message stream {_incomingMessages.GetHashCode()} created");
 
                 _incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
-                
+
                 var initRequest = new GraphQLWebSocketRequest
                 {
                     Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
@@ -488,7 +488,7 @@ private async Task ConnectAsync(CancellationToken token)
 
                 // setup task to await connection_ack message
                 var ackTask = _incomingMessages
-                    .Where(response => response != null )
+                    .Where(response => response != null)
                     .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
                                            response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
                     .LastAsync()
@@ -640,7 +640,7 @@ private async Task CloseAsync()
             }
 
             Debug.WriteLine($"send \"connection_terminate\" message");
-            await SendWebSocketMessageAsync(new GraphQLWebSocketRequest{Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE});
+            await SendWebSocketMessageAsync(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE });
 
             Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
             await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);

From e3f8ad6306188887829894d6a143f7a606589b6a Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Fri, 29 Oct 2021 19:29:20 +0300
Subject: [PATCH 351/455] Fix for double instantiation of
 git@github.com:graphql-dotnet/graphql-client.git

---
 .../ServiceCollectionExtensions.cs                              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
index 3d961d14..0fe7b234 100644
--- a/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
+++ b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
@@ -11,7 +11,7 @@ public static class ServiceCollectionExtensions
         public static IGraphQLBuilder AddGraphQLLocalExecutionClient<TSchema>(this IServiceCollection services) where TSchema : ISchema
         {
             services.AddSingleton<GraphQLLocalExecutionClient<TSchema>>();
-            services.AddSingleton<IGraphQLClient, GraphQLLocalExecutionClient<TSchema>>();
+            services.AddSingleton<IGraphQLClient>(p => p.GetRequiredService<GraphQLLocalExecutionClient<TSchema>>());
             return services.AddGraphQL();
         }
     }

From 2fcfc086e319dc439a28e9812c6965fb2dbdd01d Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 1 Nov 2021 21:46:22 +0100
Subject: [PATCH 352/455] upgrade test dependencies, implement
 ConfigureAwait(false) in libs

---
 .editorconfig                                 |   3 +
 GraphQL.Client.sln                            |   6 +
 examples/.editorconfig                        |   2 +
 .../GraphQLLocalExecutionClient.cs            |  12 +-
 src/GraphQL.Client/GraphQLHttpClient.cs       |  14 +-
 .../Websocket/GraphQLHttpWebSocket.cs         |  44 +--
 .../.editorconfig                             |   2 +
 .../FluentTestObserver.cs                     | 124 -------
 .../NoSynchronizationContextScope.cs          |  40 ---
 .../ReactiveAssertions.cs                     | 309 ------------------
 .../ReactiveExtensions.cs                     | 108 ------
 .../RollingReplaySubject.cs                   |  64 ----
 .../GraphQL.Client.Tests.Common.csproj        |   3 +-
 .../Helpers/CallbackMonitor.cs                |   6 +-
 tests/GraphQL.Integration.Tests/.editorconfig |   2 +
 .../GraphQL.Integration.Tests.csproj          |   4 +-
 .../QueryAndMutationTests/Base.cs             |   6 +-
 .../WebsocketTests/Base.cs                    |   4 +-
 tests/GraphQL.Primitives.Tests/.editorconfig  |   2 +
 tests/GraphQL.Server.Test/.editorconfig       |   2 +
 tests/IntegrationTestServer/.editorconfig     |   2 +
 tests/tests.props                             |   8 +-
 22 files changed, 70 insertions(+), 697 deletions(-)
 create mode 100644 examples/.editorconfig
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/.editorconfig
 delete mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
 delete mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs
 delete mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveAssertions.cs
 delete mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveExtensions.cs
 delete mode 100644 tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
 create mode 100644 tests/GraphQL.Integration.Tests/.editorconfig
 create mode 100644 tests/GraphQL.Primitives.Tests/.editorconfig
 create mode 100644 tests/GraphQL.Server.Test/.editorconfig
 create mode 100644 tests/IntegrationTestServer/.editorconfig

diff --git a/.editorconfig b/.editorconfig
index 8f9adfad..33d7fdc4 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -254,3 +254,6 @@ dotnet_naming_style.end_in_async_style.required_suffix = Async
 
 # dotnet_naming_rule.<namingRuleTitle>.severity = <value>
 dotnet_naming_rule.async_methods_end_in_async.severity = warning
+
+# ReSharper: Configure await
+configure_await_analysis_mode = library
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index ab95f2ec..01a7ad88 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -5,6 +5,7 @@ VisualStudioVersion = 16.0.28407.52
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{47C98B55-08F1-4428-863E-2C5C876DEEFE}"
 	ProjectSection(SolutionItems) = preProject
+		src\.editorconfig = src\.editorconfig
 		src\src.props = src\src.props
 	EndProjectSection
 EndProject
@@ -14,6 +15,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		.gitignore = .gitignore
 		dotnet-tools.json = dotnet-tools.json
 		LICENSE.txt = LICENSE.txt
+		examples\GraphQL.Client.Example\Program.cs = examples\GraphQL.Client.Example\Program.cs
 		README.md = README.md
 		root.props = root.props
 	EndProjectSection
@@ -65,6 +67,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{89
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Example", "examples\GraphQL.Client.Example\GraphQL.Client.Example.csproj", "{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{98D4DDDD-DE15-4997-B888-9BC806C7416C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -133,6 +137,7 @@ Global
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{E95A1258-F666-4D4E-9101-E0C46F6A3CB3} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{05CAF9B2-981E-40C0-AE31-5FA56E351F12} = {98D4DDDD-DE15-4997-B888-9BC806C7416C}
 		{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{C212983F-67DB-44EB-BFB0-5DA75A86DF55} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{92107DF5-73DF-4371-8EB1-6734FED704AD} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
@@ -146,6 +151,7 @@ Global
 		{0D307BAD-27AE-4A5D-8764-4AA2620B01E9} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 		{7FFFEC00-D751-4FFC-9FD4-E91858F9A1C5} = {47C98B55-08F1-4428-863E-2C5C876DEEFE}
 		{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD} = {89AD33AB-64F6-4F82-822F-21DF7A10CEC0}
+		{98D4DDDD-DE15-4997-B888-9BC806C7416C} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/examples/.editorconfig b/examples/.editorconfig
new file mode 100644
index 00000000..d1655ff8
--- /dev/null
+++ b/examples/.editorconfig
@@ -0,0 +1,2 @@
+# Configure await
+configure_await_analysis_mode = disabled
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index bd2b54fa..889bc991 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -76,12 +76,12 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
         private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken)
         {
-            var executionResult = await ExecuteAsync(request, cancellationToken);
-            return await ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, cancellationToken);
+            var executionResult = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+            return await ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, cancellationToken).ConfigureAwait(false);
         }
         private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
-            var result = await ExecuteAsync(request, cancellationToken);
+            var result = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
             var stream = ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault();
 
             return stream == null
@@ -106,7 +106,7 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
                 options.Query = deserializedRequest?.Query;
                 options.Inputs = inputs;
                 options.CancellationToken = cancellationToken;
-            });
+            }).ConfigureAwait(false);
 
             return result;
         }
@@ -114,9 +114,9 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
         private async Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponseAsync<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
         {
             using var stream = new MemoryStream();
-            await _documentWriter.WriteAsync(stream, executionResult, cancellationToken);
+            await _documentWriter.WriteAsync(stream, executionResult, cancellationToken).ConfigureAwait(false);
             stream.Seek(0, SeekOrigin.Begin);
-            return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(stream, cancellationToken);
+            return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(stream, cancellationToken).ConfigureAwait(false);
         }
 
         #endregion
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 9d2aac47..cd51622c 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -85,9 +85,9 @@ public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLR
             if (Options.UseWebSocketForQueriesAndMutations ||
                 !(Options.WebSocketEndPoint is null) && Options.EndPoint is null ||
                 Options.EndPoint.HasWebSocketScheme())
-                return await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken);
+                return await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken).ConfigureAwait(false);
 
-            return await SendHttpRequestAsync<TResponse>(request, cancellationToken);
+            return await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -140,16 +140,16 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
         private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
-            var preprocessedRequest = await Options.PreprocessRequest(request, this);
+            var preprocessedRequest = await Options.PreprocessRequest(request, this).ConfigureAwait(false);
 
             using var httpRequestMessage = preprocessedRequest.ToHttpRequestMessage(Options, JsonSerializer);
-            using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+            using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
 
-            var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync();
+            var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
 
             if (httpResponseMessage.IsSuccessStatusCode)
             {
-                var graphQLResponse = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(contentStream, cancellationToken);
+                var graphQLResponse = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(contentStream, cancellationToken).ConfigureAwait(false);
                 return graphQLResponse.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
             }
 
@@ -157,7 +157,7 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TRespons
             string content = null;
             if (contentStream != null)
                 using (var sr = new StreamReader(contentStream))
-                    content = await sr.ReadToEndAsync();
+                    content = await sr.ReadToEndAsync().ConfigureAwait(false);
 
             throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
         }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 9f12d5bf..0c4ffdff 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -99,7 +99,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                     Observable.Create<GraphQLResponse<TResponse>>(async observer =>
                     {
                         Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
-                        var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client);
+                        var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
 
                         var startRequest = new GraphQLWebSocketRequest
                         {
@@ -157,7 +157,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         try
                         {
                             // initialize websocket (completes immediately if socket is already open)
-                            await InitializeWebSocket();
+                            await InitializeWebSocket().ConfigureAwait(false);
                         }
                         catch (Exception e)
                         {
@@ -176,7 +176,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                                 try
                                 {
                                     Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
-                                    await QueueWebSocketRequest(stopRequest);
+                                    await QueueWebSocketRequest(stopRequest).ConfigureAwait(false);
                                 }
                                 // do not break on disposing
                                 catch (OperationCanceledException) { }
@@ -187,7 +187,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         // send subscription request
                         try
                         {
-                            await QueueWebSocketRequest(startRequest);
+                            await QueueWebSocketRequest(startRequest).ConfigureAwait(false);
                         }
                         catch (Exception e)
                         {
@@ -266,7 +266,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) =>
             Observable.Create<GraphQLResponse<TResponse>>(async observer =>
             {
-                var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client);
+                var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
                 var websocketRequest = new GraphQLWebSocketRequest
                 {
                     Id = Guid.NewGuid().ToString("N"),
@@ -288,7 +288,7 @@ public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest re
                 try
                 {
                     // initialize websocket (completes immediately if socket is already open)
-                    await InitializeWebSocket();
+                    await InitializeWebSocket().ConfigureAwait(false);
                 }
                 catch (Exception e)
                 {
@@ -304,7 +304,7 @@ public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest re
                 // send request
                 try
                 {
-                    await QueueWebSocketRequest(websocketRequest);
+                    await QueueWebSocketRequest(websocketRequest).ConfigureAwait(false);
                 }
                 catch (Exception e)
                 {
@@ -336,8 +336,8 @@ private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest reque
                     return Unit.Default;
                 }
 
-                await InitializeWebSocket();
-                await SendWebSocketMessageAsync(request, _internalCancellationToken);
+                await InitializeWebSocket().ConfigureAwait(false);
+                await SendWebSocketMessageAsync(request, _internalCancellationToken).ConfigureAwait(false);
                 request.SendCompleted();
             }
             catch (Exception e)
@@ -354,7 +354,7 @@ await _clientWebSocket.SendAsync(
                 new ArraySegment<byte>(requestBytes),
                 WebSocketMessageType.Text,
                 true,
-                cancellationToken);
+                cancellationToken).ConfigureAwait(false);
         }
 
         #endregion
@@ -440,13 +440,13 @@ private async Task ConnectAsync(CancellationToken token)
         {
             try
             {
-                await BackOff();
+                await BackOff().ConfigureAwait(false);
                 _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
                 Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
-                await _clientWebSocket.ConnectAsync(_webSocketUri, token);
+                await _clientWebSocket.ConnectAsync(_webSocketUri, token).ConfigureAwait(false);
                 _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
                 Debug.WriteLine($"connection established on websocket {_clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
-                await (Options.OnWebsocketConnected?.Invoke(_client) ?? Task.CompletedTask);
+                await (Options.OnWebsocketConnected?.Invoke(_client) ?? Task.CompletedTask).ConfigureAwait(false);
                 Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {_clientWebSocket.GetHashCode()}");
                 _connectionAttempt = 1;
 
@@ -496,8 +496,8 @@ private async Task ConnectAsync(CancellationToken token)
 
                 // send connection init
                 Debug.WriteLine($"sending connection init message");
-                await SendWebSocketMessageAsync(initRequest);
-                var response = await ackTask;
+                await SendWebSocketMessageAsync(initRequest).ConfigureAwait(false);
+                var response = await ackTask.ConfigureAwait(false);
 
                 if (response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
                     Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
@@ -537,7 +537,7 @@ private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
             Observable.Create<WebsocketMessageWrapper>(async observer =>
                 {
                     // make sure the websocket is connected
-                    await InitializeWebSocket();
+                    await InitializeWebSocket().ConfigureAwait(false);
                     // subscribe observer to message stream
                     var subscription = new CompositeDisposable(_incomingMessages
                         .Subscribe(observer))
@@ -591,7 +591,7 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
                 do
                 {
                     // cancellation is done implicitly via the close method
-                    webSocketReceiveResult = await _clientWebSocket.ReceiveAsync(_buffer, CancellationToken.None);
+                    webSocketReceiveResult = await _clientWebSocket.ReceiveAsync(_buffer, CancellationToken.None).ConfigureAwait(false);
                     ms.Write(_buffer.Array, _buffer.Offset, webSocketReceiveResult.Count);
                 }
                 while (!webSocketReceiveResult.EndOfMessage && !_internalCancellationToken.IsCancellationRequested);
@@ -602,13 +602,13 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
                 switch (webSocketReceiveResult.MessageType)
                 {
                     case WebSocketMessageType.Text:
-                        var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+                        var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
                         response.MessageBytes = ms.ToArray();
                         Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
                         return response;
 
                     case WebSocketMessageType.Close:
-                        var closeResponse = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms);
+                        var closeResponse = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
                         closeResponse.MessageBytes = ms.ToArray();
                         Debug.WriteLine($"Connection closed by the server.");
                         throw new Exception("Connection closed by the server.");
@@ -640,10 +640,10 @@ private async Task CloseAsync()
             }
 
             Debug.WriteLine($"send \"connection_terminate\" message");
-            await SendWebSocketMessageAsync(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE });
+            await SendWebSocketMessageAsync(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE }).ConfigureAwait(false);
 
             Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
-            await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
+            await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false);
             _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
         }
 
@@ -679,7 +679,7 @@ private async Task CompleteAsync()
             if (!_internalCancellationTokenSource.IsCancellationRequested)
                 _internalCancellationTokenSource.Cancel();
 
-            await CloseAsync();
+            await CloseAsync().ConfigureAwait(false);
             _requestSubscription?.Dispose();
             _clientWebSocket?.Dispose();
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/.editorconfig b/tests/GraphQL.Client.Serializer.Tests/.editorconfig
new file mode 100644
index 00000000..d1655ff8
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/.editorconfig
@@ -0,0 +1,2 @@
+# Configure await
+configure_await_analysis_mode = disabled
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
deleted file mode 100644
index 5b494159..00000000
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/FluentTestObserver.cs
+++ /dev/null
@@ -1,124 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Reactive;
-using System.Reactive.Concurrency;
-using System.Reactive.Disposables;
-using System.Reactive.Linq;
-using Microsoft.Reactive.Testing;
-
-namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
-{
-    /// <summary>
-    /// Observer for testing <see cref="Observable"/>s using the FluentAssertions framework
-    /// </summary>
-    /// <typeparam name="TPayload"></typeparam>
-    public class FluentTestObserver<TPayload> : IObserver<TPayload>, IDisposable
-    {
-        private readonly IDisposable _subscription;
-        private readonly IScheduler _observeScheduler;
-        private readonly RollingReplaySubject<Recorded<Notification<TPayload>>> _rollingReplaySubject = new RollingReplaySubject<Recorded<Notification<TPayload>>>();
-
-        /// <summary>
-        /// The observable which is observed by this instance
-        /// </summary>
-        public IObservable<TPayload> Subject { get; }
-
-        /// <summary>
-        /// The stream of recorded <see cref="Notification{T}"/>s
-        /// </summary>
-        public IObservable<Recorded<Notification<TPayload>>> RecordedNotificationStream => _rollingReplaySubject.AsObservable();
-
-        /// <summary>
-        /// The recorded <see cref="Notification{T}"/>s
-        /// </summary>
-        public IEnumerable<Recorded<Notification<TPayload>>> RecordedNotifications =>
-            _rollingReplaySubject.GetSnapshot();
-
-        /// <summary>
-        /// The recorded messages
-        /// </summary>
-        public IEnumerable<TPayload> RecordedMessages =>
-            RecordedNotifications.GetMessages();
-        
-        /// <summary>
-        /// The exception 
-        /// </summary>
-        public Exception Error =>
-            RecordedNotifications
-                .Where(r => r.Value.Kind == NotificationKind.OnError)
-                .Select(r => r.Value.Exception)
-                .FirstOrDefault();
-        
-        /// <summary>
-        /// The recorded messages
-        /// </summary>
-        public bool Completed =>
-            RecordedNotifications
-                .Any(r => r.Value.Kind == NotificationKind.OnCompleted);
-
-        /// <summary>
-        /// Creates a new <see cref="FluentTestObserver{TPayload}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
-        /// </summary>
-        /// <param name="subject">the <see cref="IObservable{T}"/> under test</param>
-        public FluentTestObserver(IObservable<TPayload> subject)
-        {
-            Subject = subject;
-            _observeScheduler = new EventLoopScheduler();
-            _subscription = subject.ObserveOn(_observeScheduler).Subscribe(this);
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="FluentTestObserver{TPayload}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
-        /// </summary>
-        /// <param name="subject">the <see cref="IObservable{T}"/> under test</param>
-        public FluentTestObserver(IObservable<TPayload> subject, IScheduler scheduler)
-        {
-            Subject = subject;
-            _observeScheduler = scheduler;
-            _subscription = subject.ObserveOn(scheduler).Subscribe(this);
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="FluentTestObserver{TPayload}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
-        /// </summary>
-        /// <param name="subject">the <see cref="IObservable{T}"/> under test</param>
-        public FluentTestObserver(IObservable<TPayload> subject, TestScheduler testScheduler)
-        {
-            Subject = subject;
-            _observeScheduler = testScheduler;
-            _subscription = subject.ObserveOn(Scheduler.CurrentThread).Subscribe(this);
-        }
-
-        /// <summary>
-        /// Clears the recorded notifications and messages as well as the recorded notifications stream buffer
-        /// </summary>
-        public void Clear() => _rollingReplaySubject.Clear();
-
-        /// <inheritdoc />
-        public void OnNext(TPayload value) =>
-            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnNext(value)));
-
-        /// <inheritdoc />
-        public void OnError(Exception exception) =>
-            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnError<TPayload>(exception)));
-
-        /// <inheritdoc />
-        public void OnCompleted() =>
-            _rollingReplaySubject.OnNext(new Recorded<Notification<TPayload>>(_observeScheduler.Now.UtcTicks, Notification.CreateOnCompleted<TPayload>()));
-        
-        /// <inheritdoc />
-        public void Dispose()
-        {
-            _subscription?.Dispose();
-            _rollingReplaySubject?.Dispose();
-        }
-
-        /// <summary>
-        /// Returns an <see cref="ReactiveAssertions{TPayload}"/> object that can be used to assert the observed <see cref="IObservable{T}"/>
-        /// </summary>
-        /// <returns></returns>
-        public ReactiveAssertions<TPayload> Should() => new ReactiveAssertions<TPayload>(this);
-    }
-}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs
deleted file mode 100644
index c728a671..00000000
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/NoSynchronizationContextScope.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
-{
-    internal static class NoSynchronizationContextScope
-    {
-        public static T ExecuteInDefaultSynchronizationContext<T>(this Task<T> task)
-        {
-            using (NoSynchronizationContextScope.Enter())
-            {
-                task.Wait();
-                return task.Result;
-            }
-        }
-
-        public static DisposingAction Enter()
-        {
-            var context = SynchronizationContext.Current;
-            SynchronizationContext.SetSynchronizationContext(null);
-            return new DisposingAction(() => SynchronizationContext.SetSynchronizationContext(context));
-        }
-
-        internal class DisposingAction : IDisposable
-        {
-            private readonly Action action;
-
-            public DisposingAction(Action action)
-            {
-                this.action = action;
-            }
-
-            public void Dispose()
-            {
-                action();
-            }
-        }
-    }
-}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveAssertions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveAssertions.cs
deleted file mode 100644
index b9aa410c..00000000
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveAssertions.cs
+++ /dev/null
@@ -1,309 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reactive;
-using System.Reactive.Linq;
-using System.Reactive.Threading.Tasks;
-using System.Threading.Tasks;
-using FluentAssertions;
-using FluentAssertions.Execution;
-using FluentAssertions.Primitives;
-using FluentAssertions.Specialized;
-using Microsoft.Reactive.Testing;
-
-namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
-{
-    /// <summary>
-    /// Provides methods to assert an <see cref="IObservable{T}"/> observed by a <see cref="FluentTestObserver{TPayload}"/>
-    /// </summary>
-    /// <typeparam name="TPayload"></typeparam>
-    public class ReactiveAssertions<TPayload> : ReferenceTypeAssertions<IObservable<TPayload>, ReactiveAssertions<TPayload>>
-    {
-        private readonly IExtractExceptions extractor = new AggregateExceptionExtractor();
-        public FluentTestObserver<TPayload> Observer { get; }
-
-        protected internal ReactiveAssertions(FluentTestObserver<TPayload> observer): base(observer.Subject)
-        {
-            Observer = observer;
-        }
-
-        protected override string Identifier => "Subscription";
-
-        /// <summary>
-        /// Asserts that at least <paramref name="numberOfNotifications"/> notifications were pushed to the <see cref="FluentTestObserver{TPayload}"/> within the specified <paramref name="timeout"/>.<br />
-        /// This includes any previously recorded notifications since it has been created or cleared.
-        /// </summary> 
-        /// <param name="numberOfNotifications">the number of notifications the observer should have recorded by now</param>
-        /// <param name="timeout">the maximum time to wait for the notifications to arrive</param>
-        /// <param name="because"></param>
-        /// <param name="becauseArgs"></param>
-        public AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
-        {
-            IList<TPayload> notifications = new List<TPayload>();
-            var assertion = Execute.Assertion
-                .WithExpectation($"Expected observable to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
-                .BecauseOf(because, becauseArgs);
-
-            try
-            {
-                notifications = Observer.RecordedNotificationStream
-                    .Select(r => r.Value)
-                    .Dematerialize()
-                    .Take(numberOfNotifications)
-                    .Timeout(timeout)
-                    .Catch<TPayload, TimeoutException>(exception => Observable.Empty<TPayload>())
-                    .ToList()
-                    .ToTask()
-                    .ExecuteInDefaultSynchronizationContext();
-            }
-            catch (Exception e)
-            {
-                if(e is AggregateException aggregateException)
-                    e = aggregateException.InnerException;
-                assertion.FailWith("but it failed with a {0}.", e);
-            }
-
-            assertion
-                .ForCondition(notifications.Count >= numberOfNotifications)
-                .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
-
-            return new AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
-        }
-
-        /// <inheritdoc cref="Push(int,TimeSpan,string,object[])"/>
-        public async Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
-        {
-            IList<TPayload> notifications = new List<TPayload>();
-            var assertion = Execute.Assertion
-                .WithExpectation($"Expected observable to push at least {numberOfNotifications} {(numberOfNotifications == 1 ? "notification" : "notifications")}, ")
-                .BecauseOf(because, becauseArgs);
-
-            try
-            {
-                notifications = await Observer.RecordedNotificationStream
-                    .Select(r => r.Value)
-                    .Dematerialize()
-                    .Take(numberOfNotifications)
-                    .Timeout(timeout)
-                    .Catch<TPayload, TimeoutException>(exception => Observable.Empty<TPayload>())
-                    .ToList()
-                    .ToTask();
-            }
-            catch (Exception e)
-            {
-                if (e is AggregateException aggregateException)
-                    e = aggregateException.InnerException;
-                assertion.FailWith("but it failed with a {0}.", e);
-            }
-
-            assertion
-                .ForCondition(notifications.Count >= numberOfNotifications)
-                .FailWith("but {0} were received within {1}.", notifications.Count, timeout);
-
-            return new AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>(this, notifications);
-        }
-
-        /// <summary>
-        /// Asserts that at least <paramref name="numberOfNotifications"/> notifications are pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
-        /// This includes any previously recorded notifications since it has been created or cleared. 
-        /// </summary>
-        /// <param name="numberOfNotifications">the number of notifications the observer should have recorded by now</param>
-        /// <param name="because"></param>
-        /// <param name="becauseArgs"></param>
-        public AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> Push(int numberOfNotifications, string because = "", params object[] becauseArgs)
-            => Push(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
-
-        /// <inheritdoc cref="Push(int,string,object[])"/>
-        public Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(int numberOfNotifications, string because = "", params object[] becauseArgs)
-            => PushAsync(numberOfNotifications, TimeSpan.FromSeconds(10), because, becauseArgs);
-
-        /// <summary>
-        /// Asserts that at least 1 notification is pushed to the <see cref="FluentTestObserver{TPayload}"/> within the next 1 second.<br />
-        /// This includes any previously recorded notifications since it has been created or cleared. 
-        /// </summary>
-        public AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> Push(string because = "", params object[] becauseArgs)
-            => Push(1, TimeSpan.FromSeconds(1), because, becauseArgs);
-
-        /// <inheritdoc cref="Push(string,object[])"/>
-        public Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>> PushAsync(string because = "", params object[] becauseArgs)
-            => PushAsync(1, TimeSpan.FromSeconds(1), because, becauseArgs);
-
-        /// <summary>
-        /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the specified <paramref name="timeout"/>.<br />
-        /// This includes any previously recorded notifications since it has been created or cleared. 
-        /// </summary>
-        public AndConstraint<ReactiveAssertions<TPayload>> NotPush(TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
-        {
-            bool anyNotifications = Observer.RecordedNotificationStream
-                .Any(recorded => recorded.Value.Kind == NotificationKind.OnNext)
-                .Timeout(timeout)
-                .Catch(Observable.Return(false))
-                .ToTask()
-                .ExecuteInDefaultSynchronizationContext();
-
-            Execute.Assertion
-                .ForCondition(!anyNotifications)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected observable to not push any notifications{reason}, but it did.");
-            
-            return new AndConstraint<ReactiveAssertions<TPayload>>(this);
-        }
-
-        /// <summary>
-        /// Asserts that the <see cref="FluentTestObserver{TPayload}"/> does not receive any notifications within the next 100 milliseconds.<br />
-        /// This includes any previously recorded notifications since it has been created or last cleared. 
-        /// </summary>
-        public AndConstraint<ReactiveAssertions<TPayload>> NotPush(string because = "", params object[] becauseArgs)
-            => NotPush(TimeSpan.FromMilliseconds(100), because, becauseArgs);
-
-        /// <summary>
-        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the specified <paramref name="timeout"/>. 
-        /// </summary>
-        public ExceptionAssertions<TException> Throw<TException>(TimeSpan timeout, string because = "", params object[] becauseArgs)
-            where TException : Exception
-        {
-            var notifications = GetRecordedNotifications(timeout).ExecuteInDefaultSynchronizationContext();
-            return Throw<TException>(notifications, because, becauseArgs);
-        }
-
-        /// <inheritdoc cref="Throw"/>
-        public async Task<ExceptionAssertions<TException>> ThrowAsync<TException>(TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
-            where TException : Exception
-        {
-            var notifications = await GetRecordedNotifications(timeout);
-            return Throw<TException>(notifications, because, becauseArgs);
-        }
-
-        /// <summary>
-        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> fails within the next 1 second. 
-        /// </summary>
-        public ExceptionAssertions<TException> Throw<TException>(string because = "", params object[] becauseArgs)
-            where TException : Exception
-            => Throw<TException>(TimeSpan.FromSeconds(1), because, becauseArgs);
-
-        /// <inheritdoc cref="Throw(string,object[])"/>
-        public Task<ExceptionAssertions<TException>> ThrowAsync<TException>(string because = "", params object[] becauseArgs)
-            where TException : Exception
-            => ThrowAsync<TException>(TimeSpan.FromSeconds(1), because, becauseArgs);
-
-        /// <summary>
-        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the specified <paramref name="timeout"/>. 
-        /// </summary>
-        public AndConstraint<ReactiveAssertions<TPayload>> Complete(TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
-        {
-            var notifications = GetRecordedNotifications(timeout).ExecuteInDefaultSynchronizationContext();
-
-            return Complete(timeout, because, becauseArgs, notifications);
-        }
-
-
-        /// <inheritdoc cref="Complete(System.TimeSpan,string,object[])"/>
-        public async Task<AndConstraint<ReactiveAssertions<TPayload>>> CompleteAsync(TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
-        {
-            var notifications = await GetRecordedNotifications(timeout);
-
-            return Complete(timeout, because, becauseArgs, notifications);
-        }
-
-        /// <summary>
-        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> completes within the next 1 second. 
-        /// </summary>
-        public AndConstraint<ReactiveAssertions<TPayload>> Complete(string because = "", params object[] becauseArgs)
-            => Complete(TimeSpan.FromSeconds(1), because, becauseArgs);
-
-        /// <inheritdoc cref="Complete(string,object[])"/>
-        public Task<AndConstraint<ReactiveAssertions<TPayload>>> CompleteAsync(string because = "", params object[] becauseArgs)
-            => CompleteAsync(TimeSpan.FromSeconds(1), because, becauseArgs);
-
-        /// <summary>
-        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the specified <paramref name="timeout"/>. 
-        /// </summary>
-        public AndConstraint<ReactiveAssertions<TPayload>> NotComplete(TimeSpan timeout,
-            string because = "", params object[] becauseArgs)
-        {
-            bool completed = Observer.RecordedNotificationStream
-                .Any(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
-                .Timeout(timeout)
-                .Catch(Observable.Return(false))
-                .ToTask()
-                .ExecuteInDefaultSynchronizationContext();
-
-            Execute.Assertion
-                .ForCondition(!completed)
-                .BecauseOf(because, becauseArgs)
-                .FailWith("Expected observable to not complete{reason}, but it did.");
-            
-            return new AndConstraint<ReactiveAssertions<TPayload>>(this);
-        }
-
-        /// <summary>
-        /// Asserts that the <see cref="IObservable{T}"/> observed by the <see cref="FluentTestObserver{TPayload}"/> does not complete within the next 100 milliseconds. 
-        /// </summary>
-        public AndConstraint<ReactiveAssertions<TPayload>> NotComplete(string because = "", params object[] becauseArgs)
-            => NotComplete(TimeSpan.FromMilliseconds(100), because, becauseArgs);
-
-        protected Task<IList<Recorded<Notification<TPayload>>>> GetRecordedNotifications(TimeSpan timeout) =>
-            Observer.RecordedNotificationStream
-                .TakeUntil(recorded => recorded.Value.Kind == NotificationKind.OnError)
-                .TakeUntil(recorded => recorded.Value.Kind == NotificationKind.OnCompleted)
-                .Timeout(timeout)
-                .Catch(Observable.Empty<Recorded<Notification<TPayload>>>())
-                .ToList()
-                .ToTask();
-
-        protected ExceptionAssertions<TException> Throw<TException>(IList<Recorded<Notification<TPayload>>> notifications, string because, object[] becauseArgs)
-            where TException : Exception
-        {
-            var exception = notifications
-                .Where(r => r.Value.Kind == NotificationKind.OnError)
-                .Select(r => r.Value.Exception)
-                .FirstOrDefault();
-
-            TException[] expectedExceptions = extractor.OfType<TException>(exception).ToArray();
-
-            Execute.Assertion
-                .BecauseOf(because, becauseArgs)
-                .WithExpectation("Expected observable to throw a <{0}>{reason}, ", typeof(TException))
-                .ForCondition(exception != null)
-                .FailWith("but no exception was thrown.")
-                .Then
-                .ForCondition(expectedExceptions.Any())
-                .FailWith("but found <{0}>: {1}{2}.",
-                    exception?.GetType(),
-                    Environment.NewLine,
-                    exception)
-                .Then
-                .ClearExpectation();
-
-            return new ExceptionAssertions<TException>(expectedExceptions);
-        }
-
-        protected AndConstraint<ReactiveAssertions<TPayload>> Complete(TimeSpan timeout, string because, object[] becauseArgs, IList<Recorded<Notification<TPayload>>> notifications)
-        {
-            var exception = notifications
-                .Where(r => r.Value.Kind == NotificationKind.OnError)
-                .Select(r => r.Value.Exception)
-                .FirstOrDefault();
-
-            Execute.Assertion
-                .WithExpectation("Expected observable to complete within {0}{reason}, ", timeout)
-                .BecauseOf(because, becauseArgs)
-                .ForCondition(exception is null)
-                .FailWith("but it failed with <{0}>: {1}{2}.",
-                    exception?.GetType(),
-                    Environment.NewLine,
-                    exception)
-                .Then
-                .ForCondition(notifications.Any(r => r.Value.Kind == NotificationKind.OnCompleted))
-                .FailWith("but it did not.");
-
-            return new AndConstraint<ReactiveAssertions<TPayload>>(this);
-        }
-    }
-}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveExtensions.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveExtensions.cs
deleted file mode 100644
index 8894ab99..00000000
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/ReactiveExtensions.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Reactive;
-using System.Reactive.Concurrency;
-using System.Threading.Tasks;
-using FluentAssertions;
-using FluentAssertions.Execution;
-using Microsoft.Reactive.Testing;
-
-namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
-{
-    public static class ReactiveExtensions
-    {
-        /// <summary>
-        /// Create a new <see cref="FluentTestObserver{TPayload}"/> subscribed to this <paramref name="observable"/>
-        /// </summary>
-        public static FluentTestObserver<T> Observe<T>(this IObservable<T> observable) => new FluentTestObserver<T>(observable);
-
-        /// <summary>
-        /// Create a new <see cref="FluentTestObserver{TPayload}"/> subscribed to this <paramref name="observable"/>
-        /// </summary>
-        public static FluentTestObserver<T> Observe<T>(this IObservable<T> observable, IScheduler scheduler) => new FluentTestObserver<T>(observable, scheduler);
-
-        /// <summary>
-        /// Create a new <see cref="FluentTestObserver{TPayload}"/> subscribed to this <paramref name="observable"/>
-        /// </summary>
-        public static FluentTestObserver<T> Observe<T>(this IObservable<T> observable, TestScheduler scheduler) => new FluentTestObserver<T>(observable, scheduler);
-
-        /// <summary>
-        /// Asserts that the recorded messages contain at lease one item which matches the <paramref name="predicate"/>
-        /// </summary>
-        public static AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> WithMessage<TPayload>(
-            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
-        {
-            if (predicate is null) throw new ArgumentNullException(nameof(predicate));
-            
-            var compiledPredicate = predicate.Compile();
-            bool match = recorderConstraint.Subject.Any(compiledPredicate);
-            
-            Execute.Assertion
-                .ForCondition(match)
-                .FailWith("Expected at least one message from {0} to match {1}, but found none.", recorderConstraint.And.Subject, predicate.Body);
-
-            return recorderConstraint;
-        }
-
-        /// <summary>
-        /// Asserts that the last recorded message matches the <paramref name="predicate"/>
-        /// </summary>
-        public static AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> WithLastMessage<TPayload>(
-            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>> recorderConstraint, Expression<Func<TPayload, bool>> predicate)
-        {
-            if (predicate is null)
-                throw new ArgumentNullException(nameof(predicate));
-
-            bool match = predicate.Compile().Invoke(recorderConstraint.GetLastMessage());
-
-            Execute.Assertion
-                .ForCondition(match)
-                .FailWith("Expected the last message from {0} to match {1}, but it did not.", recorderConstraint.And.Subject, predicate.Body);
-            
-            return recorderConstraint;
-        }
-
-        /// <summary>
-        /// Extracts the last recorded message
-        /// </summary>
-        public static TPayload GetLastMessage<TPayload>(
-            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>
-                recorderConstraint) =>
-            recorderConstraint.Subject.LastOrDefault();
-
-        /// <summary>
-        /// Extracts the last recorded message
-        /// </summary>
-        public static async Task<TPayload> GetLastMessageAsync<TPayload>(
-            this Task<AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<TPayload>>>
-                assertionTask)
-        {
-            var constraint = await assertionTask;
-            return constraint.Subject.LastOrDefault();
-        }
-        
-        /// <summary>
-        /// Extracts the recorded messages from a number of recorded notifications
-        /// </summary>
-        public static IEnumerable<TPayload> GetMessages<TPayload>(
-            this IEnumerable<Recorded<Notification<TPayload>>> recordedNotifications) => recordedNotifications
-            .Where(r => r.Value.Kind == NotificationKind.OnNext)
-            .Select(recorded => recorded.Value.Value);
-
-        /// <summary>
-        /// Extracts the last recorded message from a number of recorded notifications
-        /// </summary>
-        public static TPayload GetLastMessage<TPayload>(
-            this IEnumerable<Recorded<Notification<TPayload>>> recordedNotifications) =>
-            recordedNotifications.GetMessages().LastOrDefault();
-        
-        /// <summary>
-        /// Clears the recorded notifications on the underlying <see cref="FluentTestObserver{TPayload}"/>
-        /// </summary>
-        public static void Clear<TPayload>(
-            this AndWhichConstraint<ReactiveAssertions<TPayload>, IEnumerable<Recorded<Notification<TPayload>>>>
-                recorderConstraint) => recorderConstraint.And.Observer.Clear();
-    }
-}
diff --git a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs b/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
deleted file mode 100644
index df779dad..00000000
--- a/tests/GraphQL.Client.Tests.Common/FluentAssertions.Reactive/RollingReplaySubject.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Reactive.Linq;
-using System.Reactive.Subjects;
-
-namespace GraphQL.Client.Tests.Common.FluentAssertions.Reactive
-{
-    /// <summary>
-    /// Clearable <see cref="ReplaySubject{T}"/> taken from James World: https://stackoverflow.com/a/28945444/4340541
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public class RollingReplaySubject<T> : ISubject<T>, IDisposable
-    {
-        private readonly ReplaySubject<IObservable<T>> _subjects;
-        private readonly IObservable<T> _concatenatedSubjects;
-        private ISubject<T> _currentSubject;
-
-        public RollingReplaySubject()
-        {
-            _subjects = new ReplaySubject<IObservable<T>>(1);
-            _concatenatedSubjects = _subjects.Concat();
-            _currentSubject = new ReplaySubject<T>();
-            _subjects.OnNext(_currentSubject);
-        }
-
-        public void Clear()
-        {
-            _currentSubject.OnCompleted();
-            _currentSubject = new ReplaySubject<T>();
-            _subjects.OnNext(_currentSubject);
-        }
-
-        public void OnNext(T value) => _currentSubject.OnNext(value);
-
-        public void OnError(Exception error) => _currentSubject.OnError(error);
-
-        public void OnCompleted()
-        {
-            _currentSubject.OnCompleted();
-            _subjects.OnCompleted();
-            // a quick way to make the current ReplaySubject unreachable
-            // except to in-flight observers, and not hold up collection
-            _currentSubject = new Subject<T>();
-        }
-
-        public IDisposable Subscribe(IObserver<T> observer) => _concatenatedSubjects.Subscribe(observer);
-
-        public IEnumerable<T> GetSnapshot()
-        {
-            var snapshot = new List<T>();
-            using (this.Subscribe(item => snapshot.Add(item)))
-            {
-                // Deliberately empty; subscribing will add everything to the list.
-            }
-            return snapshot;
-        }
-
-        public void Dispose()
-        {
-            OnCompleted();
-            _subjects?.Dispose();
-        }
-    }
-}
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 24cbf419..01763035 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -6,11 +6,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="FluentAssertions.Reactive" Version="0.1.0-alpha.30" />
     <PackageReference Include="GraphQL" Version="4.6.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="5.0.2" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
-    <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index 6aa7284a..54e51c78 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -46,10 +46,8 @@ public void Reset()
 
         public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>>
         {
-            public CallbackAssertions(CallbackMonitor<TPayload> tester)
-            {
-                Subject = tester;
-            }
+            public CallbackAssertions(CallbackMonitor<TPayload> tester): base(tester)
+            { }
 
             protected override string Identifier => "callback";
 
diff --git a/tests/GraphQL.Integration.Tests/.editorconfig b/tests/GraphQL.Integration.Tests/.editorconfig
new file mode 100644
index 00000000..d1655ff8
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/.editorconfig
@@ -0,0 +1,2 @@
+# Configure await
+configure_await_analysis_mode = disabled
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 6aca8a5b..37d649e5 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -3,11 +3,11 @@
   <Import Project="../tests.props" />
   
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="3.1.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="5.0.11" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index b1f56e62..249ef8e7 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -68,7 +68,7 @@ public async void QueryAsHttpResponseTheory(int id, string name)
             httpResponse.Errors.Should().BeNull();
             httpResponse.Data.Human.Name.Should().Be(name);
 
-            httpResponse.StatusCode.Should().BeEquivalentTo(HttpStatusCode.OK);
+            httpResponse.StatusCode.Should().Be(HttpStatusCode.OK);
             httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));
         }
 
@@ -187,7 +187,7 @@ public async void PreprocessHttpRequestMessageIsCalled()
         }
 
         [Fact]
-        public void PostRequestCanBeCancelled()
+        public async Task PostRequestCanBeCancelled()
         {
             var graphQLRequest = new GraphQLRequest(@"
 				query Long {
@@ -218,7 +218,7 @@ query Long {
             request.Start();
             chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
             cts.Cancel();
-            request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
+            await request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled");
 
             // let the server finish its query
             chatQuery.LongRunningQueryBlocker.Set();
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 4bedde89..6a53ac26 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -9,12 +9,12 @@
 using FluentAssertions;
 using FluentAssertions.Execution;
 using FluentAssertions.Extensions;
+using FluentAssertions.Reactive;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Client.Tests.Common.Chat.Schema;
-using GraphQL.Client.Tests.Common.FluentAssertions.Reactive;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
 using Microsoft.Extensions.DependencyInjection;
@@ -140,7 +140,7 @@ query Long {
             request.Start();
             chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
             cts.Cancel();
-            request.Invoking().Should().Throw<TaskCanceledException>("because the request was cancelled");
+            await request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled");
 
             // let the server finish its query
             chatQuery.LongRunningQueryBlocker.Set();
diff --git a/tests/GraphQL.Primitives.Tests/.editorconfig b/tests/GraphQL.Primitives.Tests/.editorconfig
new file mode 100644
index 00000000..d1655ff8
--- /dev/null
+++ b/tests/GraphQL.Primitives.Tests/.editorconfig
@@ -0,0 +1,2 @@
+# Configure await
+configure_await_analysis_mode = disabled
diff --git a/tests/GraphQL.Server.Test/.editorconfig b/tests/GraphQL.Server.Test/.editorconfig
new file mode 100644
index 00000000..d1655ff8
--- /dev/null
+++ b/tests/GraphQL.Server.Test/.editorconfig
@@ -0,0 +1,2 @@
+# Configure await
+configure_await_analysis_mode = disabled
diff --git a/tests/IntegrationTestServer/.editorconfig b/tests/IntegrationTestServer/.editorconfig
new file mode 100644
index 00000000..d1655ff8
--- /dev/null
+++ b/tests/IntegrationTestServer/.editorconfig
@@ -0,0 +1,2 @@
+# Configure await
+configure_await_analysis_mode = disabled
diff --git a/tests/tests.props b/tests/tests.props
index 19bc6d36..349dec0d 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -8,14 +8,14 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="FluentAssertions.Reactive" Version="0.1.0-alpha.30" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
-    <PackageReference Include="coverlet.collector" Version="1.2.1">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime;build;native;contentfiles;analyzers;buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
   </ItemGroup>
 
 </Project>

From cff7f5f9ec5932a823bff0fcc531048dcb314f88 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 1 Nov 2021 22:46:58 +0100
Subject: [PATCH 353/455] fix test case 'CanReconnectWithSameObservable'

---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 26 +++----------------
 .../Websocket/GraphQLHttpWebSocket.cs         |  8 +++---
 .../Chat/Schema/IChat.cs                      | 22 +++++++++++-----
 .../WebsocketTests/Base.cs                    |  6 ++---
 4 files changed, 26 insertions(+), 36 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index cd51622c..01e6e40b 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
@@ -97,34 +98,15 @@ public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequ
 
         /// <inheritdoc />
         public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request)
-        {
-            if (_disposed)
-                throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
-            var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
-
-            if (_subscriptionStreams.ContainsKey(key))
-                return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
-
-            var observable = GraphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request);
-
-            _subscriptionStreams.TryAdd(key, observable);
-            return observable;
-        }
+            => CreateSubscriptionStream<TResponse>(request, null);
 
         /// <inheritdoc />
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler)
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception>? exceptionHandler)
         {
             if (_disposed)
                 throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-
-            var key = new Tuple<GraphQLRequest, Type>(request, typeof(TResponse));
-
-            if (_subscriptionStreams.ContainsKey(key))
-                return (IObservable<GraphQLResponse<TResponse>>)_subscriptionStreams[key];
-
+            
             var observable = GraphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
-            _subscriptionStreams.TryAdd(key, observable);
             return observable;
         }
 
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 0c4ffdff..67a517c6 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -94,7 +94,7 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
         /// <param name="request">the <see cref="GraphQLRequest"/> to start the subscription</param>
         /// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
         /// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler = null) =>
+        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception>? exceptionHandler = null) =>
             Observable.Defer(() =>
                     Observable.Create<GraphQLResponse<TResponse>>(async observer =>
                     {
@@ -169,6 +169,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                             observable.Subscribe(observer),
                             Disposable.Create(async () =>
                             {
+                                Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{WebSocketState}'");
                                 // only try to send close request on open websocket
                                 if (WebSocketState != WebSocketState.Open)
                                     return;
@@ -252,10 +253,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                         return Observable.Empty<GraphQLResponse<TResponse>>();
                     }
                     return Observable.Return(t.Item1);
-                })
-                // transform to hot observable and auto-connect
-                .Publish().RefCount();
-
+                });
         /// <summary>
         /// Send a regular GraphQL request (query, mutation) via websocket
         /// </summary>
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index ba9a97ab..63aaf439 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -1,7 +1,10 @@
 using System;
 using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
+using System.Threading;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema
 {
@@ -82,13 +85,20 @@ public MessageFrom Join(string userId)
         }
 
         public IObservable<Message> Messages(string user) =>
-            _messageStream
-                .Select(message =>
+            Observable.Create<Message>(observer =>
+            {
+                Debug.WriteLine($"creating messages stream for user '{user}' on thread {Thread.CurrentThread.ManagedThreadId}");
+                return new CompositeDisposable
                 {
-                    message.Sub = user;
-                    return message;
-                })
-                .AsObservable();
+                    _messageStream.Select(message =>
+                        {
+                            message.Sub = user;
+                            return message;
+                        })
+                        .Subscribe(observer),
+                    Disposable.Create(() => Debug.WriteLine($"disposing messages stream for user '{user}' on thread {Thread.CurrentThread.ManagedThreadId}"))
+                };
+            });
 
         public void AddError(Exception exception) => _messageStream.OnError(exception);
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 6a53ac26..8bc9cc7f 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -226,13 +226,13 @@ public async void CanReconnectWithSameObservable()
 
             const string message1 = "Hello World";
             Debug.WriteLine($"adding message {message1}");
-            var response = await ChatClient.AddMessageAsync(message1).ConfigureAwait(true);
+            var response = await ChatClient.AddMessageAsync(message1);
             response.Data.AddMessage.Content.Should().Be(message1);
             await observer.Should().PushAsync(2);
             observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
 
             const string message2 = "How are you?";
-            response = await ChatClient.AddMessageAsync(message2).ConfigureAwait(true);
+            response = await ChatClient.AddMessageAsync(message2);
             response.Data.AddMessage.Content.Should().Be(message2);
             await observer.Should().PushAsync(3);
             observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
@@ -247,7 +247,7 @@ public async void CanReconnectWithSameObservable()
             observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
 
             const string message3 = "lorem ipsum dolor si amet";
-            response = await ChatClient.AddMessageAsync(message3).ConfigureAwait(true);
+            response = await ChatClient.AddMessageAsync(message3);
             response.Data.AddMessage.Content.Should().Be(message3);
             await observer2.Should().PushAsync(2);
             observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message3);

From 4a2a963e98d05a2854aa5d34b443a00a63ca4746 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 1 Nov 2021 23:04:48 +0100
Subject: [PATCH 354/455] remove subscription cache field

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 01e6e40b..0d11fe11 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,11 +1,9 @@
 using System;
-using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
@@ -20,7 +18,6 @@ public class GraphQLHttpClient : IGraphQLClient
         private GraphQLHttpWebSocket GraphQlHttpWebSocket => _lazyHttpWebSocket.Value;
 
         private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
-        private readonly ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object> _subscriptionStreams = new ConcurrentDictionary<Tuple<GraphQLRequest, Type>, object>();
 
         private readonly bool _disposeHttpClient = false;
 

From ad5bdb1093a041377c79e54cc693f09f0bc56fd0 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Mon, 13 Jun 2022 08:44:01 +0300
Subject: [PATCH 355/455] Add dependabot (#392)

---
 .github/dependabot.yml | 10 ++++++++++
 GraphQL.Client.sln     |  7 +++++--
 2 files changed, 15 insertions(+), 2 deletions(-)
 create mode 100644 .github/dependabot.yml

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..a4ab6454
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,10 @@
+version: 2
+updates:
+- package-ecosystem: "nuget"
+  directory: "/"
+  schedule:
+    interval: "daily"
+- package-ecosystem: "github-actions"
+  directory: "/"
+  schedule:
+    interval: "daily"
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 01a7ad88..2de94cfb 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.28407.52
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32228.430
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{47C98B55-08F1-4428-863E-2C5C876DEEFE}"
 	ProjectSection(SolutionItems) = preProject
@@ -68,6 +68,9 @@ EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Example", "examples\GraphQL.Client.Example\GraphQL.Client.Example.csproj", "{6B13B87D-1EF4-485F-BC5D-891E2F4DA6CD}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{98D4DDDD-DE15-4997-B888-9BC806C7416C}"
+	ProjectSection(SolutionItems) = preProject
+		.github\dependabot.yml = .github\dependabot.yml
+	EndProjectSection
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution

From 59d53bf641553f7d5dd4d65ce1565d92f5c0d5e4 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 01:15:25 +0300
Subject: [PATCH 356/455] Migrate to GraphQL.NET v5 / server v6

---
 .github/workflows/branches.yml                |  8 ++---
 .github/workflows/master.yml                  | 10 +++----
 .../GraphQL.Client.Example.csproj             |  2 +-
 ...aphQL.Client.Abstractions.Websocket.csproj |  4 +--
 .../GraphQL.Client.Abstractions.csproj        |  8 -----
 .../GraphQL.Client.LocalExecution.csproj      |  7 ++---
 .../GraphQLLocalExecutionClient.cs            | 19 +++++-------
 .../ServiceCollectionExtensions.cs            |  2 +-
 ...raphQL.Client.Serializer.Newtonsoft.csproj |  2 +-
 ...QL.Client.Serializer.SystemTextJson.csproj |  2 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |  3 +-
 src/GraphQL.Client/GraphQLHttpClient.cs       |  4 +--
 .../GraphQL.Primitives.csproj                 |  2 +-
 .../GraphQL.Client.Serializer.Tests.csproj    |  4 +--
 .../Chat/Schema/ChatSubscriptions.cs          | 29 +++++++++----------
 .../GraphQL.Client.Tests.Common.csproj        |  5 ++--
 .../StarWars/StarWarsQuery.cs                 |  9 +++---
 .../StarWars/Types/EpisodeEnum.cs             |  6 ++--
 .../GraphQL.Integration.Tests.csproj          |  2 +-
 .../GraphQL.Primitives.Tests.csproj           | 14 ++++-----
 .../GraphQL.Server.Test.csproj                |  9 +++---
 tests/GraphQL.Server.Test/Startup.cs          | 15 +++++-----
 .../IntegrationTestServer.csproj              |  4 +--
 tests/IntegrationTestServer/Startup.cs        | 24 +++++++++------
 24 files changed, 95 insertions(+), 99 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index f1e31304..66468afe 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -1,5 +1,5 @@
 name: Branch workflow
-on: 
+on:
   push:
     branches-ignore:
       - master
@@ -7,10 +7,10 @@ on:
       - 'releases/**'
   pull_request:
 env:
-  DOTNET_CLI_TELEMETRY_OPTOUT: true  
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
   MSBUILDSINGLELOADCONTEXT: 1
 jobs:
-  generateVersionInfo:  
+  generateVersionInfo:
     name: GenerateVersionInfo
     runs-on: ubuntu-latest
     steps:
@@ -47,7 +47,7 @@ jobs:
     - name: Build solution
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
     - name: Create NuGet packages
-      run: dotnet pack -c Release --no-build -o nupkg 
+      run: dotnet pack -c Release --no-build -o nupkg
     - name: Upload nuget packages
       uses: actions/upload-artifact@v1
       with:
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 407156d8..daacff76 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -1,11 +1,11 @@
 name: Master workflow
-on: 
+on:
   push:
     branches:
       - master
       - 'release/**'
       - 'releases/**'
-    tags:        
+    tags:
       - v*
       - V*
 env:
@@ -13,7 +13,7 @@ env:
   MSBUILDSINGLELOADCONTEXT: 1
 
 jobs:
-  generateVersionInfo:  
+  generateVersionInfo:
     name: GenerateVersionInfo
     runs-on: ubuntu-latest
     steps:
@@ -50,7 +50,7 @@ jobs:
     - name: Build solution
       run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
     - name: Create NuGet packages
-      run: dotnet pack -c Release --no-build -o nupkg 
+      run: dotnet pack -c Release --no-build -o nupkg
     - name: Upload nuget packages
       uses: actions/upload-artifact@v1
       with:
@@ -85,7 +85,7 @@ jobs:
       uses: actions/download-artifact@v1
       with:
         name: nupkg
-    - name: Publish the package to GPR    
+    - name: Publish the package to GPR
     # using workaround with CURL because of non-functioning upload via dotnet nuget (https://stackoverflow.com/a/58943251)
       run: |
            for f in ./nupkg/*.nupkg
diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index 8880a7a6..ea44d228 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index d1980775..048dffbf 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  
+
   <Import Project="../src.props" />
 
   <PropertyGroup>
     <Description>Abstractions for the Websocket transport used in GraphQL.Client</Description>
-	  <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 8e1faee1..ef5087f4 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -11,12 +11,4 @@
     <ProjectReference Include="..\GraphQL.Primitives\GraphQL.Primitives.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="System.Reactive" Version="4.3.2" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="Utilities" />
-  </ItemGroup>
-
 </Project>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 00ef36b3..14282946 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -8,10 +8,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="4.6.1" />
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="4.6.0" />
-    <PackageReference Include="GraphQL.SystemReactive" Version="4.1.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="5.0.0" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="5.0.0" />
+    <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 889bc991..ee1edf4d 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -8,8 +8,6 @@
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Serializer.Newtonsoft;
-using GraphQL.NewtonsoftJson;
-using GraphQL.Subscription;
 using GraphQL.Types;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
@@ -20,7 +18,7 @@ namespace GraphQL.Client.LocalExecution
     public static class GraphQLLocalExecutionClient
     {
         public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer serializer) where TSchema : ISchema
-            => new GraphQLLocalExecutionClient<TSchema>(schema, serializer, new SubscriptionDocumentExecuter(), new DocumentWriter());
+            => new GraphQLLocalExecutionClient<TSchema>(schema, serializer, new DocumentExecuter(), new GraphQL.NewtonsoftJson.GraphQLSerializer());
     }
 
     public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
@@ -41,9 +39,9 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
         public IGraphQLJsonSerializer Serializer { get; }
 
         private readonly IDocumentExecuter _documentExecuter;
-        private readonly IDocumentWriter _documentWriter;
+        private readonly IGraphQLSerializer _documentSerializer;
 
-        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer, IDocumentExecuter documentExecuter, IDocumentWriter documentWriter)
+        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer, IDocumentExecuter documentExecuter, IGraphQLSerializer documentSerializer)
         {
             Schema = schema ?? throw new ArgumentNullException(nameof(schema), "no schema configured");
             Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
@@ -51,7 +49,7 @@ public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serial
             if (!Schema.Initialized)
                 Schema.Initialize();
             _documentExecuter = documentExecuter;
-            _documentWriter = documentWriter;
+            _documentSerializer = documentSerializer;
         }
 
         public void Dispose() { }
@@ -82,7 +80,7 @@ private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(Grap
         private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var result = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
-            var stream = ((SubscriptionExecutionResult)result).Streams?.Values.SingleOrDefault();
+            var stream = result.Streams?.Values.SingleOrDefault();
 
             return stream == null
                 ? Observable.Throw<GraphQLResponse<TResponse>>(new InvalidOperationException("the GraphQL execution did not return an observable"))
@@ -95,8 +93,7 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
 
             var deserializedRequest = JsonConvert.DeserializeObject<GraphQLRequest>(serializedRequest);
             var inputs = deserializedRequest.Variables != null
-                ? (JObject.FromObject(request.Variables, JsonSerializer.Create(_variablesSerializerSettings)) as JObject)
-                .ToInputs()
+                ? _documentSerializer.ReadNode<Inputs>(JObject.FromObject(request.Variables, JsonSerializer.Create(_variablesSerializerSettings)))
                 : null;
 
             var result = await _documentExecuter.ExecuteAsync(options =>
@@ -104,7 +101,7 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
                 options.Schema = Schema;
                 options.OperationName = deserializedRequest?.OperationName;
                 options.Query = deserializedRequest?.Query;
-                options.Inputs = inputs;
+                options.Variables = inputs;
                 options.CancellationToken = cancellationToken;
             }).ConfigureAwait(false);
 
@@ -114,7 +111,7 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
         private async Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponseAsync<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
         {
             using var stream = new MemoryStream();
-            await _documentWriter.WriteAsync(stream, executionResult, cancellationToken).ConfigureAwait(false);
+            await _documentSerializer.WriteAsync(stream, executionResult, cancellationToken).ConfigureAwait(false);
             stream.Seek(0, SeekOrigin.Begin);
             return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(stream, cancellationToken).ConfigureAwait(false);
         }
diff --git a/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
index 0fe7b234..ff18f49d 100644
--- a/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
+++ b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
@@ -12,7 +12,7 @@ public static IGraphQLBuilder AddGraphQLLocalExecutionClient<TSchema>(this IServ
         {
             services.AddSingleton<GraphQLLocalExecutionClient<TSchema>>();
             services.AddSingleton<IGraphQLClient>(p => p.GetRequiredService<GraphQLLocalExecutionClient<TSchema>>());
-            return services.AddGraphQL();
+            return new GraphQLBuilder(services, null);
         }
     }
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index 4bbcb784..1ef89e21 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -1,5 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  
+
   <Import Project="../src.props" />
 
   <PropertyGroup>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index 9433b8dd..ffb763bd 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -1,5 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  
+
   <Import Project="../src.props" />
 
   <PropertyGroup>
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index febf2911..4ee05d70 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -17,8 +17,9 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
+    <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
-  
+
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
     <PackageReference Include="System.Net.WebSockets.Client.Managed" Version="1.0.22" />
   </ItemGroup>
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 0d11fe11..ea095fc6 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -69,7 +69,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
 
             if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
                 HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
-            
+
             _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
         }
 
@@ -102,7 +102,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         {
             if (_disposed)
                 throw new ObjectDisposedException(nameof(GraphQLHttpClient));
-            
+
             var observable = GraphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
             return observable;
         }
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index 1c324df3..c4210d9d 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -7,5 +7,5 @@
     <RootNamespace>GraphQL</RootNamespace>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
   </PropertyGroup>
-  
+
 </Project>
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 3a5af98e..5cf5e783 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <Import Project="../tests.props" />
-  
+
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
index b15ba334..f3fbab63 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
@@ -4,7 +4,6 @@
 using System.Security.Claims;
 using GraphQL.Resolvers;
 using GraphQL.Server.Transports.Subscriptions.Abstractions;
-using GraphQL.Subscription;
 using GraphQL.Types;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema
@@ -16,23 +15,23 @@ public class ChatSubscriptions : ObjectGraphType<object>
         public ChatSubscriptions(IChat chat)
         {
             _chat = chat;
-            AddField(new EventStreamFieldType
+            AddField(new FieldType
             {
                 Name = "messageAdded",
                 Type = typeof(MessageType),
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                Subscriber = new EventStreamResolver<Message>(Subscribe)
+                StreamResolver = new SourceStreamResolver<Message>(Subscribe)
             });
 
-            AddField(new EventStreamFieldType
+            AddField(new FieldType
             {
                 Name = "contentAdded",
                 Type = typeof(MessageType),
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                Subscriber = new EventStreamResolver<Message>(Subscribe)
+                StreamResolver = new SourceStreamResolver<Message>(Subscribe)
             });
 
-            AddField(new EventStreamFieldType
+            AddField(new FieldType
             {
                 Name = "messageAddedByUser",
                 Arguments = new QueryArguments(
@@ -40,30 +39,30 @@ public ChatSubscriptions(IChat chat)
                 ),
                 Type = typeof(MessageType),
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                Subscriber = new EventStreamResolver<Message>(SubscribeById)
+                StreamResolver = new SourceStreamResolver<Message>(SubscribeById)
             });
 
-            AddField(new EventStreamFieldType
+            AddField(new FieldType
             {
                 Name = "userJoined",
                 Type = typeof(MessageFromType),
                 Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
-                Subscriber = new EventStreamResolver<MessageFrom>(context => _chat.UserJoined())
+                StreamResolver = new SourceStreamResolver<MessageFrom>(context => _chat.UserJoined())
             });
 
 
-            AddField(new EventStreamFieldType
+            AddField(new FieldType
             {
                 Name = "failImmediately",
                 Type = typeof(MessageType),
                 Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                Subscriber = new EventStreamResolver<Message>(context => throw new NotSupportedException("this is supposed to fail"))
+                StreamResolver = new SourceStreamResolver<Message>((Func<IResolveFieldContext, IObservable<Message>>)(context => throw new NotSupportedException("this is supposed to fail")))
             });
         }
 
-        private IObservable<Message> SubscribeById(IResolveEventStreamContext context)
+        private IObservable<Message> SubscribeById(IResolveFieldContext context)
         {
-            var messageContext = (MessageHandlingContext) context.UserContext;
+            var messageContext = (MessageHandlingContext)context.UserContext;
             var user = messageContext.Get<ClaimsPrincipal>("user");
 
             var sub = "Anonymous";
@@ -83,9 +82,9 @@ private Message ResolveMessage(IResolveFieldContext context)
             return message;
         }
 
-        private IObservable<Message> Subscribe(IResolveEventStreamContext context)
+        private IObservable<Message> Subscribe(IResolveFieldContext context)
         {
-            var messageContext = (MessageHandlingContext) context.UserContext;
+            var messageContext = (MessageHandlingContext)context.UserContext;
             var user = messageContext.Get<ClaimsPrincipal>("user");
 
             var sub = "Anonymous";
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 01763035..51ddf3e6 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -2,13 +2,12 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-		<IsPackable>false</IsPackable>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.1.0-alpha.30" />
-    <PackageReference Include="GraphQL" Version="4.6.0" />
-    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="5.0.2" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="6.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
index c416e8c5..ee2b9d3d 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using GraphQL.Client.Tests.Common.StarWars.Types;
 using GraphQL.Types;
 
@@ -10,16 +11,16 @@ public StarWarsQuery(StarWarsData data)
         {
             Name = "Query";
 
-            Field<CharacterInterface>("hero", resolve: context => data.GetDroidByIdAsync("3"));
-            Field<HumanType>(
+            FieldAsync<CharacterInterface>("hero", resolve: async context => await data.GetDroidByIdAsync("3"));
+            FieldAsync<HumanType>(
                 "human",
                 arguments: new QueryArguments(
                     new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the human" }
                 ),
-                resolve: context => data.GetHumanByIdAsync(context.GetArgument<string>("id"))
+                resolve: async context => await data.GetHumanByIdAsync(context.GetArgument<string>("id"))
             );
 
-            Func<IResolveFieldContext, string, object> func = (context, id) => data.GetDroidByIdAsync(id);
+            Func<IResolveFieldContext, string, Task<Droid>> func = (context, id) => data.GetDroidByIdAsync(id);
 
             FieldDelegate<DroidType>(
                 "droid",
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
index 6823376e..4b9fb577 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
@@ -8,9 +8,9 @@ public EpisodeEnum()
         {
             Name = "Episode";
             Description = "One of the films in the Star Wars Trilogy.";
-            AddValue("NEWHOPE", "Released in 1977.", 4);
-            AddValue("EMPIRE", "Released in 1980.", 5);
-            AddValue("JEDI", "Released in 1983.", 6);
+            Add("NEWHOPE", 4, "Released in 1977.");
+            Add("EMPIRE", 5, "Released in 1980.");
+            Add("JEDI", 6, "Released in 1983.");
         }
     }
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 37d649e5..9ca8df0b 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <Import Project="../tests.props" />
-  
+
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index 99070b4c..5019b79a 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<Import Project="../tests.props" />
+  <Import Project="../tests.props" />
 
-	<PropertyGroup>
-		<TargetFramework>netcoreapp3.1</TargetFramework>
-	</PropertyGroup>
+  <PropertyGroup>
+    <TargetFramework>net5</TargetFramework>
+  </PropertyGroup>
 
-	<ItemGroup>
-		<ProjectReference Include="..\..\src\GraphQL.Primitives\GraphQL.Primitives.csproj" />
-	</ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Primitives\GraphQL.Primitives.csproj" />
+  </ItemGroup>
 
 </Project>
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index ad08e233..1b6f7f39 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -1,13 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.4.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.4.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="5.0.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="6.0.0" />
+    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.WebSockets" Version="6.1.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="6.1.0" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index a1f710ee..06eae89b 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -1,3 +1,4 @@
+using GraphQL.MicrosoftDI;
 using GraphQL.Server.Test.GraphQL;
 using GraphQL.Server.Ui.GraphiQL;
 using Microsoft.AspNetCore.Builder;
@@ -21,17 +22,17 @@ public void Configure(IApplicationBuilder app)
             app.UseWebSockets();
             app.UseGraphQLWebSockets<TestSchema>();
             app.UseGraphQL<TestSchema>();
-            app.UseGraphiQLServer(new GraphiQLOptions { });
+            app.UseGraphQLGraphiQL(new GraphiQLOptions { });
         }
 
         public void ConfigureServices(IServiceCollection services)
         {
-            services.AddSingleton<TestSchema>();
-            services.AddGraphQL(options =>
-            {
-                options.EnableMetrics = true;
-                options.ExposeExceptions = true;
-            }).AddWebSockets();
+            services.AddGraphQL(builder => builder
+                .AddSchema<TestSchema>()
+                .AddApolloTracing(enableMetrics: true)
+                .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = true)
+                .AddWebSockets()
+            );
         }
     }
 }
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index fab13b6e..884cbaad 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5</TargetFramework>
     <StartupObject>IntegrationTestServer.Program</StartupObject>
   </PropertyGroup>
 
@@ -10,7 +10,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.All" Version="5.0.2" />
+    <PackageReference Include="GraphQL.Server.All" Version="6.1.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
     <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
   </ItemGroup>
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index f41856d7..0d1ad68e 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -2,9 +2,11 @@
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.StarWars;
+using GraphQL.MicrosoftDI;
 using GraphQL.Server;
 using GraphQL.Server.Ui.Altair;
 using GraphQL.Server.Ui.GraphiQL;
+using GraphQL.SystemTextJson;
 using GraphQL.Types;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
@@ -36,18 +38,22 @@ public void ConfigureServices(IServiceCollection services)
             //
             services.AddChatSchema();
             services.AddStarWarsSchema();
-            services.AddSingleton<IDocumentExecuter, SubscriptionDocumentExecuter>();
-            services.AddGraphQL((options, services) =>
-            {
-                options.EnableMetrics = true;
-                var logger = services.GetRequiredService<ILogger<Startup>>();
-                options.UnhandledExceptionDelegate = ctx => logger.LogError("{Error} occurred", ctx.OriginalException.Message);
-            })
+            services.AddGraphQL(builder => builder
+                .AddApolloTracing(enableMetrics: true)
+                .AddHttpMiddleware<ChatSchema>()
+                .AddHttpMiddleware<StarWarsSchema>()
+                .AddWebSocketsHttpMiddleware<ChatSchema>()
+                .AddWebSocketsHttpMiddleware<StarWarsSchema>()
+                .ConfigureExecutionOptions(opt => opt.UnhandledExceptionDelegate = ctx =>
+                {
+                    var logger = ctx.Context.RequestServices.GetRequiredService<ILogger<Startup>>();
+                    logger.LogError("{Error} occurred", ctx.OriginalException.Message);
+                    return System.Threading.Tasks.Task.CompletedTask;
+                })
                 .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = Environment.IsDevelopment())
                 .AddSystemTextJson()
                 .AddWebSockets()
-                .AddGraphTypes(typeof(ChatSchema))
-                .AddGraphTypes(typeof(StarWarsSchema));
+                .AddGraphTypes(typeof(ChatSchema).Assembly));
         }
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.

From e014aabea6f46ea5a4d3c58990e12a6b9280042d Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:29:49 +0300
Subject: [PATCH 357/455] Update
 examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index ea44d228..046e466d 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

From 74276ff76542333ab2706ead3c40a5b9dbe5859a Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:29:59 +0300
Subject: [PATCH 358/455] Update
 tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 5cf5e783..ff238bdd 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net5</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

From 6e697e52257b6dc99e7b2553c0f119317631969c Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:30:07 +0300
Subject: [PATCH 359/455] Update
 tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index 5019b79a..ad5efd71 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net5</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

From 9e1c787316aa7ed72f0d84a29d838d1bcc82b801 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:30:15 +0300
Subject: [PATCH 360/455] Update
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 1b6f7f39..bd680444 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net5</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

From c5620f6ebdcaee84c637b9d960c061d67f1caf76 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:30:24 +0300
Subject: [PATCH 361/455] Update
 tests/IntegrationTestServer/IntegrationTestServer.csproj

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 tests/IntegrationTestServer/IntegrationTestServer.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 884cbaad..1e68549b 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net5</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
     <StartupObject>IntegrationTestServer.Program</StartupObject>
   </PropertyGroup>
 

From 16347daae30ee8117059727eaddc5b0c79302e99 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:33:00 +0300
Subject: [PATCH 362/455] Update
 src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 .../GraphQLLocalExecutionClient.cs                              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index ee1edf4d..36705e87 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -39,7 +39,7 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
         public IGraphQLJsonSerializer Serializer { get; }
 
         private readonly IDocumentExecuter _documentExecuter;
-        private readonly IGraphQLSerializer _documentSerializer;
+        private readonly IGraphQLTextSerializer _documentSerializer;
 
         public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer, IDocumentExecuter documentExecuter, IGraphQLSerializer documentSerializer)
         {

From 0bf5b2e797b4a109270b80811227f7127cd374ac Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:33:11 +0300
Subject: [PATCH 363/455] Update
 src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 .../GraphQLLocalExecutionClient.cs                              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 36705e87..0d82a558 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -41,7 +41,7 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
         private readonly IDocumentExecuter _documentExecuter;
         private readonly IGraphQLTextSerializer _documentSerializer;
 
-        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer, IDocumentExecuter documentExecuter, IGraphQLSerializer documentSerializer)
+        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer, IDocumentExecuter documentExecuter, IGraphQLTextSerializer documentSerializer)
         {
             Schema = schema ?? throw new ArgumentNullException(nameof(schema), "no schema configured");
             Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");

From d390e96b4ec146dc9b84e42f4174e050b5edc829 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:33:50 +0300
Subject: [PATCH 364/455] Update
 src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 .../GraphQLLocalExecutionClient.cs                             | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 0d82a558..a8ad29c4 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -101,7 +101,8 @@ private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, Cancell
                 options.Schema = Schema;
                 options.OperationName = deserializedRequest?.OperationName;
                 options.Query = deserializedRequest?.Query;
-                options.Variables = inputs;
+                options.Variables = deserializedRequest?.Variables;
+                options.Extensions = deserializedRequest?.Extensions;
                 options.CancellationToken = cancellationToken;
             }).ConfigureAwait(false);
 

From 5ccab4c4290889b46639f5f209fdb27f99f37afe Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 12:34:25 +0300
Subject: [PATCH 365/455] Update
 src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs

Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 .../GraphQLLocalExecutionClient.cs                              | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index a8ad29c4..9ce7546e 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -9,8 +9,6 @@
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Types;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.LocalExecution

From 131512097249e0e935d7595ae9d26b4a118433a6 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 12 Jul 2022 13:48:03 +0300
Subject: [PATCH 366/455] jump around deps, add GraphQLRequest.Extensions
 property

---
 .../GraphQL.Client.LocalExecution.csproj      |  1 -
 .../GraphQLLocalExecutionClient.cs            | 43 ++++++-------------
 ...raphQL.Client.Serializer.Newtonsoft.csproj |  2 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |  2 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      | 15 ++++++-
 .../BaseSerializeNoCamelCaseTest.cs           | 17 +++++---
 .../BaseSerializerTest.cs                     | 36 ++++++++--------
 .../GraphQL.Client.Serializer.Tests.csproj    |  5 +++
 .../NewtonsoftSerializerTest.cs               |  5 ++-
 .../SystemTextJsonSerializerTests.cs          |  5 ++-
 .../TestData/SerializeToBytesTestData.cs      |  4 +-
 .../TestData/SerializeToStringTestData.cs     |  8 ++--
 .../GraphQL.Client.Tests.Common.csproj        |  4 +-
 .../GraphQL.Integration.Tests.csproj          |  4 +-
 tests/tests.props                             | 10 ++---
 15 files changed, 83 insertions(+), 78 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 14282946..36d80714 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -9,7 +9,6 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.MicrosoftDI" Version="5.0.0" />
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="5.0.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 9ce7546e..9a741b32 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reactive.Linq;
@@ -7,31 +6,19 @@
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
-using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Types;
-using Newtonsoft.Json.Serialization;
 
 namespace GraphQL.Client.LocalExecution
 {
     public static class GraphQLLocalExecutionClient
     {
-        public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer serializer) where TSchema : ISchema
-            => new GraphQLLocalExecutionClient<TSchema>(schema, serializer, new DocumentExecuter(), new GraphQL.NewtonsoftJson.GraphQLSerializer());
+        public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
+            where TSchema : ISchema
+            => new GraphQLLocalExecutionClient<TSchema>(schema, new DocumentExecuter(), clientSerializer, serverSerializer);
     }
 
     public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
     {
-        private static readonly JsonSerializerSettings _variablesSerializerSettings = new JsonSerializerSettings
-        {
-            Formatting = Formatting.Indented,
-            DateTimeZoneHandling = DateTimeZoneHandling.Local,
-            ContractResolver = new CamelCasePropertyNamesContractResolver(),
-            Converters = new List<JsonConverter>
-            {
-                new ConstantCaseEnumConverter()
-            }
-        };
-
         public TSchema Schema { get; }
 
         public IGraphQLJsonSerializer Serializer { get; }
@@ -39,15 +26,15 @@ public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema
         private readonly IDocumentExecuter _documentExecuter;
         private readonly IGraphQLTextSerializer _documentSerializer;
 
-        public GraphQLLocalExecutionClient(TSchema schema, IGraphQLJsonSerializer serializer, IDocumentExecuter documentExecuter, IGraphQLTextSerializer documentSerializer)
+        public GraphQLLocalExecutionClient(TSchema schema, IDocumentExecuter documentExecuter, IGraphQLJsonSerializer serializer, IGraphQLTextSerializer documentSerializer)
         {
             Schema = schema ?? throw new ArgumentNullException(nameof(schema), "no schema configured");
+            _documentExecuter = documentExecuter;
             Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
+            _documentSerializer = documentSerializer;
 
             if (!Schema.Initialized)
                 Schema.Initialize();
-            _documentExecuter = documentExecuter;
-            _documentSerializer = documentSerializer;
         }
 
         public void Dispose() { }
@@ -75,6 +62,7 @@ private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(Grap
             var executionResult = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
             return await ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, cancellationToken).ConfigureAwait(false);
         }
+
         private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
         {
             var result = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
@@ -85,22 +73,17 @@ private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionA
                 : stream.SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, token)));
         }
 
-        private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+        private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest clientRequest, CancellationToken cancellationToken = default)
         {
-            string serializedRequest = Serializer.SerializeToString(request);
-
-            var deserializedRequest = JsonConvert.DeserializeObject<GraphQLRequest>(serializedRequest);
-            var inputs = deserializedRequest.Variables != null
-                ? _documentSerializer.ReadNode<Inputs>(JObject.FromObject(request.Variables, JsonSerializer.Create(_variablesSerializerSettings)))
-                : null;
+            var serverRequest = _documentSerializer.Deserialize<Transport.GraphQLRequest>(Serializer.SerializeToString(clientRequest));
 
             var result = await _documentExecuter.ExecuteAsync(options =>
             {
                 options.Schema = Schema;
-                options.OperationName = deserializedRequest?.OperationName;
-                options.Query = deserializedRequest?.Query;
-                options.Variables = deserializedRequest?.Variables;
-                options.Extensions = deserializedRequest?.Extensions;
+                options.OperationName = serverRequest?.OperationName;
+                options.Query = serverRequest?.Query;
+                options.Variables = serverRequest?.Variables;
+                options.Extensions = serverRequest?.Extensions;
                 options.CancellationToken = cancellationToken;
             }).ConfigureAwait(false);
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index 1ef89e21..27801752 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -8,7 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 4ee05d70..8203c2f4 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -16,7 +16,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.2" PrivateAssets="All" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index d2d15a8d..2755122c 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -12,6 +12,7 @@ public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequ
         public const string OPERATION_NAME_KEY = "operationName";
         public const string QUERY_KEY = "query";
         public const string VARIABLES_KEY = "variables";
+        public const string EXTENSIONS_KEY = "extensions";
 
         /// <summary>
         /// The Query
@@ -40,13 +41,23 @@ public object? Variables
             set => this[VARIABLES_KEY] = value;
         }
 
+        /// <summary>
+        /// Represents the request extensions
+        /// </summary>
+        public object? Extensions
+        {
+            get => TryGetValue(EXTENSIONS_KEY, out object value) ? value : null;
+            set => this[EXTENSIONS_KEY] = value;
+        }
+
         public GraphQLRequest() { }
 
-        public GraphQLRequest(string query, object? variables = null, string? operationName = null)
+        public GraphQLRequest(string query, object? variables = null, string? operationName = null, object? extensions = null)
         {
             Query = query;
             Variables = variables;
             OperationName = operationName;
+            Extensions = extensions;
         }
 
         public GraphQLRequest(GraphQLRequest other): base(other) { }
@@ -84,7 +95,7 @@ public virtual bool Equals(GraphQLRequest? other)
         /// <summary>
         /// <inheritdoc cref="object.GetHashCode"/>
         /// </summary>
-        public override int GetHashCode() => (Query, OperationName, Variables).GetHashCode();
+        public override int GetHashCode() => (Query, OperationName, Variables, Extensions).GetHashCode();
 
         /// <summary>
         /// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index 7ef81660..ce3d51f6 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -13,24 +13,27 @@ namespace GraphQL.Client.Serializer.Tests
 {
     public abstract class BaseSerializeNoCamelCaseTest
     {
-        public IGraphQLWebsocketJsonSerializer Serializer { get; }
+        public IGraphQLWebsocketJsonSerializer ClientSerializer { get; }
+
+        public IGraphQLTextSerializer ServerSerializer { get; }
 
         public IGraphQLClient ChatClient { get; }
 
         public IGraphQLClient StarWarsClient { get; }
 
-        protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer serializer)
+        protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
         {
-            Serializer = serializer;
-            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
-            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
+            ClientSerializer = clientSerializer;
+            ServerSerializer = serverSerializer;
+            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), clientSerializer, serverSerializer);
+            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), clientSerializer, serverSerializer);
         }
 
         [Theory]
         [ClassData(typeof(SerializeToStringTestData))]
         public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
         {
-            var json = Serializer.SerializeToString(request).RemoveWhitespace();
+            var json = ClientSerializer.SerializeToString(request).RemoveWhitespace();
             json.Should().Be(expectedJson.RemoveWhitespace());
         }
 
@@ -38,7 +41,7 @@ public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
         [ClassData(typeof(SerializeToBytesTestData))]
         public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
         {
-            var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
+            var json = Encoding.UTF8.GetString(ClientSerializer.SerializeToBytes(request)).RemoveWhitespace();
             json.Should().Be(expectedJson.RemoveWhitespace());
         }
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 863974ae..8efdccdf 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -15,7 +15,6 @@
 using GraphQL.Client.Tests.Common.Chat;
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
-using GraphQL.Client.Tests.Common.StarWars;
 using GraphQL.Client.Tests.Common.StarWars.TestData;
 using Xunit;
 
@@ -23,24 +22,27 @@ namespace GraphQL.Client.Serializer.Tests
 {
     public abstract class BaseSerializerTest
     {
-        public IGraphQLWebsocketJsonSerializer Serializer { get; }
+        public IGraphQLWebsocketJsonSerializer ClientSerializer { get; }
+
+        public IGraphQLTextSerializer ServerSerializer { get; }
 
         public IGraphQLClient ChatClient { get; }
 
         public IGraphQLClient StarWarsClient { get; }
 
-        protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer serializer)
+        protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
         {
-            Serializer = serializer;
-            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), serializer);
-            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), serializer);
+            ClientSerializer = clientSerializer;
+            ServerSerializer = serverSerializer;
+            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), clientSerializer, serverSerializer);
+            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), clientSerializer, serverSerializer);
         }
 
         [Theory]
         [ClassData(typeof(SerializeToStringTestData))]
         public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
         {
-            var json = Serializer.SerializeToString(request).RemoveWhitespace();
+            var json = ClientSerializer.SerializeToString(request).RemoveWhitespace();
             json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
         }
 
@@ -48,7 +50,7 @@ public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
         [ClassData(typeof(SerializeToBytesTestData))]
         public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
         {
-            var json = Encoding.UTF8.GetString(Serializer.SerializeToBytes(request)).RemoveWhitespace();
+            var json = Encoding.UTF8.GetString(ClientSerializer.SerializeToBytes(request)).RemoveWhitespace();
             json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
         }
 
@@ -96,9 +98,9 @@ public async void DeserializeFromUtf8StreamTest(string json, IGraphQLResponse ex
 
         public async Task<IGraphQLResponse> DeserializeToUnknownType(Type dataType, Stream stream)
         {
-            MethodInfo mi = Serializer.GetType().GetMethod("DeserializeFromUtf8StreamAsync", BindingFlags.Instance | BindingFlags.Public);
+            MethodInfo mi = ClientSerializer.GetType().GetMethod("DeserializeFromUtf8StreamAsync", BindingFlags.Instance | BindingFlags.Public);
             MethodInfo mi2 = mi.MakeGenericMethod(dataType);
-            var task = (Task)mi2.Invoke(Serializer, new object[] { stream, CancellationToken.None });
+            var task = (Task)mi2.Invoke(ClientSerializer, new object[] { stream, CancellationToken.None });
             await task;
             var resultProperty = task.GetType().GetProperty("Result", BindingFlags.Public | BindingFlags.Instance);
             var result = resultProperty.GetValue(task);
@@ -108,9 +110,9 @@ public async Task<IGraphQLResponse> DeserializeToUnknownType(Type dataType, Stre
         [Fact]
         public async void CanDeserializeExtensions()
         {
-            var response = await ChatClient.SendQueryAsync(new GraphQLRequest("query { extensionsTest }"),
-                                                           () => new { extensionsTest = "" })
-                ;
+            var response = await ChatClient.SendQueryAsync(
+                new GraphQLRequest("query { extensionsTest }"),
+                () => new { extensionsTest = "" });
 
             response.Errors.Should().NotBeNull();
             response.Errors.Should().ContainSingle();
@@ -136,8 +138,8 @@ query Droid($id: String!) {
 				    name
 				  }
 				}",
-                                                    new { id = id.ToString() },
-                                                    "Human");
+                new { id = id.ToString() },
+                "Human");
 
             var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
@@ -162,7 +164,7 @@ public class WithNullable
         [Fact]
         public void CanSerializeNullableInt()
         {
-            Action action = () => Serializer.SerializeToString(new GraphQLRequest
+            Action action = () => ClientSerializer.SerializeToString(new GraphQLRequest
             {
                 Query = "{}",
                 Variables = new WithNullable
@@ -182,7 +184,7 @@ public class WithNullableStruct
         [Fact]
         public void CanSerializeNullableStruct()
         {
-            Action action = () => Serializer.SerializeToString(new GraphQLRequest
+            Action action = () => ClientSerializer.SerializeToString(new GraphQLRequest
             {
                 Query = "{}",
                 Variables = new WithNullableStruct
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index ff238bdd..49a25c09 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -6,6 +6,11 @@
     <TargetFramework>net6</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="5.3.2" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="5.3.2" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\src\GraphQL.Client.Abstractions.Websocket\GraphQL.Client.Abstractions.Websocket.csproj" />
     <ProjectReference Include="..\..\src\GraphQL.Client.LocalExecution\GraphQL.Client.LocalExecution.csproj" />
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 43ade957..481a23c0 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -5,12 +5,13 @@ namespace GraphQL.Client.Serializer.Tests
 {
     public class NewtonsoftSerializerTest : BaseSerializerTest
     {
-        public NewtonsoftSerializerTest() : base(new NewtonsoftJsonSerializer()) { }
+        public NewtonsoftSerializerTest()
+            : base(new NewtonsoftJsonSerializer(), new NewtonsoftJson.GraphQLSerializer()) { }
     }
 
     public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
     {
         public NewtonsoftSerializeNoCamelCaseTest()
-            : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings(){ Converters = { new ConstantCaseEnumConverter() } })) { }
+            : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings { Converters = { new ConstantCaseEnumConverter() } }), new NewtonsoftJson.GraphQLSerializer()) { }
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index 153bcd4d..d5e04733 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -6,12 +6,13 @@ namespace GraphQL.Client.Serializer.Tests
 {
     public class SystemTextJsonSerializerTests : BaseSerializerTest
     {
-        public SystemTextJsonSerializerTests() : base(new SystemTextJsonSerializer()) { }
+        public SystemTextJsonSerializerTests()
+            : base(new SystemTextJsonSerializer(), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
     }
 
     public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
     {
         public SystemTextJsonSerializeNoCamelCaseTest()
-            : base(new SystemTextJsonSerializer(new JsonSerializerOptions(){Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter())) { }
+            : base(new SystemTextJsonSerializer(new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter()), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
index de76f5d8..3b581cc5 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
@@ -9,7 +9,7 @@ public class SerializeToBytesTestData : IEnumerable<object[]>
         public IEnumerator<object[]> GetEnumerator()
         {
             yield return new object[] {
-                "{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}}",
+                "{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null}}",
                 new GraphQLWebSocketRequest {
                     Id = "1234567",
                     Type = GraphQLWebSocketMessageType.GQL_START,
@@ -17,7 +17,7 @@ public IEnumerator<object[]> GetEnumerator()
                 }
             };
             yield return new object[] {
-                "{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}}",
+                "{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null,\"extensions\":null}}",
                 new GraphQLWebSocketRequest {
                     Id = "34476567",
                     Type = GraphQLWebSocketMessageType.GQL_START,
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index e5285681..87634dad 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -10,19 +10,19 @@ public class SerializeToStringTestData : IEnumerable<object[]>
         public IEnumerator<object[]> GetEnumerator()
         {
             yield return new object[] {
-                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null}",
+                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null}",
                 new GraphQLRequest("simple query string")
             };
             yield return new object[] {
-                "{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null}",
+                "{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null,\"extensions\":null}",
                 new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
             };
             yield return new object[] {
-                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"authentication\":\"an-authentication-token\"}",
+                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null,\"authentication\":\"an-authentication-token\"}",
                 new GraphQLRequest("simple query string"){{"authentication", "an-authentication-token"}}
             };
             yield return new object[] {
-                "{\"query\":\"enumtest\",\"variables\":{\"enums\":[\"REGULAR\",\"PASCAL_CASE\",\"CAMEL_CASE\",\"LOWER\",\"UPPER\",\"CONSTANT_CASE\"]},\"operationName\":null}",
+                "{\"query\":\"enumtest\",\"variables\":{\"enums\":[\"REGULAR\",\"PASCAL_CASE\",\"CAMEL_CASE\",\"LOWER\",\"UPPER\",\"CONSTANT_CASE\"]},\"operationName\":null,\"extensions\":null}",
                 new GraphQLRequest("enumtest", new { enums = Enum.GetValues(typeof(TestEnum)).Cast<TestEnum>()})
             };
         }
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 51ddf3e6..1b285443 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions.Reactive" Version="0.1.0-alpha.30" />
+    <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="6.0.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.2" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 9ca8df0b..e854727b 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -3,11 +3,11 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="5.0.11" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.6" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/tests/tests.props b/tests/tests.props
index 349dec0d..7d4a0255 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -3,16 +3,16 @@
   <Import Project="../root.props" />
 
   <PropertyGroup>
-		<IsPackable>false</IsPackable>
+    <IsPackable>false</IsPackable>
     <NoWarn>$(NoWarn);NU1701;IDE1006</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions.Reactive" Version="0.1.0-alpha.30" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
-    <PackageReference Include="coverlet.collector" Version="3.1.0">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime;build;native;contentfiles;analyzers;buildtransitive</IncludeAssets>
     </PackageReference>

From 923495123ee852691271d7a1d9bae734abcee844 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 13 Jun 2022 05:44:22 +0000
Subject: [PATCH 367/455] Bump actions/checkout from 2 to 3

Bumps [actions/checkout](https://github.com/actions/checkout) from 2 to 3.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v2...v3)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/branches.yml | 6 +++---
 .github/workflows/master.yml   | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 66468afe..84137705 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
         fetch-depth: 0
     - name: Restore dotnet tools
@@ -36,7 +36,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:
@@ -60,7 +60,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index daacff76..6f6da04d 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
       with:
         fetch-depth: 0
     - name: Restore dotnet tools
@@ -39,7 +39,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:
@@ -63,7 +63,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
     - name: Download version info file
       uses: actions/download-artifact@v1
       with:
@@ -80,7 +80,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
     - name: Download nuget packages
       uses: actions/download-artifact@v1
       with:

From ce341169a7aabb231a63daa656bbd2b373f6980f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Jul 2022 12:35:41 +0000
Subject: [PATCH 368/455] Bump actions/download-artifact from 1 to 3

Bumps [actions/download-artifact](https://github.com/actions/download-artifact) from 1 to 3.
- [Release notes](https://github.com/actions/download-artifact/releases)
- [Commits](https://github.com/actions/download-artifact/compare/v1...v3)

---
updated-dependencies:
- dependency-name: actions/download-artifact
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/branches.yml | 4 ++--
 .github/workflows/master.yml   | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 84137705..9b0ee728 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -38,7 +38,7 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v3
     - name: Download version info file
-      uses: actions/download-artifact@v1
+      uses: actions/download-artifact@v3
       with:
         name: gitversion
         path: ./
@@ -62,7 +62,7 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v3
     - name: Download version info file
-      uses: actions/download-artifact@v1
+      uses: actions/download-artifact@v3
       with:
         name: gitversion
         path: ./
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 6f6da04d..9b99aa36 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -41,7 +41,7 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v3
     - name: Download version info file
-      uses: actions/download-artifact@v1
+      uses: actions/download-artifact@v3
       with:
         name: gitversion
         path: ./
@@ -65,7 +65,7 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v3
     - name: Download version info file
-      uses: actions/download-artifact@v1
+      uses: actions/download-artifact@v3
       with:
         name: gitversion
         path: ./
@@ -82,7 +82,7 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v3
     - name: Download nuget packages
-      uses: actions/download-artifact@v1
+      uses: actions/download-artifact@v3
       with:
         name: nupkg
     - name: Publish the package to GPR

From 51ae3f1a831e2759445cdaab410a5e06ab2ddaff Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 12 Jul 2022 14:38:14 +0200
Subject: [PATCH 369/455] Fix path for nupkg checkout

---
 .github/workflows/master.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 9b99aa36..3c066c3d 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -85,6 +85,7 @@ jobs:
       uses: actions/download-artifact@v3
       with:
         name: nupkg
+        path: nupkg
     - name: Publish the package to GPR
     # using workaround with CURL because of non-functioning upload via dotnet nuget (https://stackoverflow.com/a/58943251)
       run: |

From cb62813f7763dfca9ce13963c4cd94d15a8b303e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Jul 2022 12:23:04 +0000
Subject: [PATCH 370/455] Bump actions/upload-artifact from 1 to 3

Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 1 to 3.
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/v1...v3)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/branches.yml | 4 ++--
 .github/workflows/master.yml   | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 9b0ee728..e493fc97 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -25,7 +25,7 @@ jobs:
     - name: Generate version info from git history
       run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> gitversion.env && cat gitversion.env
     - name: Upload version info file
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v3
       with:
         name: gitversion
         path: gitversion.env
@@ -49,7 +49,7 @@ jobs:
     - name: Create NuGet packages
       run: dotnet pack -c Release --no-build -o nupkg
     - name: Upload nuget packages
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v3
       with:
         name: nupkg
         path: nupkg
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 3c066c3d..3fbd5662 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -28,7 +28,7 @@ jobs:
     - name: Generate version info from git history
       run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> gitversion.env && cat gitversion.env
     - name: Upload version info file
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v3
       with:
         name: gitversion
         path: gitversion.env
@@ -52,7 +52,7 @@ jobs:
     - name: Create NuGet packages
       run: dotnet pack -c Release --no-build -o nupkg
     - name: Upload nuget packages
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v3
       with:
         name: nupkg
         path: nupkg

From ebe5231d99e1cf1da84e911cd593ca557366fb2a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Jul 2022 12:35:44 +0000
Subject: [PATCH 371/455] Bump xunit.runner.visualstudio from 2.4.1 to 2.4.5

Bumps [xunit.runner.visualstudio](https://github.com/xunit/visualstudio.xunit) from 2.4.1 to 2.4.5.
- [Release notes](https://github.com/xunit/visualstudio.xunit/releases)
- [Commits](https://github.com/xunit/visualstudio.xunit/commits)

---
updated-dependencies:
- dependency-name: xunit.runner.visualstudio
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 7d4a0255..f2157f5f 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -11,7 +11,7 @@
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.1.2">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime;build;native;contentfiles;analyzers;buildtransitive</IncludeAssets>

From 3ae63ec89efba0df6561fc4cdaa5f68bcc6d6fbd Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 15:13:33 +0200
Subject: [PATCH 372/455] reduce branches workflow to single job

---
 .github/workflows/branches.yml | 56 +++++++++-------------------------
 1 file changed, 14 insertions(+), 42 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index e493fc97..9160192b 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -6,12 +6,15 @@ on:
       - 'release/**'
       - 'releases/**'
   pull_request:
+
 env:
+  DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
   MSBUILDSINGLELOADCONTEXT: 1
+
 jobs:
-  generateVersionInfo:
-    name: GenerateVersionInfo
+  build:
+    name: Build and Test
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
@@ -23,50 +26,19 @@ jobs:
     - name: Fetch complete repository including tags
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
-      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> gitversion.env && cat gitversion.env
-    - name: Upload version info file
-      uses: actions/upload-artifact@v3
-      with:
-        name: gitversion
-        path: gitversion.env
-
-  build:
-    name: Build
-    needs: generateVersionInfo
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Download version info file
-      uses: actions/download-artifact@v3
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: cat ./gitversion.env >> $GITHUB_ENV
+      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> $GITHUB_ENV
+    - name: Print current version
+      run: echo "Current version is \"$GitVersion_SemVer\""
+    - name: Install dependencies
+      run: dotnet restore
     - name: Build solution
-      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
+      run:  dotnet build --no-restore -c Release
+    - name: Run Tests
+      run: dotnet test -c Release --no-restore --no-build
     - name: Create NuGet packages
-      run: dotnet pack -c Release --no-build -o nupkg
+      run: dotnet pack -c Release --no-restore --no-build -o nupkg
     - name: Upload nuget packages
       uses: actions/upload-artifact@v3
       with:
         name: nupkg
         path: nupkg
-
-  test:
-    name: Test
-    needs: [build, generateVersionInfo]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Download version info file
-      uses: actions/download-artifact@v3
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: cat ./gitversion.env >> $GITHUB_ENV
-    - name: Run tests
-      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release

From 1a1dc9eaf0266be1124b1de42af3b8c5b552cb1b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 15:27:43 +0200
Subject: [PATCH 373/455] add setup-dotnet

---
 .github/workflows/branches.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 9160192b..dc383883 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -21,6 +21,10 @@ jobs:
       uses: actions/checkout@v3
       with:
         fetch-depth: 0
+    - name: Setup .NET Core SDK
+      uses: actions/setup-dotnet@v2
+      with:
+        dotnet-version: "6.0.x"
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository including tags

From 8e60104f477cb39caf1ff05169ee9a382119093a Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 15:32:24 +0200
Subject: [PATCH 374/455] add older dotnet-sdks

---
 .github/workflows/branches.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index dc383883..764bf9db 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -24,7 +24,10 @@ jobs:
     - name: Setup .NET Core SDK
       uses: actions/setup-dotnet@v2
       with:
-        dotnet-version: "6.0.x"
+        dotnet-version: | 
+          3.1.x
+          5.0.x
+          6.0.x
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository including tags

From 4b06fb8bc7d28e8b6d0d5360f6dbe6365ed9ca28 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 15:45:57 +0200
Subject: [PATCH 375/455] check if version has been resolved

---
 .github/workflows/branches.yml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 764bf9db..40ad9123 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -25,8 +25,6 @@ jobs:
       uses: actions/setup-dotnet@v2
       with:
         dotnet-version: | 
-          3.1.x
-          5.0.x
           6.0.x
     - name: Restore dotnet tools
       run: dotnet tool restore
@@ -34,6 +32,11 @@ jobs:
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
       run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> $GITHUB_ENV
+    - name: Check that the version number has been resolved
+      if: ${{ !env.GitVersion_SemVer }}
+      run: |
+        echo Error! Version number not resolved!
+        exit 1
     - name: Print current version
       run: echo "Current version is \"$GitVersion_SemVer\""
     - name: Install dependencies

From 6b0236aa4035a44e7f4a435b474e11d65cf1664c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 15:48:06 +0200
Subject: [PATCH 376/455] upgrade gitversion.tool

---
 dotnet-tools.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dotnet-tools.json b/dotnet-tools.json
index 3c532709..7254cc09 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -8,7 +8,7 @@
       ]
     },
     "gitversion.tool": {
-      "version": "5.6.7",
+      "version": "5.10.3",
       "commands": [
         "dotnet-gitversion"
       ]

From 0022e39e275c02a572f7ad8ca1bf34e8867194e0 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 15:56:24 +0200
Subject: [PATCH 377/455] update master workflow

---
 .github/workflows/branches.yml |  2 +-
 .github/workflows/master.yml   | 94 ++++++++++------------------------
 2 files changed, 29 insertions(+), 67 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 40ad9123..3807f0a0 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -32,7 +32,7 @@ jobs:
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
       run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> $GITHUB_ENV
-    - name: Check that the version number has been resolved
+    - name: Fail if the version number has not been resolved
       if: ${{ !env.GitVersion_SemVer }}
       run: |
         echo Error! Version number not resolved!
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 3fbd5662..31cc1f10 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -5,91 +5,53 @@ on:
       - master
       - 'release/**'
       - 'releases/**'
-    tags:
-      - v*
-      - V*
+
 env:
+  DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
   MSBUILDSINGLELOADCONTEXT: 1
 
 jobs:
-  generateVersionInfo:
-    name: GenerateVersionInfo
+  build:
+    name: Build and Test
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
       uses: actions/checkout@v3
       with:
         fetch-depth: 0
+    - name: Setup .NET Core SDK
+      uses: actions/setup-dotnet@v2
+      with:
+        dotnet-version: "6.0.x"
+        source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository including tags
       run: git fetch --tags --force --prune && git describe
     - name: Generate version info from git history
-      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> gitversion.env && cat gitversion.env
-    - name: Upload version info file
-      uses: actions/upload-artifact@v3
-      with:
-        name: gitversion
-        path: gitversion.env
-
-  build:
-    name: Build
-    needs: generateVersionInfo
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Download version info file
-      uses: actions/download-artifact@v3
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: cat ./gitversion.env >> $GITHUB_ENV
+      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> $GITHUB_ENV
+    - name: Fail if the version number has not been resolved
+      if: ${{ !env.GitVersion_SemVer }}
+      run: |
+        echo Error! Version number not resolved!
+        exit 1
+    - name: Print current version
+      run: echo "Current version is \"$GitVersion_SemVer\""
+    - name: Install dependencies
+      run: dotnet restore
     - name: Build solution
-      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet build -c Release
+      run:  dotnet build --no-restore -c Release
+    - name: Run Tests
+      run: dotnet test -c Release --no-restore --no-build
     - name: Create NuGet packages
-      run: dotnet pack -c Release --no-build -o nupkg
-    - name: Upload nuget packages
+      run: dotnet pack -c Release --no-restore --no-build -o nupkg
+    - name: Upload nuget packages as artifacts
       uses: actions/upload-artifact@v3
       with:
         name: nupkg
         path: nupkg
-
-  test:
-    name: Test
-    needs: [build, generateVersionInfo]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Download version info file
-      uses: actions/download-artifact@v3
-      with:
-        name: gitversion
-        path: ./
-    - name: Inject version info into environment
-      run: cat ./gitversion.env >> $GITHUB_ENV
-    - name: Run tests
-      run: echo "Current version is \"$GitVersion_SemVer\"" && dotnet test -c Release
-
-  publish:
-    name: Publish
-    needs: [test]
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v3
-    - name: Download nuget packages
-      uses: actions/download-artifact@v3
-      with:
-        name: nupkg
-        path: nupkg
-    - name: Publish the package to GPR
-    # using workaround with CURL because of non-functioning upload via dotnet nuget (https://stackoverflow.com/a/58943251)
-      run: |
-           for f in ./nupkg/*.nupkg
-           do
-             curl -vX PUT -u "graphql-dotnet:${{secrets.GITHUB_TOKEN}}" -F package=@$f https://nuget.pkg.github.com/graphql-dotnet/
-           done
+    - name: Publish Nuget packages to GitHub registry
+      run: dotnet nuget push "nupkg/*" -k ${{secrets.GITHUB_TOKEN}}

From 5f666ae6df8a8ce3dc780ab539e622655d0f94c1 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 16:05:43 +0200
Subject: [PATCH 378/455] add publish workflow

---
 .github/workflows/publish.yml | 59 +++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 .github/workflows/publish.yml

diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 00000000..d890925f
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,59 @@
+name: Publish
+on:
+  release:
+    types:
+      - published
+
+env:
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+  MSBUILDSINGLELOADCONTEXT: 1
+
+jobs:
+  build:
+    name: Build and Test
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+    - name: Check github.ref starts with 'refs/tags/'
+      if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+      run: |
+        echo Error! github.ref does not start with 'refs/tags'
+        echo github.ref: ${{ github.ref }}
+        exit 1
+    - name: Setup .NET Core SDK
+      uses: actions/setup-dotnet@v2
+      with:
+        dotnet-version: "6.0.x"
+        source-url: https://api.nuget.org/v3/index.json
+      env:
+        NUGET_AUTH_TOKEN: ${{secrets.NUGET_API_KEY}}
+    - name: Restore dotnet tools
+      run: dotnet tool restore
+    - name: Fetch complete repository including tags
+      run: git fetch --tags --force --prune && git describe
+    - name: Generate version info from git history
+      run: dotnet gitversion /output json | jq -r 'to_entries|map("GitVersion_\(.key)=\(.value|tostring)")|.[]' >> $GITHUB_ENV
+    - name: Fail if the version number has not been resolved
+      if: ${{ !env.GitVersion_SemVer }}
+      run: |
+        echo Error! Version number not resolved!
+        exit 1
+    - name: Print current version
+      run: echo "Current version is \"$GitVersion_SemVer\""
+    - name: Install dependencies
+      run: dotnet restore
+    - name: Build solution
+      run:  dotnet build --no-restore -c Release
+    - name: Create NuGet packages
+      run: dotnet pack -c Release --no-restore --no-build -o nupkg
+    - name: Upload nuget packages as artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: nupkg
+        path: nupkg
+    - name: Publish Nuget packages to GitHub registry
+      run: dotnet nuget push "nupkg/*" -k ${{secrets.NUGET_API_KEY}}
\ No newline at end of file

From 54f5e8ac8172262b9e0106418f91de176346dd11 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 16:34:58 +0200
Subject: [PATCH 379/455] add script to upload nuget packages as release
 artifacts

---
 .github/workflows/publish.yml | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index d890925f..e070df28 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -55,5 +55,23 @@ jobs:
       with:
         name: nupkg
         path: nupkg
-    - name: Publish Nuget packages to GitHub registry
-      run: dotnet nuget push "nupkg/*" -k ${{secrets.NUGET_API_KEY}}
\ No newline at end of file
+    - name: Publish Nuget packages to Nuget registry
+      run: dotnet nuget push "nupkg/*" -k ${{secrets.NUGET_API_KEY}}
+    - name: Upload Nuget packages as release artifacts
+      uses: actions/github-script@v6
+      with:
+        github-token: ${{secrets.GITHUB_TOKEN}}
+        script: |
+          console.log('environment', process.versions);
+          const fs = require('fs').promises;
+          const { repo: { owner, repo }, sha } = context;
+          for (let file of await fs.readdir('nupkg')) {
+            console.log('uploading', file);
+            await github.rest.repos.uploadReleaseAsset({
+              owner,
+              repo,
+              release_id: ${{ github.event.release.id }},
+              name: file,
+              data: await fs.readFile(`nupkg/${file}`)
+            });
+          }
\ No newline at end of file

From 7f49e38f82ba146dda2548bdb49209484186291c Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Tue, 12 Jul 2022 16:36:18 +0200
Subject: [PATCH 380/455] add final newiline

---
 .github/workflows/publish.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index e070df28..ddff922e 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -74,4 +74,4 @@ jobs:
               name: file,
               data: await fs.readFile(`nupkg/${file}`)
             });
-          }
\ No newline at end of file
+          }

From 3304558c8dfc396af872a77ec95ad8c2843ba469 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 13 Jul 2022 00:28:12 +0300
Subject: [PATCH 381/455] Bump Microsoft.AspNetCore.Mvc.Testing from 6.0.6 to
 6.0.7 (#413)

Bumps [Microsoft.AspNetCore.Mvc.Testing](https://github.com/dotnet/aspnetcore) from 6.0.6 to 6.0.7.
- [Release notes](https://github.com/dotnet/aspnetcore/releases)
- [Changelog](https://github.com/dotnet/aspnetcore/blob/main/docs/ReleasePlanning.md)
- [Commits](https://github.com/dotnet/aspnetcore/commits)

---
updated-dependencies:
- dependency-name: Microsoft.AspNetCore.Mvc.Testing
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index e854727b..1377f01a 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.6" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.7" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 

From f81031506900a0aa02e6c164b6711710ab3e228a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 13 Jul 2022 00:32:08 +0300
Subject: [PATCH 382/455] Bump GraphQL.Server.Transports.AspNetCore from 6.0.0
 to 6.1.0 (#414)

Bumps [GraphQL.Server.Transports.AspNetCore](https://github.com/graphql-dotnet/server) from 6.0.0 to 6.1.0.
- [Release notes](https://github.com/graphql-dotnet/server/releases)
- [Commits](https://github.com/graphql-dotnet/server/compare/6.0.0...6.1.0)

---
updated-dependencies:
- dependency-name: GraphQL.Server.Transports.AspNetCore
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index bd680444..97773f9f 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,7 +6,7 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.MicrosoftDI" Version="5.0.0" />
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="6.0.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="6.1.0" />
     <PackageReference Include="GraphQL.Server.Transports.Subscriptions.WebSockets" Version="6.1.0" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="6.1.0" />
   </ItemGroup>

From ae7da16141a1d278a71fa75cf7a287d3b51b1aca Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Mon, 18 Jul 2022 10:32:46 +0300
Subject: [PATCH 383/455] Move IDisposable to implementation (#417)

---
 src/GraphQL.Client.Abstractions/IGraphQLClient.cs | 4 ++--
 src/GraphQL.Client/GraphQLHttpClient.cs           | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
index 0508f8b5..40ecac8e 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
@@ -5,7 +5,7 @@
 
 namespace GraphQL.Client.Abstractions
 {
-    public interface IGraphQLClient : IDisposable
+    public interface IGraphQLClient
     {
         Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
@@ -14,7 +14,7 @@ public interface IGraphQLClient : IDisposable
         /// <summary>
         /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
         /// All subscriptions made to this stream share the same hot observable.<br/>
-        /// The stream must be recreated completely after an error has occured within its logic (i.e. a <see cref="WebSocketException"/>)
+        /// The stream must be recreated completely after an error has occurred within its logic (i.e. a <see cref="WebSocketException"/>)
         /// </summary>
         /// <param name="request">the GraphQL request for this subscription</param>
         /// <returns>an observable stream for the specified subscription</returns>
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index ea095fc6..8df8951e 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -12,7 +12,7 @@
 
 namespace GraphQL.Client.Http
 {
-    public class GraphQLHttpClient : IGraphQLClient
+    public class GraphQLHttpClient : IGraphQLClient, IDisposable
     {
         private readonly Lazy<GraphQLHttpWebSocket> _lazyHttpWebSocket;
         private GraphQLHttpWebSocket GraphQlHttpWebSocket => _lazyHttpWebSocket.Value;

From 9ca13c232dc2c1095a9202fcd06cd2e738daebe8 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Mon, 18 Jul 2022 12:54:06 +0300
Subject: [PATCH 384/455] Add SourceLink, embedded readme, implicit usings;
 refactor project properties (#416)

* Add SourceLink, embedded readme, implicit usings; refactor project properties
---
 Directory.Build.props                         | 33 ++++++++++++++++
 src/src.props => Directory.Build.targets      | 33 +++++++++-------
 GraphQL.Client.sln                            | 11 ++----
 GraphQL.Client.sln.DotSettings                |  2 -
 examples/GraphQL.Client.Example/Program.cs    |  2 +-
 root.props                                    | 38 -------------------
 ...aphQL.Client.Abstractions.Websocket.csproj |  2 -
 .../GraphQLWebSocketRequest.cs                |  4 --
 .../GraphQLWebSocketResponse.cs               |  3 --
 .../IGraphQLWebsocketJsonSerializer.cs        |  3 --
 .../GraphQL.Client.Abstractions.csproj        |  2 -
 .../GraphQLClientExtensions.cs                |  4 --
 .../GraphQLJsonSerializerExtensions.cs        |  2 -
 .../IGraphQLClient.cs                         |  3 --
 .../IGraphQLJsonSerializer.cs                 |  4 --
 .../Utilities/StringExtensions.cs             |  4 +-
 .../Utilities/StringUtils.cs                  |  5 +--
 .../GraphQL.Client.LocalExecution.csproj      |  2 -
 .../GraphQLLocalExecutionClient.cs            |  5 ---
 .../ConstantCaseEnumConverter.cs              |  2 -
 ...raphQL.Client.Serializer.Newtonsoft.csproj |  2 -
 .../MapConverter.cs                           |  3 --
 .../NewtonsoftJsonSerializer.cs               |  4 --
 .../ConverterHelperExtensions.cs              |  1 -
 .../ErrorPathConverter.cs                     |  3 --
 ...QL.Client.Serializer.SystemTextJson.csproj |  2 -
 .../ImmutableConverter.cs                     |  3 --
 .../MapConverter.cs                           |  4 --
 .../SystemTextJsonSerializer.cs               |  4 --
 src/GraphQL.Client/GraphQL.Client.csproj      |  2 -
 src/GraphQL.Client/GraphQLHttpClient.cs       |  8 +---
 .../GraphQLHttpClientExtensions.cs            |  1 -
 .../GraphQLHttpClientOptions.cs               |  5 +--
 src/GraphQL.Client/GraphQLHttpRequest.cs      |  2 -
 .../GraphQLHttpRequestException.cs            |  1 -
 src/GraphQL.Client/GraphQLHttpResponse.cs     |  1 -
 .../GraphQLSubscriptionException.cs           |  1 -
 src/GraphQL.Client/UriExtensions.cs           |  2 -
 .../Websocket/GraphQLHttpWebSocket.cs         |  5 ---
 .../GraphQLWebsocketConnectionException.cs    |  1 -
 src/GraphQL.Primitives/ErrorPath.cs           |  2 -
 .../GraphQL.Primitives.csproj                 |  2 -
 src/GraphQL.Primitives/GraphQLError.cs        |  3 --
 src/GraphQL.Primitives/GraphQLLocation.cs     |  3 --
 src/GraphQL.Primitives/GraphQLRequest.cs      |  4 --
 src/GraphQL.Primitives/GraphQLResponse.cs     |  3 --
 src/GraphQL.Primitives/Map.cs                 |  2 -
 .../.editorconfig                             |  0
 .../Chat/AddMessageVariables.cs               |  2 -
 .../Chat/GraphQLClientChatExtensions.cs       |  2 -
 .../Chat/Schema/ChatQuery.cs                  |  3 --
 .../Chat/Schema/ChatSchema.cs                 |  1 -
 .../Chat/Schema/ChatSubscriptions.cs          |  2 -
 .../Chat/Schema/IChat.cs                      |  2 -
 .../Chat/Schema/Message.cs                    |  2 -
 .../Chat/Schema/ReceivedMessage.cs            |  2 -
 .../Helpers/AvailableJsonSerializers.cs       |  3 --
 .../Helpers/CallbackMonitor.cs                |  2 -
 .../Helpers/ConcurrentTaskWrapper.cs          |  3 --
 .../Helpers/MiscellaneousExtensions.cs        |  2 -
 .../ResolveFieldContextExtensions.cs          |  3 --
 .../StarWars/StarWarsData.cs                  |  3 --
 .../StarWars/StarWarsMutation.cs              |  1 +
 .../StarWars/StarWarsQuery.cs                 |  2 -
 .../StarWars/StarWarsSchema.cs                |  1 -
 .../StarWars/TestData/StarWarsHumans.cs       |  1 -
 .../StarWars/Types/StarWarsCharacter.cs       |  2 -
 .../GraphQL.Common.Tests.csproj               | 15 --------
 tests/GraphQL.Integration.Tests/.editorconfig |  2 -
 .../Helpers/IntegrationServerTestFixture.cs   |  3 --
 .../Helpers/WebHostHelpers.cs                 |  7 ----
 .../QueryAndMutationTests/Base.cs             |  6 ---
 .../UriExtensionTests.cs                      |  3 +-
 .../WebsocketTests/Base.cs                    |  6 ---
 tests/GraphQL.Primitives.Tests/.editorconfig  |  2 -
 tests/GraphQL.Server.Test/.editorconfig       |  2 -
 .../GraphQL.Server.Test.csproj                |  1 +
 .../GraphQL/Models/Repository.cs              |  9 ++---
 tests/GraphQL.Server.Test/GraphQL/Storage.cs  |  3 --
 .../GraphQL.Server.Test/GraphQL/TestQuery.cs  |  1 -
 tests/GraphQL.Server.Test/Program.cs          |  4 +-
 tests/GraphQL.Server.Test/Startup.cs          |  4 --
 tests/IntegrationTestServer/.editorconfig     |  2 -
 .../IntegrationTestServer.csproj              |  1 +
 tests/IntegrationTestServer/Program.cs        |  6 +--
 tests/IntegrationTestServer/Startup.cs        |  6 ---
 tests/tests.props                             |  2 -
 87 files changed, 72 insertions(+), 290 deletions(-)
 create mode 100644 Directory.Build.props
 rename src/src.props => Directory.Build.targets (66%)
 delete mode 100644 GraphQL.Client.sln.DotSettings
 delete mode 100644 root.props
 rename tests/{GraphQL.Client.Serializer.Tests => }/.editorconfig (100%)
 delete mode 100644 tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
 delete mode 100644 tests/GraphQL.Integration.Tests/.editorconfig
 delete mode 100644 tests/GraphQL.Primitives.Tests/.editorconfig
 delete mode 100644 tests/GraphQL.Server.Test/.editorconfig
 delete mode 100644 tests/IntegrationTestServer/.editorconfig

diff --git a/Directory.Build.props b/Directory.Build.props
new file mode 100644
index 00000000..3b54328d
--- /dev/null
+++ b/Directory.Build.props
@@ -0,0 +1,33 @@
+<Project>
+
+  <PropertyGroup>
+    <Authors>Deinok,Alexander Rose,graphql-dotnet</Authors>
+    <Description>A GraphQL Client for .NET Standard</Description>
+    <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <LangVersion>latest</LangVersion>
+    <NeutralLanguage>en-US</NeutralLanguage>
+    <NoWarn>$(NoWarn);NU5105</NoWarn> <!--TODO: fix-->
+    <NoWarn>$(NoWarn);1591</NoWarn> <!--TODO: write comments to public APIs-->
+    <Nullable>annotations</Nullable>
+    <PackageIcon>logo.64x64.png</PackageIcon>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
+    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
+    <PackageTags>GraphQL</PackageTags>
+    <RepositoryType>git</RepositoryType>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <Deterministic>true</Deterministic>
+    <!-- https://help.github.com/en/actions/configuring-and-managing-workflows/using-environment-variables -->
+    <!-- https://github.com/clairernovotny/DeterministicBuilds -->
+    <ContinuousIntegrationBuild Condition="'$(GITHUB_ACTIONS)' == 'true'">true</ContinuousIntegrationBuild>
+    <DebugType>embedded</DebugType>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
+    <WarningLevel>4</WarningLevel>
+    <IsPackable>true</IsPackable>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/src.props b/Directory.Build.targets
similarity index 66%
rename from src/src.props
rename to Directory.Build.targets
index 37933c88..af739e1d 100644
--- a/src/src.props
+++ b/Directory.Build.targets
@@ -1,20 +1,12 @@
 <Project>
 
-  <Import Project="../root.props" />
-
-  <PropertyGroup>
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-    <LangVersion>8.0</LangVersion>
+  <PropertyGroup Condition="'$(IsPackable)' == 'true'">
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <!--<Nullable>enable</Nullable>--> <!--TODO-->
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild> <!--TODO: remove? since generated on CI-->
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Update="GitVersionTask" Version="5.6.7">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-
-  <PropertyGroup Condition=" '$(GitVersion_SemVer)' != ''">
+  <PropertyGroup Condition="'$(IsPackable)' == 'true' AND '$(GitVersion_SemVer)' != ''">
     <GetVersion>false</GetVersion>
     <WriteVersionInfoToBuildLog>false</WriteVersionInfoToBuildLog>
     <UpdateAssemblyInfo>false</UpdateAssemblyInfo>
@@ -33,4 +25,19 @@
     <RepositoryCommit Condition=" '$(RepositoryCommit)' == '' ">$(GitVersion_Sha)</RepositoryCommit>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(IsPackable)' != 'true'">
+    <NoWarn>$(NoWarn);1591</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(IsPackable)' == 'true'">
+    <None Include="..\..\assets\logo.64x64.png" Pack="true" PackagePath="\" />
+    <None Include="..\..\README.md" Pack="true" PackagePath="\" />
+    <None Include="..\..\LICENSE.txt" Pack="true" PackagePath="\" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
+    <PackageReference Update="GitVersionTask" Version="5.6.7">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
 </Project>
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 2de94cfb..89782ecc 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -4,26 +4,21 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 VisualStudioVersion = 17.1.32228.430
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{47C98B55-08F1-4428-863E-2C5C876DEEFE}"
-	ProjectSection(SolutionItems) = preProject
-		src\.editorconfig = src\.editorconfig
-		src\src.props = src\src.props
-	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{63F75859-4698-4EDE-8B70-4ACBB8BC425A}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
 		.gitignore = .gitignore
+		Directory.Build.props = Directory.Build.props
+		Directory.Build.targets = Directory.Build.targets
 		dotnet-tools.json = dotnet-tools.json
 		LICENSE.txt = LICENSE.txt
 		examples\GraphQL.Client.Example\Program.cs = examples\GraphQL.Client.Example\Program.cs
 		README.md = README.md
-		root.props = root.props
+		tests\tests.props = tests\tests.props
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}"
-	ProjectSection(SolutionItems) = preProject
-		tests\tests.props = tests\tests.props
-	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "assets", "assets", "{6326E0E2-3F48-4BAF-80D3-47AED5EB647C}"
 	ProjectSection(SolutionItems) = preProject
diff --git a/GraphQL.Client.sln.DotSettings b/GraphQL.Client.sln.DotSettings
deleted file mode 100644
index 9e5ec22f..00000000
--- a/GraphQL.Client.sln.DotSettings
+++ /dev/null
@@ -1,2 +0,0 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=QL/@EntryIndexedValue">QL</s:String></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index 0bfd14b1..a67114a1 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -7,7 +7,7 @@
 
 namespace GraphQL.Client.Example
 {
-    public class Program
+    public static class Program
     {
         public static async Task Main()
         {
diff --git a/root.props b/root.props
deleted file mode 100644
index 17bd287e..00000000
--- a/root.props
+++ /dev/null
@@ -1,38 +0,0 @@
-<Project>
-
-  <PropertyGroup>
-    <Authors>Deinok,Alexander Rose,graphql-dotnet</Authors>
-    <Description>A GraphQL Client for .NET Standard</Description>
-    <GenerateAssemblyInfo>True</GenerateAssemblyInfo>
-    <GenerateDocumentationFile>True</GenerateDocumentationFile>
-    <LangVersion>8.0</LangVersion>
-    <NeutralLanguage>en-US</NeutralLanguage>
-    <NoWarn>$(NoWarn);CS1591;NU5048;NU5105;NU5125</NoWarn>
-    <Nullable>annotations</Nullable>
-    <PackageIcon>icon.png</PackageIcon>
-    <PackageLicenseFile>LICENSE.txt</PackageLicenseFile>
-    <PackageProjectUrl>https://github.com/graphql-dotnet/graphql-client</PackageProjectUrl>
-    <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
-    <PackageTags>GraphQL</PackageTags>
-    <RepositoryType>git</RepositoryType>
-    <RepositoryUrl>https://github.com/graphql-dotnet/graphql-client</RepositoryUrl>
-    <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Content Include="$(MSBuildThisFileDirectory)/LICENSE.txt">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <Pack>true</Pack>
-      <PackagePath>LICENSE.txt</PackagePath>
-      <Visible>false</Visible>
-    </Content>
-    <Content Include="$(MSBuildThisFileDirectory)/assets/logo.64x64.png">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <Pack>true</Pack>
-      <PackagePath>icon.png</PackagePath>
-      <Visible>false</Visible>
-    </Content>
-  </ItemGroup>
-
-</Project>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
index 048dffbf..5960fbf8 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQL.Client.Abstractions.Websocket.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../src.props" />
-
   <PropertyGroup>
     <Description>Abstractions for the Websocket transport used in GraphQL.Client</Description>
     <TargetFramework>netstandard2.0</TargetFramework>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index f83fe5aa..1210c34a 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
 namespace GraphQL.Client.Abstractions.Websocket
 {
     /// <summary>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
index 390834da..5de56492 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-
 namespace GraphQL.Client.Abstractions.Websocket
 {
     /// <summary>
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index 5e3d58ec..4526d797 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -1,6 +1,3 @@
-using System.IO;
-using System.Threading.Tasks;
-
 namespace GraphQL.Client.Abstractions.Websocket
 {
     /// <summary>
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index ef5087f4..58f116f2 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../src.props" />
-
   <PropertyGroup>
     <Description>Abstractions for GraphQL.Client</Description>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
diff --git a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index 0c891bf7..379eb932 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -1,7 +1,3 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
 namespace GraphQL.Client.Abstractions
 {
     public static class GraphQLClientExtensions
diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index 9222690c..56ff68e6 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace GraphQL.Client.Abstractions
 {
     public static class GraphQLJsonSerializerExtensions
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
index 40ecac8e..f289786b 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
@@ -1,7 +1,4 @@
-using System;
 using System.Net.WebSockets;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace GraphQL.Client.Abstractions
 {
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
index fa21dbac..9f5f9410 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
@@ -1,7 +1,3 @@
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-
 namespace GraphQL.Client.Abstractions
 {
     public interface IGraphQLJsonSerializer
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
index 38c718a8..8aeb4cb0 100644
--- a/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-
-namespace GraphQL.Client.Abstractions.Utilities
+namespace GraphQL.Client.Abstractions.Utilities
 {
     /// <summary>
     /// Copied from https://github.com/jquense/StringUtils
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
index c643fd23..57673216 100644
--- a/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 
 namespace GraphQL.Client.Abstractions.Utilities
 {
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 36d80714..6973829f 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../src.props" />
-
   <PropertyGroup>
     <Description>A GraphQL Client which executes the queries directly on a provided GraphQL schema using graphql-dotnet</Description>
     <TargetFramework>netstandard2.0</TargetFramework>
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 9a741b32..4a92e647 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -1,10 +1,5 @@
-using System;
-using System.IO;
-using System.Linq;
 using System.Reactive.Linq;
 using System.Reactive.Threading.Tasks;
-using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Types;
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
index d618a490..476eed9c 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Linq;
 using System.Reflection;
 using GraphQL.Client.Abstractions.Utilities;
 using Newtonsoft.Json;
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index 27801752..65aef0d0 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../src.props" />
-
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using Newtonsoft.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0</TargetFrameworks>
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index 3caefd5f..d1dd60f4 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index e7cae90f..6e362c08 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -1,8 +1,4 @@
-using System;
-using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using Newtonsoft.Json;
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
index fbb9036d..7afffe57 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Buffers;
 using System.Numerics;
 using System.Text;
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
index b2718096..4114a17a 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index ffb763bd..e49b975d 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../src.props" />
-
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using System.Text.Json as underlying JSON library</Description>
     <TargetFrameworks>netstandard2.0;netcoreapp3.1</TargetFrameworks>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index 7355970d..0c9ec398 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
index e41c1bf5..e3ab7217 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index d0325464..05b2c2f0 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -1,9 +1,5 @@
-using System;
-using System.IO;
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 8203c2f4..719c1a76 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../src.props" />
-
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
     <RootNamespace>GraphQL.Client.Http</RootNamespace>
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 8df8951e..fb95a963 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,11 +1,5 @@
-using System;
 using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Net.Http;
 using System.Net.Http.Headers;
-using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
@@ -110,7 +104,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         #endregion
 
         /// <summary>
-        /// explicitly opens the websocket connection. Will be closed again on disposing the last subscription
+        /// Explicitly opens the websocket connection. Will be closed again on disposing the last subscription.
         /// </summary>
         /// <returns></returns>
         public Task InitializeWebsocketConnection() => GraphQlHttpWebSocket.InitializeWebSocket();
diff --git a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index 041ed5c6..c3f49dfb 100644
--- a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Net.WebSockets;
 using GraphQL.Client.Abstractions;
 
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index dac7c4f1..74cd6c08 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -1,13 +1,10 @@
-using System;
-using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
-using System.Threading.Tasks;
 
 namespace GraphQL.Client.Http
 {
     /// <summary>
-    /// The Options that the <see cref="GraphQLHttpClient"/> will use
+    /// The Options that the <see cref="GraphQLHttpClient"/> will use.
     /// </summary>
     public class GraphQLHttpClientOptions
     {
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index eb3aac14..ac62c6a8 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Net.Http;
 using System.Runtime.Serialization;
 using System.Text;
 using GraphQL.Client.Abstractions;
diff --git a/src/GraphQL.Client/GraphQLHttpRequestException.cs b/src/GraphQL.Client/GraphQLHttpRequestException.cs
index 5b3a8b9f..faf7e6c5 100644
--- a/src/GraphQL.Client/GraphQLHttpRequestException.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequestException.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Net;
 using System.Net.Http.Headers;
 
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index b4b09784..8888ff61 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Net;
 using System.Net.Http.Headers;
 
diff --git a/src/GraphQL.Client/GraphQLSubscriptionException.cs b/src/GraphQL.Client/GraphQLSubscriptionException.cs
index d9accc85..28e8566c 100644
--- a/src/GraphQL.Client/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client/GraphQLSubscriptionException.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Runtime.Serialization;
 
 namespace GraphQL.Client.Http
diff --git a/src/GraphQL.Client/UriExtensions.cs b/src/GraphQL.Client/UriExtensions.cs
index 296eb052..1e2e53e2 100644
--- a/src/GraphQL.Client/UriExtensions.cs
+++ b/src/GraphQL.Client/UriExtensions.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace GraphQL.Client.Http
 {
     public static class UriExtensions
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 67a517c6..0aa60818 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -1,7 +1,4 @@
-using System;
 using System.Diagnostics;
-using System.IO;
-using System.Net.Http;
 using System.Net.WebSockets;
 using System.Reactive;
 using System.Reactive.Disposables;
@@ -9,8 +6,6 @@
 using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Http.Websocket
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
index c6b2e831..a1416948 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Runtime.Serialization;
 
 namespace GraphQL.Client.Http.Websocket
diff --git a/src/GraphQL.Primitives/ErrorPath.cs b/src/GraphQL.Primitives/ErrorPath.cs
index 59abdb79..dd449d73 100644
--- a/src/GraphQL.Primitives/ErrorPath.cs
+++ b/src/GraphQL.Primitives/ErrorPath.cs
@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-
 namespace GraphQL
 {
     public class ErrorPath : List<object>
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index c4210d9d..676e6fe8 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -1,7 +1,5 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <Import Project="../src.props" />
-
   <PropertyGroup>
     <Description>GraphQL basic types</Description>
     <RootNamespace>GraphQL</RootNamespace>
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index c76d3f00..7b3e9a1a 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.Serialization;
 
 namespace GraphQL
diff --git a/src/GraphQL.Primitives/GraphQLLocation.cs b/src/GraphQL.Primitives/GraphQLLocation.cs
index 9464817a..4a499031 100644
--- a/src/GraphQL.Primitives/GraphQLLocation.cs
+++ b/src/GraphQL.Primitives/GraphQLLocation.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-
 namespace GraphQL
 {
     /// <summary>
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 2755122c..5dbb766d 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -1,7 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
 namespace GraphQL
 {
     /// <summary>
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index 1c1af7de..c4c8a010 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.Serialization;
 
 namespace GraphQL
diff --git a/src/GraphQL.Primitives/Map.cs b/src/GraphQL.Primitives/Map.cs
index 9c4f503b..b51f5a85 100644
--- a/src/GraphQL.Primitives/Map.cs
+++ b/src/GraphQL.Primitives/Map.cs
@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-
 namespace GraphQL
 {
     /// <summary>
diff --git a/tests/GraphQL.Client.Serializer.Tests/.editorconfig b/tests/.editorconfig
similarity index 100%
rename from tests/GraphQL.Client.Serializer.Tests/.editorconfig
rename to tests/.editorconfig
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
index 887c55cd..916054e8 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace GraphQL.Client.Tests.Common.Chat
 {
     public class AddMessageVariables
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index 07648f06..47edfc28 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions;
 
 namespace GraphQL.Client.Tests.Common.Chat
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index e60bf97e..5645beb8 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
 using GraphQL.Types;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
index fbdfedf1..d606cdbd 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
@@ -1,4 +1,3 @@
-using System;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
index f3fbab63..58dcd240 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Linq;
 using System.Reactive.Linq;
 using System.Security.Claims;
 using GraphQL.Resolvers;
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index 63aaf439..bfbdeb32 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -1,10 +1,8 @@
-using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
-using System.Threading;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema
 {
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
index 345a397e..e344caee 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace GraphQL.Client.Tests.Common.Chat.Schema
 {
     public class Message
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
index 9cf72c9b..95d7d295 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace GraphQL.Client.Tests.Common.Chat.Schema
 {
     public class ReceivedMessage
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
index 4104fd20..dca19832 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
@@ -1,7 +1,4 @@
-using System;
 using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
 using GraphQL.Client.Abstractions;
 
 namespace GraphQL.Client.Tests.Common.Helpers
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index 54e51c78..3603041c 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -1,6 +1,4 @@
-using System;
 using System.Diagnostics;
-using System.Threading;
 using FluentAssertions;
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
index c16e1744..6d957c38 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Threading.Tasks;
-
 namespace GraphQL.Client.Tests.Common.Helpers
 {
     public class ConcurrentTaskWrapper
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
index dcbb6db9..428d4cca 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
@@ -1,5 +1,3 @@
-using System.Linq;
-using System.Threading.Tasks;
 using GraphQL.Client.Http;
 
 namespace GraphQL.Client.Tests.Common.Helpers
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
index 44ba5895..ff3a12da 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using GraphQL.Builders;
 using GraphQL.Client.Tests.Common.StarWars.Types;
 using GraphQL.Types.Relay.DataObjects;
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
index f561ed87..c0d3595b 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
@@ -1,6 +1,3 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
 using GraphQL.Client.Tests.Common.StarWars.Types;
 
 namespace GraphQL.Client.Tests.Common.StarWars
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
index cd577688..130ee1a9 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
@@ -3,6 +3,7 @@
 
 namespace GraphQL.Client.Tests.Common.StarWars
 {
+    /// <summary> Mutation graph type for StarWars schema. </summary>
     /// <example>
     /// This is an example JSON request for a mutation
     /// {
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
index ee2b9d3d..38b29e6f 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
@@ -1,5 +1,3 @@
-using System;
-using System.Threading.Tasks;
 using GraphQL.Client.Tests.Common.StarWars.Types;
 using GraphQL.Types;
 
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
index eff7cff4..3756f471 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
@@ -1,4 +1,3 @@
-using System;
 using GraphQL.Types;
 using Microsoft.Extensions.DependencyInjection;
 
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs b/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
index 1e93ccb6..25376b87 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
@@ -1,5 +1,4 @@
 using System.Collections;
-using System.Collections.Generic;
 
 namespace GraphQL.Client.Tests.Common.StarWars.TestData
 {
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
index b39d4cdc..6c646e0b 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-
 namespace GraphQL.Client.Tests.Common.StarWars.Types
 {
     public abstract class StarWarsCharacter
diff --git a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj b/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
deleted file mode 100644
index 4aae0487..00000000
--- a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-
-	<Import Project="../tests.props" />
-
-	<PropertyGroup>
-		<IsTestProject>true</IsTestProject>
-		<TargetFramework>netcoreapp3.0</TargetFramework>
-	</PropertyGroup>
-	
-	<ItemGroup>
-		<ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
-	</ItemGroup>
-
-</Project>
diff --git a/tests/GraphQL.Integration.Tests/.editorconfig b/tests/GraphQL.Integration.Tests/.editorconfig
deleted file mode 100644
index d1655ff8..00000000
--- a/tests/GraphQL.Integration.Tests/.editorconfig
+++ /dev/null
@@ -1,2 +0,0 @@
-# Configure await
-configure_await_analysis_mode = disabled
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index 25773b47..59dc0733 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -1,12 +1,9 @@
-using System;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Client.Serializer.SystemTextJson;
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Helpers;
-using Microsoft.AspNetCore.Hosting;
 
 namespace GraphQL.Integration.Tests.Helpers
 {
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 0bdb0e8c..fb3ba46b 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,16 +1,9 @@
-using System;
-using System.Threading.Tasks;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Helpers;
 using IntegrationTestServer;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
 namespace GraphQL.Integration.Tests.Helpers
 {
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 249ef8e7..e489046a 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -1,17 +1,11 @@
-using System;
 using System.Net;
-using System.Net.Http;
-using System.Threading;
-using System.Threading.Tasks;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http;
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
-using GraphQL.Client.Tests.Common.StarWars;
 using GraphQL.Client.Tests.Common.StarWars.TestData;
 using GraphQL.Integration.Tests.Helpers;
-using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests
diff --git a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
index 1298ca11..4daba07c 100644
--- a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
+++ b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
@@ -1,5 +1,4 @@
-using System;
-using FluentAssertions;
+using FluentAssertions;
 using GraphQL.Client.Http;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 8bc9cc7f..a63ed980 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -1,11 +1,6 @@
-using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Net.WebSockets;
-using System.Threading;
-using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Execution;
 using FluentAssertions.Extensions;
@@ -17,7 +12,6 @@
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.Helpers;
 using GraphQL.Integration.Tests.Helpers;
-using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 using Xunit.Abstractions;
 
diff --git a/tests/GraphQL.Primitives.Tests/.editorconfig b/tests/GraphQL.Primitives.Tests/.editorconfig
deleted file mode 100644
index d1655ff8..00000000
--- a/tests/GraphQL.Primitives.Tests/.editorconfig
+++ /dev/null
@@ -1,2 +0,0 @@
-# Configure await
-configure_await_analysis_mode = disabled
diff --git a/tests/GraphQL.Server.Test/.editorconfig b/tests/GraphQL.Server.Test/.editorconfig
deleted file mode 100644
index d1655ff8..00000000
--- a/tests/GraphQL.Server.Test/.editorconfig
+++ /dev/null
@@ -1,2 +0,0 @@
-# Configure await
-configure_await_analysis_mode = disabled
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 97773f9f..ac59ef1a 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>net6</TargetFramework>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
index 95e5f1fc..b262a6bd 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
@@ -1,4 +1,3 @@
-using System;
 using GraphQL.Types;
 
 namespace GraphQL.Server.Test.GraphQL.Models
@@ -7,13 +6,13 @@ public class Repository
     {
         public int DatabaseId { get; set; }
 
-        public string Id { get; set; }
+        public string? Id { get; set; }
 
-        public string Name { get; set; }
+        public string? Name { get; set; }
 
-        public object Owner { get; set; }
+        public object? Owner { get; set; }
 
-        public Uri Url { get; set; }
+        public Uri? Url { get; set; }
     }
 
     public class RepositoryGraphType : ObjectGraphType<Repository>
diff --git a/tests/GraphQL.Server.Test/GraphQL/Storage.cs b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
index 0280b28f..f157da14 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Storage.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
@@ -1,6 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using GraphQL.Server.Test.GraphQL.Models;
 
 namespace GraphQL.Server.Test.GraphQL
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index bf8aa3ae..4eb32723 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -1,4 +1,3 @@
-using System.Linq;
 using GraphQL.Server.Test.GraphQL.Models;
 using GraphQL.Types;
 
diff --git a/tests/GraphQL.Server.Test/Program.cs b/tests/GraphQL.Server.Test/Program.cs
index df18d888..98538f1f 100644
--- a/tests/GraphQL.Server.Test/Program.cs
+++ b/tests/GraphQL.Server.Test/Program.cs
@@ -1,10 +1,8 @@
-using System.Threading.Tasks;
 using Microsoft.AspNetCore;
-using Microsoft.AspNetCore.Hosting;
 
 namespace GraphQL.Server.Test
 {
-    public class Program
+    public static class Program
     {
         public static async Task Main(string[] args) =>
             await CreateHostBuilder(args).Build().RunAsync();
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index 06eae89b..2421cf70 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -1,10 +1,6 @@
 using GraphQL.MicrosoftDI;
 using GraphQL.Server.Test.GraphQL;
 using GraphQL.Server.Ui.GraphiQL;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
 
 namespace GraphQL.Server.Test
 {
diff --git a/tests/IntegrationTestServer/.editorconfig b/tests/IntegrationTestServer/.editorconfig
deleted file mode 100644
index d1655ff8..00000000
--- a/tests/IntegrationTestServer/.editorconfig
+++ /dev/null
@@ -1,2 +0,0 @@
-# Configure await
-configure_await_analysis_mode = disabled
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 1e68549b..4bda2103 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFramework>net6</TargetFramework>
     <StartupObject>IntegrationTestServer.Program</StartupObject>
+    <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index 09269167..ac56ea87 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,16 +1,14 @@
 using Microsoft.AspNetCore;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Logging;
 
 namespace IntegrationTestServer
 {
-    public class Program
+    public static class Program
     {
         public static void Main(string[] args) => CreateWebHostBuilder(args).Build().Run();
 
         public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
             WebHost.CreateDefaultBuilder(args)
                 .UseStartup<Startup>()
-                .ConfigureLogging((ctx, logging) => logging.SetMinimumLevel(LogLevel.Debug));
+                .ConfigureLogging((_, logging) => logging.SetMinimumLevel(LogLevel.Debug));
     }
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 0d1ad68e..c8441472 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -8,13 +8,7 @@
 using GraphQL.Server.Ui.GraphiQL;
 using GraphQL.SystemTextJson;
 using GraphQL.Types;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 
 namespace IntegrationTestServer
 {
diff --git a/tests/tests.props b/tests/tests.props
index f2157f5f..28e5e65c 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -1,7 +1,5 @@
 <Project>
 
-  <Import Project="../root.props" />
-
   <PropertyGroup>
     <IsPackable>false</IsPackable>
     <NoWarn>$(NoWarn);NU1701;IDE1006</NoWarn>

From ac2043a577f33906fc1d295dce1dd9c76e4063dd Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Wed, 20 Jul 2022 01:36:16 +0300
Subject: [PATCH 385/455] Allow non-200 HTTP status codes (#419)

* Allow non-200 HTTP status codes

* Update src/GraphQL.Client/GraphQLHttpClientOptions.cs

Co-authored-by: Alexander Rose <alex@rose-a.de>

* fix

Co-authored-by: Alexander Rose <alex@rose-a.de>
---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 19 +++++++++++--------
 .../GraphQLHttpClientOptions.cs               | 12 +++++++++---
 2 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index fb95a963..a0b20c5d 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -11,7 +11,7 @@ public class GraphQLHttpClient : IGraphQLClient, IDisposable
         private readonly Lazy<GraphQLHttpWebSocket> _lazyHttpWebSocket;
         private GraphQLHttpWebSocket GraphQlHttpWebSocket => _lazyHttpWebSocket.Value;
 
-        private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+        private readonly CancellationTokenSource _cancellationTokenSource = new();
 
         private readonly bool _disposeHttpClient = false;
 
@@ -42,14 +42,17 @@ public class GraphQLHttpClient : IGraphQLClient, IDisposable
 
         #region Constructors
 
-        public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serializer) : this(new Uri(endPoint), serializer) { }
+        public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serializer)
+            : this(new Uri(endPoint), serializer) { }
 
-        public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serializer) : this(o => o.EndPoint = endPoint, serializer) { }
+        public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serializer)
+            : this(o => o.EndPoint = endPoint, serializer) { }
 
-        public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer) : this(configure.New(), serializer) { }
+        public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer)
+            : this(configure.New(), serializer) { }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer) : this(
-            options, serializer, new HttpClient(options.HttpMessageHandler))
+        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer)
+            : this(options, serializer, new HttpClient(options.HttpMessageHandler))
         {
             // set this flag to dispose the internally created HttpClient when GraphQLHttpClient gets disposed
             _disposeHttpClient = true;
@@ -120,7 +123,7 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TRespons
 
             var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
 
-            if (httpResponseMessage.IsSuccessStatusCode)
+            if (Options.IsValidResponseToDeserialize(httpResponseMessage))
             {
                 var graphQLResponse = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(contentStream, cancellationToken).ConfigureAwait(false);
                 return graphQLResponse.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
@@ -167,7 +170,7 @@ public void Dispose()
         }
 
         private volatile bool _disposed;
-        private readonly object _disposeLocker = new object();
+        private readonly object _disposeLocker = new();
 
         protected virtual void Dispose(bool disposing)
         {
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 74cd6c08..acbdfaab 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -1,3 +1,4 @@
+using System.Net;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
 
@@ -16,7 +17,7 @@ public class GraphQLHttpClientOptions
         /// <summary>
         /// The GraphQL EndPoint to be used for websocket connections
         /// </summary>
-        public Uri? WebSocketEndPoint { get; set; } = null;
+        public Uri? WebSocketEndPoint { get; set; }
 
         /// <summary>
         /// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
@@ -50,12 +51,17 @@ public class GraphQLHttpClientOptions
             Task.FromResult(request is GraphQLHttpRequest graphQLHttpRequest ? graphQLHttpRequest : new GraphQLHttpRequest(request));
 
         /// <summary>
-        /// This callback is called after successfully establishing a websocket connection but before any regular request is made. 
+        /// Delegate to determine if GraphQL response may be properly deserialized into <see cref="GraphQLResponse{T}"/>.
+        /// </summary>
+        public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = r => r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest;
+
+        /// <summary>
+        /// This callback is called after successfully establishing a websocket connection but before any regular request is made.
         /// </summary>
         public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
 
         /// <summary>
-        /// Configure additional websocket options (i.e. headers). This will not be invoked on Windows 7 when targeting .NET Framework 4.x. 
+        /// Configure additional websocket options (i.e. headers). This will not be invoked on Windows 7 when targeting .NET Framework 4.x.
         /// </summary>
         public Action<ClientWebSocketOptions> ConfigureWebsocketOptions { get; set; } = options => { };
 

From 8961dc3b0a6ba7d85d222bfd56e2b6c762d6dd16 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 21 Jul 2022 07:05:55 +0300
Subject: [PATCH 386/455] Bump GraphQL.SystemTextJson from 5.3.2 to 5.3.3
 (#426)

Bumps [GraphQL.SystemTextJson](https://github.com/graphql-dotnet/graphql-dotnet) from 5.3.2 to 5.3.3.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/5.3.2...5.3.3)

---
updated-dependencies:
- dependency-name: GraphQL.SystemTextJson
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 49a25c09..e04fc48f 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.NewtonsoftJson" Version="5.3.2" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="5.3.2" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="5.3.3" />
   </ItemGroup>
 
   <ItemGroup>

From 04112cd9f31443b577e18dfef73508b5458152ae Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 21 Jul 2022 07:26:40 +0300
Subject: [PATCH 387/455] Bump GraphQL.NewtonsoftJson from 5.3.2 to 5.3.3
 (#425)

Bumps [GraphQL.NewtonsoftJson](https://github.com/graphql-dotnet/graphql-dotnet) from 5.3.2 to 5.3.3.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/5.3.2...5.3.3)

---
updated-dependencies:
- dependency-name: GraphQL.NewtonsoftJson
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Ivan Maximov <sungam3r@yandex.ru>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index e04fc48f..2e15b077 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="5.3.2" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="5.3.3" />
     <PackageReference Include="GraphQL.SystemTextJson" Version="5.3.3" />
   </ItemGroup>
 

From 758ede0e1773dafc9f9c662e495e89fe852a9786 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Thu, 21 Jul 2022 09:05:27 +0300
Subject: [PATCH 388/455] Convert to file-scoped namespaces, no code changes
 (#428)

---
 .editorconfig                                 |   17 +-
 .../PersonAndFilmsResponse.cs                 |   27 +-
 examples/GraphQL.Client.Example/Program.cs    |   49 +-
 .../GraphQLWebSocketMessageType.cs            |  149 ++-
 .../GraphQLWebSocketRequest.cs                |  173 ++-
 .../GraphQLWebSocketResponse.cs               |  143 ++-
 .../GraphQLWebsocketConnectionState.cs        |   13 +-
 .../IGraphQLWebsocketJsonSerializer.cs        |   21 +-
 .../WebsocketMessageWrapper.cs                |   11 +-
 .../GraphQLClientExtensions.cs                |   83 +-
 .../GraphQLJsonSerializerExtensions.cs        |   19 +-
 .../IGraphQLClient.cs                         |   49 +-
 .../IGraphQLJsonSerializer.cs                 |   11 +-
 .../Utilities/StringExtensions.cs             |   37 +-
 .../Utilities/StringUtils.cs                  |  347 +++---
 .../GraphQLLocalExecutionClient.cs            |  145 ++-
 .../ServiceCollectionExtensions.cs            |   15 +-
 .../ConstantCaseEnumConverter.cs              |   37 +-
 .../MapConverter.cs                           |   89 +-
 .../NewtonsoftJsonSerializer.cs               |   71 +-
 .../ConstantCaseJsonNamingPolicy.cs           |    9 +-
 .../ConverterHelperExtensions.cs              |   47 +-
 .../ErrorPathConverter.cs                     |   67 +-
 .../ImmutableConverter.cs                     |  273 +++--
 .../JsonSerializerOptionsExtensions.cs        |   13 +-
 .../MapConverter.cs                           |  117 +-
 .../SystemTextJsonSerializer.cs               |   61 +-
 src/GraphQL.Client/GraphQLHttpClient.cs       |  271 ++--
 .../GraphQLHttpClientExtensions.cs            |   73 +-
 .../GraphQLHttpClientOptions.cs               |  111 +-
 src/GraphQL.Client/GraphQLHttpRequest.cs      |   63 +-
 .../GraphQLHttpRequestException.cs            |   56 +-
 src/GraphQL.Client/GraphQLHttpResponse.cs     |   49 +-
 .../GraphQLSubscriptionException.cs           |   41 +-
 src/GraphQL.Client/UriExtensions.cs           |   61 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 1085 ++++++++---------
 .../GraphQLWebsocketConnectionException.cs    |   29 +-
 src/GraphQL.Primitives/ErrorPath.cs           |   15 +-
 src/GraphQL.Primitives/GraphQLError.cs        |  179 ++-
 src/GraphQL.Primitives/GraphQLLocation.cs     |  107 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |  191 ++-
 src/GraphQL.Primitives/GraphQLResponse.cs     |  123 +-
 src/GraphQL.Primitives/IGraphQLResponse.cs    |   13 +-
 src/GraphQL.Primitives/Map.cs                 |   13 +-
 .../BaseSerializeNoCamelCaseTest.cs           |   89 +-
 .../BaseSerializerTest.cs                     |  255 ++--
 .../ConsistencyTests.cs                       |   55 +-
 .../NewtonsoftSerializerTest.cs               |   21 +-
 .../SystemTextJsonSerializerTests.cs          |   21 +-
 .../TestData/DeserializeResponseTestData.cs   |  169 ++-
 .../TestData/SerializeToBytesTestData.cs      |   45 +-
 .../TestData/SerializeToStringTestData.cs     |   61 +-
 .../Chat/AddMessageMutationResult.cs          |   15 +-
 .../Chat/AddMessageVariables.cs               |   19 +-
 .../Chat/GraphQLClientChatExtensions.cs       |   49 +-
 .../Chat/JoinDeveloperMutationResult.cs       |   17 +-
 .../Chat/Schema/CapitalizedFieldsGraphType.cs |   17 +-
 .../Chat/Schema/ChatMutation.cs               |   63 +-
 .../Chat/Schema/ChatQuery.cs                  |   73 +-
 .../Chat/Schema/ChatSchema.cs                 |   17 +-
 .../Chat/Schema/ChatSubscriptions.cs          |  147 ++-
 .../Chat/Schema/IChat.cs                      |  155 ++-
 .../Chat/Schema/Message.cs                    |   15 +-
 .../Chat/Schema/MessageFrom.cs                |   11 +-
 .../Chat/Schema/MessageFromType.cs            |   13 +-
 .../Chat/Schema/MessageType.cs                |   27 +-
 .../Chat/Schema/ReceivedMessage.cs            |   13 +-
 tests/GraphQL.Client.Tests.Common/Common.cs   |   83 +-
 .../Helpers/AvailableJsonSerializers.cs       |   29 +-
 .../Helpers/CallbackMonitor.cs                |  139 ++-
 .../Helpers/ConcurrentTaskWrapper.cs          |   75 +-
 .../Helpers/MiscellaneousExtensions.cs        |   33 +-
 .../Helpers/NetworkHelpers.cs                 |   19 +-
 .../ResolveFieldContextExtensions.cs          |   89 +-
 .../StarWars/StarWarsData.cs                  |  139 ++-
 .../StarWars/StarWarsMutation.cs              |   55 +-
 .../StarWars/StarWarsQuery.cs                 |   43 +-
 .../StarWars/StarWarsSchema.cs                |   17 +-
 .../StarWars/TestData/StarWarsHumans.cs       |   23 +-
 .../StarWars/Types/CharacterInterface.cs      |   21 +-
 .../StarWars/Types/DroidType.cs               |   35 +-
 .../StarWars/Types/EpisodeEnum.cs             |   31 +-
 .../StarWars/Types/HumanInputType.cs          |   15 +-
 .../StarWars/Types/HumanType.cs               |   33 +-
 .../StarWars/Types/StarWarsCharacter.cs       |   33 +-
 .../Helpers/IntegrationServerTestFixture.cs   |   91 +-
 .../Helpers/WebHostHelpers.cs                 |   87 +-
 .../QueryAndMutationTests/Base.cs             |  295 +++--
 .../QueryAndMutationTests/Newtonsoft.cs       |    9 +-
 .../QueryAndMutationTests/SystemTextJson.cs   |    9 +-
 .../UriExtensionTests.cs                      |   67 +-
 .../WebsocketTests/Base.cs                    |  751 ++++++------
 .../WebsocketTests/Newtonsoft.cs              |    9 +-
 .../WebsocketTests/SystemTextJson.cs          |    9 +-
 .../GraphQLLocationTest.cs                    |  111 +-
 .../GraphQLRequestTest.cs                     |  307 +++--
 .../GraphQLResponseTest.cs                    |  189 ++-
 .../JsonSerializationTests.cs                 |   43 +-
 .../GraphQL/Models/Repository.cs              |   37 +-
 tests/GraphQL.Server.Test/GraphQL/Storage.cs  |   27 +-
 .../GraphQL/TestMutation.cs                   |    9 +-
 .../GraphQL.Server.Test/GraphQL/TestQuery.cs  |   19 +-
 .../GraphQL.Server.Test/GraphQL/TestSchema.cs |   15 +-
 .../GraphQL/TestSubscription.cs               |    9 +-
 tests/GraphQL.Server.Test/Program.cs          |   19 +-
 tests/GraphQL.Server.Test/Startup.cs          |   45 +-
 tests/IntegrationTestServer/Program.cs        |   17 +-
 tests/IntegrationTestServer/Startup.cs        |  101 +-
 108 files changed, 4511 insertions(+), 4616 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index 33d7fdc4..b3d87c9d 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -35,7 +35,7 @@ insert_final_newline = false
 
 # Code files
 [*.{cs,vb}]
- 
+
 # .NET code style settings - "This." and "Me." qualifiers
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#this-and-me
 dotnet_style_qualification_for_field = false:warning
@@ -194,22 +194,25 @@ csharp_space_between_square_brackets = false
 csharp_preserve_single_line_blocks = true
 csharp_preserve_single_line_statements = false
 
+# C# formatting settings - Namespace options
+csharp_style_namespace_declarations = file_scoped:suggestion
+
 ########## name all private fields using camelCase with underscore prefix ##########
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions?view=vs-2019
 # dotnet_naming_rule.<namingRuleTitle>.symbols = <symbolTitle>
 dotnet_naming_rule.private_fields_with_underscore.symbols = private_fields
- 
+
 # dotnet_naming_symbols.<symbolTitle>.<property> = <value>
 dotnet_naming_symbols.private_fields.applicable_kinds = field
 dotnet_naming_symbols.private_fields.applicable_accessibilities = private
- 
+
 # dotnet_naming_rule.<namingRuleTitle>.style = <styleTitle>
 dotnet_naming_rule.private_fields_with_underscore.style = prefix_underscore
- 
+
 # dotnet_naming_style.<styleTitle>.<property> = <value>
 dotnet_naming_style.prefix_underscore.capitalization = camel_case
 dotnet_naming_style.prefix_underscore.required_prefix = _
- 
+
 # dotnet_naming_rule.<namingRuleTitle>.severity = <value>
 dotnet_naming_rule.private_fields_with_underscore.severity = warning
 
@@ -248,8 +251,8 @@ dotnet_naming_rule.async_methods_end_in_async.style = end_in_async_style
 
 # dotnet_naming_style.<styleTitle>.<property> = <value>
 dotnet_naming_style.end_in_async_style.capitalization = pascal_case
-dotnet_naming_style.end_in_async_style.word_separator = 
-dotnet_naming_style.end_in_async_style.required_prefix = 
+dotnet_naming_style.end_in_async_style.word_separator =
+dotnet_naming_style.end_in_async_style.required_prefix =
 dotnet_naming_style.end_in_async_style.required_suffix = Async
 
 # dotnet_naming_rule.<namingRuleTitle>.severity = <value>
diff --git a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
index eafba6d1..7dbd22b5 100644
--- a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
+++ b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
@@ -1,25 +1,24 @@
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Example
+namespace GraphQL.Client.Example;
+
+public class PersonAndFilmsResponse
 {
-    public class PersonAndFilmsResponse
+    public PersonContent Person { get; set; }
+
+    public class PersonContent
     {
-        public PersonContent Person { get; set; }
+        public string Name { get; set; }
 
-        public class PersonContent
-        {
-            public string Name { get; set; }
+        public FilmConnectionContent FilmConnection { get; set; }
 
-            public FilmConnectionContent FilmConnection { get; set; }
+        public class FilmConnectionContent
+        {
+            public List<FilmContent> Films { get; set; }
 
-            public class FilmConnectionContent
+            public class FilmContent
             {
-                public List<FilmContent> Films { get; set; }
-
-                public class FilmContent
-                {
-                    public string Title { get; set; }
-                }
+                public string Title { get; set; }
             }
         }
     }
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index a67114a1..b1f4d2ac 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -5,17 +5,17 @@
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
 
-namespace GraphQL.Client.Example
+namespace GraphQL.Client.Example;
+
+public static class Program
 {
-    public static class Program
+    public static async Task Main()
     {
-        public static async Task Main()
-        {
-            using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
+        using var graphQLClient = new GraphQLHttpClient("https://swapi.apis.guru/", new NewtonsoftJsonSerializer());
 
-            var personAndFilmsRequest = new GraphQLRequest
-            {
-                Query = @"
+        var personAndFilmsRequest = new GraphQLRequest
+        {
+            Query = @"
 			    query PersonAndFilms($id: ID) {
 			        person(id: $id) {
 			            name
@@ -26,25 +26,24 @@ query PersonAndFilms($id: ID) {
 			            }
 			        }
 			    }",
-                OperationName = "PersonAndFilms",
-                Variables = new
-                {
-                    id = "cGVvcGxlOjE="
-                }
-            };
+            OperationName = "PersonAndFilms",
+            Variables = new
+            {
+                id = "cGVvcGxlOjE="
+            }
+        };
 
-            var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
-            Console.WriteLine("raw response:");
-            Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
+        var graphQLResponse = await graphQLClient.SendQueryAsync<PersonAndFilmsResponse>(personAndFilmsRequest);
+        Console.WriteLine("raw response:");
+        Console.WriteLine(JsonSerializer.Serialize(graphQLResponse, new JsonSerializerOptions { WriteIndented = true }));
 
-            Console.WriteLine();
-            Console.WriteLine($"Name: {graphQLResponse.Data.Person.Name}");
-            var films = string.Join(", ", graphQLResponse.Data.Person.FilmConnection.Films.Select(f => f.Title));
-            Console.WriteLine($"Films: {films}");
+        Console.WriteLine();
+        Console.WriteLine($"Name: {graphQLResponse.Data.Person.Name}");
+        var films = string.Join(", ", graphQLResponse.Data.Person.FilmConnection.Films.Select(f => f.Title));
+        Console.WriteLine($"Films: {films}");
 
-            Console.WriteLine();
-            Console.WriteLine("Press any key to quit...");
-            Console.ReadKey();
-        }
+        Console.WriteLine();
+        Console.WriteLine("Press any key to quit...");
+        Console.ReadKey();
     }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
index 3b0e0499..16125a71 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
@@ -1,87 +1,86 @@
-namespace GraphQL.Client.Abstractions.Websocket
+namespace GraphQL.Client.Abstractions.Websocket;
+
+public static class GraphQLWebSocketMessageType
 {
-    public static class GraphQLWebSocketMessageType
-    {
 
-        /// <summary>
-        ///     Client sends this message after plain websocket connection to start the communication with the server
-        ///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
-        ///     to this message.
-        ///     payload: Object : optional parameters that the client specifies in connectionParams
-        /// </summary>
-        public const string GQL_CONNECTION_INIT = "connection_init";
+    /// <summary>
+    ///     Client sends this message after plain websocket connection to start the communication with the server
+    ///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+    ///     to this message.
+    ///     payload: Object : optional parameters that the client specifies in connectionParams
+    /// </summary>
+    public const string GQL_CONNECTION_INIT = "connection_init";
 
-        /// <summary>
-        ///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
-        ///     the connection.
-        /// </summary>
-        public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+    /// <summary>
+    ///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+    ///     the connection.
+    /// </summary>
+    public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
 
-        /// <summary>
-        ///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
-        ///     the connection.
-        ///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
-        ///     client, just ignore the message).
-        ///     payload: Object: the server side error
-        /// </summary>
-        public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+    /// <summary>
+    ///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+    ///     the connection.
+    ///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+    ///     client, just ignore the message).
+    ///     payload: Object: the server side error
+    /// </summary>
+    public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
 
-        /// <summary>
-        ///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
-        ///     client connection alive.
-        ///     The client starts to consider the keep alive message only upon the first received keep alive message from the
-        ///     server.
-        ///     <remarks>
-        ///         NOTE: This one here don't follow the standard due to connection optimization
-        ///     </remarks>
-        /// </summary>
-        public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+    /// <summary>
+    ///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+    ///     client connection alive.
+    ///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+    ///     server.
+    ///     <remarks>
+    ///         NOTE: This one here don't follow the standard due to connection optimization
+    ///     </remarks>
+    /// </summary>
+    public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
 
-        /// <summary>
-        ///     Client sends this message to terminate the connection.
-        /// </summary>
-        public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+    /// <summary>
+    ///     Client sends this message to terminate the connection.
+    /// </summary>
+    public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
 
-        /// <summary>
-        ///     Client sends this message to execute GraphQL operation
-        ///     id: string : The id of the GraphQL operation to start
-        ///     payload: Object:
-        ///     query: string : GraphQL operation as string or parsed GraphQL document node
-        ///     variables?: Object : Object with GraphQL variables
-        ///     operationName?: string : GraphQL operation name
-        /// </summary>
-        public const string GQL_START = "start";
+    /// <summary>
+    ///     Client sends this message to execute GraphQL operation
+    ///     id: string : The id of the GraphQL operation to start
+    ///     payload: Object:
+    ///     query: string : GraphQL operation as string or parsed GraphQL document node
+    ///     variables?: Object : Object with GraphQL variables
+    ///     operationName?: string : GraphQL operation name
+    /// </summary>
+    public const string GQL_START = "start";
 
-        /// <summary>
-        ///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
-        ///     is a response for GQL_START message.
-        ///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
-        ///     id: string : ID of the operation that was successfully set up
-        ///     payload: Object :
-        ///     data: any: Execution result
-        ///     errors?: Error[] : Array of resolvers errors
-        /// </summary>
-        public const string GQL_DATA = "data"; // Server -> Client
+    /// <summary>
+    ///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+    ///     is a response for GQL_START message.
+    ///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+    ///     id: string : ID of the operation that was successfully set up
+    ///     payload: Object :
+    ///     data: any: Execution result
+    ///     errors?: Error[] : Array of resolvers errors
+    /// </summary>
+    public const string GQL_DATA = "data"; // Server -> Client
 
-        /// <summary>
-        ///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
-        ///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
-        ///     payload: Error : payload with the error attributed to the operation failing on the server
-        ///     id: string : operation ID of the operation that failed on the server
-        /// </summary>
-        public const string GQL_ERROR = "error"; // Server -> Client
+    /// <summary>
+    ///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+    ///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+    ///     payload: Error : payload with the error attributed to the operation failing on the server
+    ///     id: string : operation ID of the operation that failed on the server
+    /// </summary>
+    public const string GQL_ERROR = "error"; // Server -> Client
 
-        /// <summary>
-        ///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-        ///     specific operation.
-        ///     id: string : operation ID of the operation that completed
-        /// </summary>
-        public const string GQL_COMPLETE = "complete"; // Server -> Client
+    /// <summary>
+    ///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+    ///     specific operation.
+    ///     id: string : operation ID of the operation that completed
+    /// </summary>
+    public const string GQL_COMPLETE = "complete"; // Server -> Client
 
-        /// <summary>
-        ///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
-        ///     id: string : operation id
-        /// </summary>
-        public const string GQL_STOP = "stop"; // Client -> Server
-    }
+    /// <summary>
+    ///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+    ///     id: string : operation id
+    /// </summary>
+    public const string GQL_STOP = "stop"; // Client -> Server
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
index 1210c34a..69c8593e 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketRequest.cs
@@ -1,108 +1,107 @@
-namespace GraphQL.Client.Abstractions.Websocket
+namespace GraphQL.Client.Abstractions.Websocket;
+
+/// <summary>
+/// A Subscription Request
+/// </summary>
+public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<GraphQLWebSocketRequest>
 {
+    public const string ID_KEY = "id";
+    public const string TYPE_KEY = "type";
+    public const string PAYLOAD_KEY = "payload";
+
     /// <summary>
-    /// A Subscription Request
+    /// The Identifier of the request
     /// </summary>
-    public class GraphQLWebSocketRequest : Dictionary<string, object>, IEquatable<GraphQLWebSocketRequest>
+    public string Id
     {
-        public const string ID_KEY = "id";
-        public const string TYPE_KEY = "type";
-        public const string PAYLOAD_KEY = "payload";
-
-        /// <summary>
-        /// The Identifier of the request
-        /// </summary>
-        public string Id
-        {
-            get => TryGetValue(ID_KEY, out object value) ? (string)value : null;
-            set => this[ID_KEY] = value;
-        }
+        get => TryGetValue(ID_KEY, out object value) ? (string)value : null;
+        set => this[ID_KEY] = value;
+    }
 
-        /// <summary>
-        /// The Type of the Request
-        /// </summary>
-        public string Type
-        {
-            get => TryGetValue(TYPE_KEY, out object value) ? (string)value : null;
-            set => this[TYPE_KEY] = value;
-        }
+    /// <summary>
+    /// The Type of the Request
+    /// </summary>
+    public string Type
+    {
+        get => TryGetValue(TYPE_KEY, out object value) ? (string)value : null;
+        set => this[TYPE_KEY] = value;
+    }
 
-        /// <summary>
-        /// The payload of the websocket request
-        /// </summary>
-        public object? Payload
-        {
-            get => TryGetValue(PAYLOAD_KEY, out object value) ? value : null;
-            set => this[PAYLOAD_KEY] = value;
-        }
+    /// <summary>
+    /// The payload of the websocket request
+    /// </summary>
+    public object? Payload
+    {
+        get => TryGetValue(PAYLOAD_KEY, out object value) ? value : null;
+        set => this[PAYLOAD_KEY] = value;
+    }
 
-        private readonly TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
+    private readonly TaskCompletionSource<bool> _tcs = new TaskCompletionSource<bool>();
 
-        /// <summary>
-        /// Task used to await the actual send operation and to convey potential exceptions
-        /// </summary>
-        /// <returns></returns>
-        public Task SendTask() => _tcs.Task;
+    /// <summary>
+    /// Task used to await the actual send operation and to convey potential exceptions
+    /// </summary>
+    /// <returns></returns>
+    public Task SendTask() => _tcs.Task;
 
-        /// <summary>
-        /// gets called when the send operation for this request has completed successfully
-        /// </summary>
-        public void SendCompleted() => _tcs.SetResult(true);
+    /// <summary>
+    /// gets called when the send operation for this request has completed successfully
+    /// </summary>
+    public void SendCompleted() => _tcs.SetResult(true);
 
-        /// <summary>
-        /// gets called when an exception occurs during the send operation
-        /// </summary>
-        /// <param name="e"></param>
-        public void SendFailed(Exception e) => _tcs.SetException(e);
+    /// <summary>
+    /// gets called when an exception occurs during the send operation
+    /// </summary>
+    /// <param name="e"></param>
+    public void SendFailed(Exception e) => _tcs.SetException(e);
 
-        /// <summary>
-        /// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
-        /// </summary>
-        public void SendCanceled() => _tcs.SetCanceled();
+    /// <summary>
+    /// gets called when the GraphQLHttpWebSocket has been disposed before the send operation for this request has started
+    /// </summary>
+    public void SendCanceled() => _tcs.SetCanceled();
 
-        /// <inheritdoc />
-        public override bool Equals(object obj) => Equals(obj as GraphQLWebSocketRequest);
+    /// <inheritdoc />
+    public override bool Equals(object obj) => Equals(obj as GraphQLWebSocketRequest);
 
-        /// <inheritdoc />
-        public bool Equals(GraphQLWebSocketRequest other)
+    /// <inheritdoc />
+    public bool Equals(GraphQLWebSocketRequest other)
+    {
+        if (other == null)
+        {
+            return false;
+        }
+        if (ReferenceEquals(this, other))
         {
-            if (other == null)
-            {
-                return false;
-            }
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-            if (!Equals(Id, other.Id))
-            {
-                return false;
-            }
-            if (!Equals(Type, other.Type))
-            {
-                return false;
-            }
-            if (!Equals(Payload, other.Payload))
-            {
-                return false;
-            }
             return true;
         }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
+        if (!Equals(Id, other.Id))
         {
-            var hashCode = 9958074;
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Id);
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Type);
-            hashCode = hashCode * -1521134295 + EqualityComparer<object>.Default.GetHashCode(Payload);
-            return hashCode;
+            return false;
         }
+        if (!Equals(Type, other.Type))
+        {
+            return false;
+        }
+        if (!Equals(Payload, other.Payload))
+        {
+            return false;
+        }
+        return true;
+    }
 
-        /// <inheritdoc />
-        public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
-
-        /// <inheritdoc />
-        public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
+    /// <inheritdoc />
+    public override int GetHashCode()
+    {
+        var hashCode = 9958074;
+        hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Id);
+        hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Type);
+        hashCode = hashCode * -1521134295 + EqualityComparer<object>.Default.GetHashCode(Payload);
+        return hashCode;
     }
+
+    /// <inheritdoc />
+    public static bool operator ==(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => EqualityComparer<GraphQLWebSocketRequest>.Default.Equals(request1, request2);
+
+    /// <inheritdoc />
+    public static bool operator !=(GraphQLWebSocketRequest request1, GraphQLWebSocketRequest request2) => !(request1 == request2);
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
index 5de56492..f1241fbc 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketResponse.cs
@@ -1,97 +1,96 @@
-namespace GraphQL.Client.Abstractions.Websocket
+namespace GraphQL.Client.Abstractions.Websocket;
+
+/// <summary>
+/// A Subscription Response
+/// </summary>
+public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse>
 {
     /// <summary>
-    /// A Subscription Response
+    /// The Identifier of the Response
     /// </summary>
-    public class GraphQLWebSocketResponse : IEquatable<GraphQLWebSocketResponse>
-    {
-        /// <summary>
-        /// The Identifier of the Response
-        /// </summary>
-        public string Id { get; set; }
+    public string Id { get; set; }
 
-        /// <summary>
-        /// The Type of the Response
-        /// </summary>
-        public string Type { get; set; }
+    /// <summary>
+    /// The Type of the Response
+    /// </summary>
+    public string Type { get; set; }
 
-        /// <inheritdoc />
-        public override bool Equals(object obj) => Equals(obj as GraphQLWebSocketResponse);
+    /// <inheritdoc />
+    public override bool Equals(object obj) => Equals(obj as GraphQLWebSocketResponse);
 
-        /// <inheritdoc />
-        public bool Equals(GraphQLWebSocketResponse other)
+    /// <inheritdoc />
+    public bool Equals(GraphQLWebSocketResponse other)
+    {
+        if (other == null)
         {
-            if (other == null)
-            {
-                return false;
-            }
-
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            if (!Equals(Id, other.Id))
-            {
-                return false;
-            }
-
-            if (!Equals(Type, other.Type))
-            {
-                return false;
-            }
+            return false;
+        }
 
+        if (ReferenceEquals(this, other))
+        {
             return true;
         }
 
-        /// <inheritdoc />
-        public override int GetHashCode()
+        if (!Equals(Id, other.Id))
         {
-            var hashCode = 9958074;
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Id);
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Type);
-            return hashCode;
+            return false;
         }
 
-        /// <inheritdoc />
-        public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
-            EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
+        if (!Equals(Type, other.Type))
+        {
+            return false;
+        }
 
-        /// <inheritdoc />
-        public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
-            !(response1 == response2);
+        return true;
     }
 
-    public class GraphQLWebSocketResponse<TPayload> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TPayload>>
+    /// <inheritdoc />
+    public override int GetHashCode()
     {
-        public TPayload Payload { get; set; }
+        var hashCode = 9958074;
+        hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Id);
+        hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Type);
+        return hashCode;
+    }
 
-        public bool Equals(GraphQLWebSocketResponse<TPayload>? other)
-        {
-            if (other is null)
-                return false;
-            if (ReferenceEquals(this, other))
-                return true;
-            return base.Equals(other) && Payload.Equals(other.Payload);
-        }
+    /// <inheritdoc />
+    public static bool operator ==(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
+        EqualityComparer<GraphQLWebSocketResponse>.Default.Equals(response1, response2);
 
-        public override bool Equals(object? obj)
-        {
-            if (obj is null)
-                return false;
-            if (ReferenceEquals(this, obj))
-                return true;
-            if (obj.GetType() != GetType())
-                return false;
-            return Equals((GraphQLWebSocketResponse<TPayload>)obj);
-        }
+    /// <inheritdoc />
+    public static bool operator !=(GraphQLWebSocketResponse response1, GraphQLWebSocketResponse response2) =>
+        !(response1 == response2);
+}
+
+public class GraphQLWebSocketResponse<TPayload> : GraphQLWebSocketResponse, IEquatable<GraphQLWebSocketResponse<TPayload>>
+{
+    public TPayload Payload { get; set; }
+
+    public bool Equals(GraphQLWebSocketResponse<TPayload>? other)
+    {
+        if (other is null)
+            return false;
+        if (ReferenceEquals(this, other))
+            return true;
+        return base.Equals(other) && Payload.Equals(other.Payload);
+    }
 
-        public override int GetHashCode()
+    public override bool Equals(object? obj)
+    {
+        if (obj is null)
+            return false;
+        if (ReferenceEquals(this, obj))
+            return true;
+        if (obj.GetType() != GetType())
+            return false;
+        return Equals((GraphQLWebSocketResponse<TPayload>)obj);
+    }
+
+    public override int GetHashCode()
+    {
+        unchecked
         {
-            unchecked
-            {
-                return (base.GetHashCode() * 397) ^ Payload.GetHashCode();
-            }
+            return (base.GetHashCode() * 397) ^ Payload.GetHashCode();
         }
     }
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
index c5fd3107..e12957a1 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebsocketConnectionState.cs
@@ -1,11 +1,10 @@
-namespace GraphQL.Client.Abstractions.Websocket
+namespace GraphQL.Client.Abstractions.Websocket;
+
+public enum GraphQLWebsocketConnectionState
 {
-    public enum GraphQLWebsocketConnectionState
-    {
-        Disconnected,
+    Disconnected,
 
-        Connecting,
+    Connecting,
 
-        Connected
-    }
+    Connected
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index 4526d797..f7c4a2bf 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -1,15 +1,14 @@
-namespace GraphQL.Client.Abstractions.Websocket
+namespace GraphQL.Client.Abstractions.Websocket;
+
+/// <summary>
+/// The json serializer interface for the graphql-dotnet http client.
+/// Implementations should provide a parameterless constructor for convenient usage
+/// </summary>
+public interface IGraphQLWebsocketJsonSerializer : IGraphQLJsonSerializer
 {
-    /// <summary>
-    /// The json serializer interface for the graphql-dotnet http client.
-    /// Implementations should provide a parameterless constructor for convenient usage
-    /// </summary>
-    public interface IGraphQLWebsocketJsonSerializer : IGraphQLJsonSerializer
-    {
-        byte[] SerializeToBytes(GraphQLWebSocketRequest request);
+    byte[] SerializeToBytes(GraphQLWebSocketRequest request);
 
-        Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
+    Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
 
-        GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
-    }
+    GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs b/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
index e7ca0ab8..a94cb8a6 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/WebsocketMessageWrapper.cs
@@ -1,11 +1,10 @@
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Abstractions.Websocket
+namespace GraphQL.Client.Abstractions.Websocket;
+
+public class WebsocketMessageWrapper : GraphQLWebSocketResponse
 {
-    public class WebsocketMessageWrapper : GraphQLWebSocketResponse
-    {
 
-        [IgnoreDataMember]
-        public byte[] MessageBytes { get; set; }
-    }
+    [IgnoreDataMember]
+    public byte[] MessageBytes { get; set; }
 }
diff --git a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index 379eb932..e27d1a9a 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -1,51 +1,50 @@
-namespace GraphQL.Client.Abstractions
+namespace GraphQL.Client.Abstractions;
+
+public static class GraphQLClientExtensions
 {
-    public static class GraphQLClientExtensions
+    public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
+        string query, object? variables = null,
+        string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
     {
-        public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
-            string query, object? variables = null,
-            string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
-        {
-            _ = defineResponseType;
-            return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
-                cancellationToken: cancellationToken);
-        }
+        _ = defineResponseType;
+        return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
+            cancellationToken: cancellationToken);
+    }
 
-        public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
-            string query, object? variables = null,
-            string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
-        {
-            _ = defineResponseType;
-            return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
-                cancellationToken: cancellationToken);
-        }
+    public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
+        string query, object? variables = null,
+        string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
+    {
+        _ = defineResponseType;
+        return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
+            cancellationToken: cancellationToken);
+    }
 
-        public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
-            GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-        {
-            _ = defineResponseType;
-            return client.SendQueryAsync<TResponse>(request, cancellationToken);
-        }
+    public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
+        GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+    {
+        _ = defineResponseType;
+        return client.SendQueryAsync<TResponse>(request, cancellationToken);
+    }
 
-        public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
-            GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
-        {
-            _ = defineResponseType;
-            return client.SendMutationAsync<TResponse>(request, cancellationToken);
-        }
+    public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
+        GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
+    {
+        _ = defineResponseType;
+        return client.SendMutationAsync<TResponse>(request, cancellationToken);
+    }
 
-        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
-        {
-            _ = defineResponseType;
-            return client.CreateSubscriptionStream<TResponse>(request);
-        }
+    public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+        this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
+    {
+        _ = defineResponseType;
+        return client.CreateSubscriptionStream<TResponse>(request);
+    }
 
-        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<Exception> exceptionHandler)
-        {
-            _ = defineResponseType;
-            return client.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
-        }
+    public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+        this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<Exception> exceptionHandler)
+    {
+        _ = defineResponseType;
+        return client.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
     }
 }
diff --git a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
index 56ff68e6..248f594a 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLJsonSerializerExtensions.cs
@@ -1,14 +1,13 @@
-namespace GraphQL.Client.Abstractions
+namespace GraphQL.Client.Abstractions;
+
+public static class GraphQLJsonSerializerExtensions
 {
-    public static class GraphQLJsonSerializerExtensions
-    {
-        public static TOptions New<TOptions>(this Action<TOptions> configure) =>
-            configure.AndReturn(Activator.CreateInstance<TOptions>());
+    public static TOptions New<TOptions>(this Action<TOptions> configure) =>
+        configure.AndReturn(Activator.CreateInstance<TOptions>());
 
-        public static TOptions AndReturn<TOptions>(this Action<TOptions> configure, TOptions options)
-        {
-            configure(options);
-            return options;
-        }
+    public static TOptions AndReturn<TOptions>(this Action<TOptions> configure, TOptions options)
+    {
+        configure(options);
+        return options;
     }
 }
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
index f289786b..e868a20e 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLClient.cs
@@ -1,32 +1,31 @@
 using System.Net.WebSockets;
 
-namespace GraphQL.Client.Abstractions
+namespace GraphQL.Client.Abstractions;
+
+public interface IGraphQLClient
 {
-    public interface IGraphQLClient
-    {
-        Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
+    Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
-        Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
+    Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default);
 
-        /// <summary>
-        /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-        /// All subscriptions made to this stream share the same hot observable.<br/>
-        /// The stream must be recreated completely after an error has occurred within its logic (i.e. a <see cref="WebSocketException"/>)
-        /// </summary>
-        /// <param name="request">the GraphQL request for this subscription</param>
-        /// <returns>an observable stream for the specified subscription</returns>
-        IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request);
+    /// <summary>
+    /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+    /// All subscriptions made to this stream share the same hot observable.<br/>
+    /// The stream must be recreated completely after an error has occurred within its logic (i.e. a <see cref="WebSocketException"/>)
+    /// </summary>
+    /// <param name="request">the GraphQL request for this subscription</param>
+    /// <returns>an observable stream for the specified subscription</returns>
+    IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request);
 
-        /// <summary>
-        /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-        /// All subscriptions made to this stream share the same hot observable.<br/>
-        /// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
-        /// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-        /// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
-        /// </summary>
-        /// <param name="request">the GraphQL request for this subscription</param>
-        /// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occurring within the sequence</param>
-        /// <returns>an observable stream for the specified subscription</returns>
-        IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler);
-    }
+    /// <summary>
+    /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+    /// All subscriptions made to this stream share the same hot observable.<br/>
+    /// All <see cref="Exception"/>s are passed to the <paramref name="exceptionHandler"/> to be handled externally.<br/>
+    /// If the <paramref name="exceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+    /// Any exception thrown by <paramref name="exceptionHandler"/> will cause the sequence to fail.
+    /// </summary>
+    /// <param name="request">the GraphQL request for this subscription</param>
+    /// <param name="exceptionHandler">an external handler for all <see cref="Exception"/>s occurring within the sequence</param>
+    /// <returns>an observable stream for the specified subscription</returns>
+    IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception> exceptionHandler);
 }
diff --git a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
index 9f5f9410..28690947 100644
--- a/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions/IGraphQLJsonSerializer.cs
@@ -1,9 +1,8 @@
-namespace GraphQL.Client.Abstractions
+namespace GraphQL.Client.Abstractions;
+
+public interface IGraphQLJsonSerializer
 {
-    public interface IGraphQLJsonSerializer
-    {
-        string SerializeToString(GraphQLRequest request);
+    string SerializeToString(GraphQLRequest request);
 
-        Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken);
-    }
+    Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken);
 }
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
index 8aeb4cb0..f751adb8 100644
--- a/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
@@ -1,35 +1,34 @@
-namespace GraphQL.Client.Abstractions.Utilities
+namespace GraphQL.Client.Abstractions.Utilities;
+
+/// <summary>
+/// Copied from https://github.com/jquense/StringUtils
+/// </summary>
+public static class StringExtensions
 {
-    /// <summary>
-    /// Copied from https://github.com/jquense/StringUtils
-    /// </summary>
-    public static class StringExtensions
-    {
-        public static string StripIndent(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.StripIndent(str);
+    public static string StripIndent(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.StripIndent(str);
 
-        public static IEnumerable<string> ToWords(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToWords(str);
+    public static IEnumerable<string> ToWords(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToWords(str);
 
-        public static string ToUpperFirst(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToUpperFirst(str);
+    public static string ToUpperFirst(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToUpperFirst(str);
 
-        public static string ToLowerFirst(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToLowerFirst(str);
+    public static string ToLowerFirst(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToLowerFirst(str);
 
-        public static string Capitalize(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.Capitalize(str);
+    public static string Capitalize(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.Capitalize(str);
 
-        public static string ToCamelCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToCamelCase(str);
+    public static string ToCamelCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToCamelCase(str);
 
-        public static string ToConstantCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToConstantCase(str);
+    public static string ToConstantCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToConstantCase(str);
 
-        public static string ToUpperCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToUpperCase(str);
+    public static string ToUpperCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToUpperCase(str);
 
-        public static string ToLowerCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToLowerCase(str);
+    public static string ToLowerCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToLowerCase(str);
 
 
-        public static string ToPascalCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToPascalCase(str);
+    public static string ToPascalCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToPascalCase(str);
 
 
-        public static string ToKebabCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToKebabCase(str);
+    public static string ToKebabCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToKebabCase(str);
 
 
-        public static string ToSnakeCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToSnakeCase(str);
-    }
+    public static string ToSnakeCase(this string str) => GraphQL.Client.Abstractions.Utilities.StringUtils.ToSnakeCase(str);
 }
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
index 57673216..27fbf992 100644
--- a/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
@@ -1,190 +1,189 @@
 using System.Text.RegularExpressions;
 
-namespace GraphQL.Client.Abstractions.Utilities
+namespace GraphQL.Client.Abstractions.Utilities;
+
+/// <summary>
+/// Copied from https://github.com/jquense/StringUtils
+/// </summary>
+public static class StringUtils
 {
+    private static readonly Regex _reWords = new Regex(@"[A-Z\xc0-\xd6\xd8-\xde]?[a-z\xdf-\xf6\xf8-\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde]|$)|(?:[A-Z\xc0-\xd6\xd8-\xde]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde](?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])|$)|[A-Z\xc0-\xd6\xd8-\xde]?(?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\xc0-\xd6\xd8-\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\d+|(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?)*");
+    private static readonly Regex _reIndent = new Regex(@"^[ \t]*(?=\S)", RegexOptions.Multiline);
+
     /// <summary>
-    /// Copied from https://github.com/jquense/StringUtils
+    /// Removes the leading indent from a multi-line string
     /// </summary>
-    public static class StringUtils
+    /// <param name="str">String</param>
+    /// <returns></returns>
+    public static string StripIndent(string str)
     {
-        private static readonly Regex _reWords = new Regex(@"[A-Z\xc0-\xd6\xd8-\xde]?[a-z\xdf-\xf6\xf8-\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde]|$)|(?:[A-Z\xc0-\xd6\xd8-\xde]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde](?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])|$)|[A-Z\xc0-\xd6\xd8-\xde]?(?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\xc0-\xd6\xd8-\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\d+|(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?)*");
-        private static readonly Regex _reIndent = new Regex(@"^[ \t]*(?=\S)", RegexOptions.Multiline);
-
-        /// <summary>
-        /// Removes the leading indent from a multi-line string
-        /// </summary>
-        /// <param name="str">String</param>
-        /// <returns></returns>
-        public static string StripIndent(string str)
-        {
-            int indent = _reIndent.Matches(str).Cast<Match>().Select(m => m.Value.Length).Min();
-            return new Regex(@"^[ \t]{" + indent + "}", RegexOptions.Multiline).Replace(str, "");
-        }
+        int indent = _reIndent.Matches(str).Cast<Match>().Select(m => m.Value.Length).Min();
+        return new Regex(@"^[ \t]{" + indent + "}", RegexOptions.Multiline).Replace(str, "");
+    }
 
-        /// <summary>
-        /// Split a cased string into a series of "words" excluding the seperator.
-        /// </summary>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static IEnumerable<string> ToWords(string str)
+    /// <summary>
+    /// Split a cased string into a series of "words" excluding the seperator.
+    /// </summary>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static IEnumerable<string> ToWords(string str)
+    {
+        foreach (Match match in _reWords.Matches(str))
         {
-            foreach (Match match in _reWords.Matches(str))
-            {
-                yield return match.Value;
-            }
+            yield return match.Value;
         }
+    }
 
-        /// <summary>
-        /// Uppercase the first character in a string, leaving the rest of the string as is
-        /// </summary>
-        /// <param name="str"></param>
-        /// <returns>a string with the first character uppercased</returns>
-        public static string ToUpperFirst(string str) => ChangeCaseFirst(str, c => c.ToUpperInvariant());
-
-        /// <summary>
-        /// Lowercase the first character in a string, leaving the rest of the string as is
-        /// </summary>
-        /// <param name="str"></param>
-        /// <returns>a string with the first character lowercased</returns>
-        public static string ToLowerFirst(string str) => ChangeCaseFirst(str, c => c.ToLowerInvariant());
-
-        /// <summary>
-        /// Capitalizes a string, lowercasing the entire string and uppercasing the first character
-        /// </summary>
-        /// <param name="str"></param>
-        /// <returns>a capitalized string</returns>
-        public static string Capitalize(string str) => ToUpperFirst(str.ToLowerInvariant());
-
-        /// <summary>
-        /// Converts a string to camelCase.
-        /// </summary>
-        /// <example>
-        ///     <code>StringUtils.ToCamelCase("FOOBAR")  // "foobar"</code>
-        ///     <code>StringUtils.ToCamelCase("FOO_BAR") // "fooBar"</code>
-        ///     <code>StringUtils.ToCamelCase("FooBar")  // "fooBar"</code>
-        ///     <code>StringUtils.ToCamelCase("foo bar") // "fooBar"</code>
-        /// </example>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static string ToCamelCase(string str) =>
-            ChangeCase(str, (word, index) =>
-                (index == 0 ? word.ToLowerInvariant() : Capitalize(word)));
-
-        /// <summary>
-        /// Convert a string to CONSTANT_CASE
-        /// </summary>
-        /// <example>
-        ///     <code>StringUtils.ToConstantCase("fOo BaR") // "FOO_BAR"</code>
-        ///     <code>StringUtils.ToConstantCase("FooBar")  // "FOO_BAR"</code>
-        ///     <code>StringUtils.ToConstantCase("Foo Bar") // "FOO_BAR"</code>
-        /// </example>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static string ToConstantCase(string str) => ChangeCase(str, "_", w => w.ToUpperInvariant());
-
-        /// <summary>
-        /// Convert a string to UPPERCASE
-        /// </summary>
-        /// <example>
-        ///     <code>StringUtils.ToUpperCase("foobar")  // "FOOBAR"</code>
-        ///     <code>StringUtils.ToUpperCase("FOO_BAR") // "FOO BAR"</code>
-        ///     <code>StringUtils.ToUpperCase("FooBar")  // "FOO BAR"</code>
-        ///     <code>StringUtils.ToUpperCase("Foo Bar") // "FOO BAR"</code>
-        /// </example>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static string ToUpperCase(string str) => ChangeCase(str, " ", (word) => word.ToUpperInvariant());
-
-        /// <summary>
-        /// Convert a string to lowercase
-        /// </summary>
-        /// <example>
-        ///     <code>StringUtils.ToLowerCase("FOOBAR")  // "foobar"</code>
-        ///     <code>StringUtils.ToLowerCase("FOO_BAR") // "foo bar"</code>
-        ///     <code>StringUtils.ToLowerCase("FooBar")  // "foo bar"</code>
-        ///     <code>StringUtils.ToLowerCase("Foo Bar") // "foo bar"</code>
-        /// </example>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static string ToLowerCase(string str) => ChangeCase(str, " ", word => word.ToLowerInvariant());
-
-        /// <summary>
-        /// convert a string to PascalCase
-        /// </summary>
-        /// <example>
-        ///     <code>StringUtils.ToPascalCase("FOOBAR")  // "FooBar"</code>
-        ///     <code>StringUtils.ToPascalCase("FOO_BAR") // "FooBar"</code>
-        ///     <code>StringUtils.ToPascalCase("fooBar")  // "FooBar"</code>
-        ///     <code>StringUtils.ToPascalCase("Foo Bar") // "FooBar"</code>
-        /// </example>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static string ToPascalCase(string str) => ChangeCase(str, Capitalize);
-
-        /// <summary>
-        /// convert a string to kebab-case
-        /// </summary>
-        /// <example>
-        ///     <code>StringUtils.ToKebabCase("FOOBAR")  // "foo-bar"</code>
-        ///     <code>StringUtils.ToKebabCase("FOO_BAR") // "foo-bar"</code>
-        ///     <code>StringUtils.ToKebabCase("fooBar")  // "foo-bar"</code>
-        ///     <code>StringUtils.ToKebabCase("Foo Bar") // "foo-bar"</code>
-        /// </example>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static string ToKebabCase(string str) => ChangeCase(str, "-", word => word.ToLowerInvariant());
-
-        /// <summary>
-        /// convert a string to snake_case
-        /// </summary>
-        /// <example>
-        ///     <code>StringUtils.ToSnakeCase("FOOBAR")  // "foo_bar"</code>
-        ///     <code>StringUtils.ToSnakeCase("FOO_BAR") // "foo_bar"</code>
-        ///     <code>StringUtils.ToSnakeCase("fooBar")  // "foo_bar"</code>
-        ///     <code>StringUtils.ToSnakeCase("Foo Bar") // "foo_bar"</code>
-        /// </example>
-        /// <param name="str"></param>
-        /// <returns></returns>
-        public static string ToSnakeCase(string str) => ChangeCase(str, "_", word => word.ToLowerInvariant());
-
-        public static string ChangeCase(string str, Func<string, string> composer) => ChangeCase(str, "", composer);
-
-        public static string ChangeCase(string str, string sep, Func<string, string> composer) => ChangeCase(str, sep, (w, i) => composer(w));
-
-        public static string ChangeCase(string str, Func<string, int, string> composer) => ChangeCase(str, "", composer);
-
-        /// <summary>
-        /// Convert a string to a new case
-        /// </summary>
-        /// <example>
-        /// Convert a string to inverse camelCase: CAMELcASE
-        ///     <code>
-        ///         StringUtils.ChangeCase("my string", "", (word, index) => {
-        ///             word = word.ToUpperInvariant();
-        ///             if (index > 0)
-        ///                 word = StringUtils.toLowerFirst(word);
-        ///             return word
-        ///         });
-        ///         // "MYsTRING"
-        ///     </code>
-        /// </example>
-        /// <param name="str">an input string </param>
-        /// <param name="sep">a seperator string used between "words" in the string</param>
-        /// <param name="composer">a function that converts individual words to a new case</param>
-        /// <returns></returns>
-        public static string ChangeCase(string str, string sep, Func<string, int, string> composer)
-        {
-            string result = "";
-            int index = 0;
+    /// <summary>
+    /// Uppercase the first character in a string, leaving the rest of the string as is
+    /// </summary>
+    /// <param name="str"></param>
+    /// <returns>a string with the first character uppercased</returns>
+    public static string ToUpperFirst(string str) => ChangeCaseFirst(str, c => c.ToUpperInvariant());
 
-            foreach (string word in ToWords(str))
-            {
-                result += ((index == 0 ? "" : sep) + composer(word, index++));
-            }
+    /// <summary>
+    /// Lowercase the first character in a string, leaving the rest of the string as is
+    /// </summary>
+    /// <param name="str"></param>
+    /// <returns>a string with the first character lowercased</returns>
+    public static string ToLowerFirst(string str) => ChangeCaseFirst(str, c => c.ToLowerInvariant());
+
+    /// <summary>
+    /// Capitalizes a string, lowercasing the entire string and uppercasing the first character
+    /// </summary>
+    /// <param name="str"></param>
+    /// <returns>a capitalized string</returns>
+    public static string Capitalize(string str) => ToUpperFirst(str.ToLowerInvariant());
+
+    /// <summary>
+    /// Converts a string to camelCase.
+    /// </summary>
+    /// <example>
+    ///     <code>StringUtils.ToCamelCase("FOOBAR")  // "foobar"</code>
+    ///     <code>StringUtils.ToCamelCase("FOO_BAR") // "fooBar"</code>
+    ///     <code>StringUtils.ToCamelCase("FooBar")  // "fooBar"</code>
+    ///     <code>StringUtils.ToCamelCase("foo bar") // "fooBar"</code>
+    /// </example>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static string ToCamelCase(string str) =>
+        ChangeCase(str, (word, index) =>
+            (index == 0 ? word.ToLowerInvariant() : Capitalize(word)));
+
+    /// <summary>
+    /// Convert a string to CONSTANT_CASE
+    /// </summary>
+    /// <example>
+    ///     <code>StringUtils.ToConstantCase("fOo BaR") // "FOO_BAR"</code>
+    ///     <code>StringUtils.ToConstantCase("FooBar")  // "FOO_BAR"</code>
+    ///     <code>StringUtils.ToConstantCase("Foo Bar") // "FOO_BAR"</code>
+    /// </example>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static string ToConstantCase(string str) => ChangeCase(str, "_", w => w.ToUpperInvariant());
 
-            return result;
+    /// <summary>
+    /// Convert a string to UPPERCASE
+    /// </summary>
+    /// <example>
+    ///     <code>StringUtils.ToUpperCase("foobar")  // "FOOBAR"</code>
+    ///     <code>StringUtils.ToUpperCase("FOO_BAR") // "FOO BAR"</code>
+    ///     <code>StringUtils.ToUpperCase("FooBar")  // "FOO BAR"</code>
+    ///     <code>StringUtils.ToUpperCase("Foo Bar") // "FOO BAR"</code>
+    /// </example>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static string ToUpperCase(string str) => ChangeCase(str, " ", (word) => word.ToUpperInvariant());
+
+    /// <summary>
+    /// Convert a string to lowercase
+    /// </summary>
+    /// <example>
+    ///     <code>StringUtils.ToLowerCase("FOOBAR")  // "foobar"</code>
+    ///     <code>StringUtils.ToLowerCase("FOO_BAR") // "foo bar"</code>
+    ///     <code>StringUtils.ToLowerCase("FooBar")  // "foo bar"</code>
+    ///     <code>StringUtils.ToLowerCase("Foo Bar") // "foo bar"</code>
+    /// </example>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static string ToLowerCase(string str) => ChangeCase(str, " ", word => word.ToLowerInvariant());
+
+    /// <summary>
+    /// convert a string to PascalCase
+    /// </summary>
+    /// <example>
+    ///     <code>StringUtils.ToPascalCase("FOOBAR")  // "FooBar"</code>
+    ///     <code>StringUtils.ToPascalCase("FOO_BAR") // "FooBar"</code>
+    ///     <code>StringUtils.ToPascalCase("fooBar")  // "FooBar"</code>
+    ///     <code>StringUtils.ToPascalCase("Foo Bar") // "FooBar"</code>
+    /// </example>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static string ToPascalCase(string str) => ChangeCase(str, Capitalize);
+
+    /// <summary>
+    /// convert a string to kebab-case
+    /// </summary>
+    /// <example>
+    ///     <code>StringUtils.ToKebabCase("FOOBAR")  // "foo-bar"</code>
+    ///     <code>StringUtils.ToKebabCase("FOO_BAR") // "foo-bar"</code>
+    ///     <code>StringUtils.ToKebabCase("fooBar")  // "foo-bar"</code>
+    ///     <code>StringUtils.ToKebabCase("Foo Bar") // "foo-bar"</code>
+    /// </example>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static string ToKebabCase(string str) => ChangeCase(str, "-", word => word.ToLowerInvariant());
+
+    /// <summary>
+    /// convert a string to snake_case
+    /// </summary>
+    /// <example>
+    ///     <code>StringUtils.ToSnakeCase("FOOBAR")  // "foo_bar"</code>
+    ///     <code>StringUtils.ToSnakeCase("FOO_BAR") // "foo_bar"</code>
+    ///     <code>StringUtils.ToSnakeCase("fooBar")  // "foo_bar"</code>
+    ///     <code>StringUtils.ToSnakeCase("Foo Bar") // "foo_bar"</code>
+    /// </example>
+    /// <param name="str"></param>
+    /// <returns></returns>
+    public static string ToSnakeCase(string str) => ChangeCase(str, "_", word => word.ToLowerInvariant());
+
+    public static string ChangeCase(string str, Func<string, string> composer) => ChangeCase(str, "", composer);
+
+    public static string ChangeCase(string str, string sep, Func<string, string> composer) => ChangeCase(str, sep, (w, i) => composer(w));
+
+    public static string ChangeCase(string str, Func<string, int, string> composer) => ChangeCase(str, "", composer);
+
+    /// <summary>
+    /// Convert a string to a new case
+    /// </summary>
+    /// <example>
+    /// Convert a string to inverse camelCase: CAMELcASE
+    ///     <code>
+    ///         StringUtils.ChangeCase("my string", "", (word, index) => {
+    ///             word = word.ToUpperInvariant();
+    ///             if (index > 0)
+    ///                 word = StringUtils.toLowerFirst(word);
+    ///             return word
+    ///         });
+    ///         // "MYsTRING"
+    ///     </code>
+    /// </example>
+    /// <param name="str">an input string </param>
+    /// <param name="sep">a seperator string used between "words" in the string</param>
+    /// <param name="composer">a function that converts individual words to a new case</param>
+    /// <returns></returns>
+    public static string ChangeCase(string str, string sep, Func<string, int, string> composer)
+    {
+        string result = "";
+        int index = 0;
+
+        foreach (string word in ToWords(str))
+        {
+            result += ((index == 0 ? "" : sep) + composer(word, index++));
         }
 
-        private static string ChangeCaseFirst(string str, Func<string, string> change) => change(str.Substring(0, 1)) + str.Substring(1);
+        return result;
     }
+
+    private static string ChangeCaseFirst(string str, Func<string, string> change) => change(str.Substring(0, 1)) + str.Substring(1);
 }
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 4a92e647..15e4c3e3 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -3,96 +3,95 @@
 using GraphQL.Client.Abstractions;
 using GraphQL.Types;
 
-namespace GraphQL.Client.LocalExecution
+namespace GraphQL.Client.LocalExecution;
+
+public static class GraphQLLocalExecutionClient
 {
-    public static class GraphQLLocalExecutionClient
-    {
-        public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
-            where TSchema : ISchema
-            => new GraphQLLocalExecutionClient<TSchema>(schema, new DocumentExecuter(), clientSerializer, serverSerializer);
-    }
+    public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
+        where TSchema : ISchema
+        => new GraphQLLocalExecutionClient<TSchema>(schema, new DocumentExecuter(), clientSerializer, serverSerializer);
+}
 
-    public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
-    {
-        public TSchema Schema { get; }
+public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
+{
+    public TSchema Schema { get; }
 
-        public IGraphQLJsonSerializer Serializer { get; }
+    public IGraphQLJsonSerializer Serializer { get; }
 
-        private readonly IDocumentExecuter _documentExecuter;
-        private readonly IGraphQLTextSerializer _documentSerializer;
+    private readonly IDocumentExecuter _documentExecuter;
+    private readonly IGraphQLTextSerializer _documentSerializer;
 
-        public GraphQLLocalExecutionClient(TSchema schema, IDocumentExecuter documentExecuter, IGraphQLJsonSerializer serializer, IGraphQLTextSerializer documentSerializer)
-        {
-            Schema = schema ?? throw new ArgumentNullException(nameof(schema), "no schema configured");
-            _documentExecuter = documentExecuter;
-            Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
-            _documentSerializer = documentSerializer;
+    public GraphQLLocalExecutionClient(TSchema schema, IDocumentExecuter documentExecuter, IGraphQLJsonSerializer serializer, IGraphQLTextSerializer documentSerializer)
+    {
+        Schema = schema ?? throw new ArgumentNullException(nameof(schema), "no schema configured");
+        _documentExecuter = documentExecuter;
+        Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
+        _documentSerializer = documentSerializer;
 
-            if (!Schema.Initialized)
-                Schema.Initialize();
-        }
+        if (!Schema.Initialized)
+            Schema.Initialize();
+    }
 
-        public void Dispose() { }
+    public void Dispose() { }
 
-        public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-            => ExecuteQueryAsync<TResponse>(request, cancellationToken);
+    public Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+        => ExecuteQueryAsync<TResponse>(request, cancellationToken);
 
-        public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-            => ExecuteQueryAsync<TResponse>(request, cancellationToken);
+    public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+        => ExecuteQueryAsync<TResponse>(request, cancellationToken);
 
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) =>
-            Observable.Defer(() => ExecuteSubscriptionAsync<TResponse>(request).ToObservable())
-                .Concat()
-                .Publish()
-                .RefCount();
+    public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request) =>
+        Observable.Defer(() => ExecuteSubscriptionAsync<TResponse>(request).ToObservable())
+            .Concat()
+            .Publish()
+            .RefCount();
 
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request,
-            Action<Exception> exceptionHandler)
-            => CreateSubscriptionStream<TResponse>(request);
+    public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request,
+        Action<Exception> exceptionHandler)
+        => CreateSubscriptionStream<TResponse>(request);
 
-        #region Private Methods
+    #region Private Methods
 
-        private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken)
-        {
-            var executionResult = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
-            return await ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, cancellationToken).ConfigureAwait(false);
-        }
+    private async Task<GraphQLResponse<TResponse>> ExecuteQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken)
+    {
+        var executionResult = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+        return await ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, cancellationToken).ConfigureAwait(false);
+    }
 
-        private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-        {
-            var result = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
-            var stream = result.Streams?.Values.SingleOrDefault();
+    private async Task<IObservable<GraphQLResponse<TResponse>>> ExecuteSubscriptionAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+    {
+        var result = await ExecuteAsync(request, cancellationToken).ConfigureAwait(false);
+        var stream = result.Streams?.Values.SingleOrDefault();
 
-            return stream == null
-                ? Observable.Throw<GraphQLResponse<TResponse>>(new InvalidOperationException("the GraphQL execution did not return an observable"))
-                : stream.SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, token)));
-        }
+        return stream == null
+            ? Observable.Throw<GraphQLResponse<TResponse>>(new InvalidOperationException("the GraphQL execution did not return an observable"))
+            : stream.SelectMany(executionResult => Observable.FromAsync(token => ExecutionResultToGraphQLResponseAsync<TResponse>(executionResult, token)));
+    }
 
-        private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest clientRequest, CancellationToken cancellationToken = default)
-        {
-            var serverRequest = _documentSerializer.Deserialize<Transport.GraphQLRequest>(Serializer.SerializeToString(clientRequest));
-
-            var result = await _documentExecuter.ExecuteAsync(options =>
-            {
-                options.Schema = Schema;
-                options.OperationName = serverRequest?.OperationName;
-                options.Query = serverRequest?.Query;
-                options.Variables = serverRequest?.Variables;
-                options.Extensions = serverRequest?.Extensions;
-                options.CancellationToken = cancellationToken;
-            }).ConfigureAwait(false);
-
-            return result;
-        }
-
-        private async Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponseAsync<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
+    private async Task<ExecutionResult> ExecuteAsync(GraphQLRequest clientRequest, CancellationToken cancellationToken = default)
+    {
+        var serverRequest = _documentSerializer.Deserialize<Transport.GraphQLRequest>(Serializer.SerializeToString(clientRequest));
+
+        var result = await _documentExecuter.ExecuteAsync(options =>
         {
-            using var stream = new MemoryStream();
-            await _documentSerializer.WriteAsync(stream, executionResult, cancellationToken).ConfigureAwait(false);
-            stream.Seek(0, SeekOrigin.Begin);
-            return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(stream, cancellationToken).ConfigureAwait(false);
-        }
+            options.Schema = Schema;
+            options.OperationName = serverRequest?.OperationName;
+            options.Query = serverRequest?.Query;
+            options.Variables = serverRequest?.Variables;
+            options.Extensions = serverRequest?.Extensions;
+            options.CancellationToken = cancellationToken;
+        }).ConfigureAwait(false);
+
+        return result;
+    }
 
-        #endregion
+    private async Task<GraphQLResponse<TResponse>> ExecutionResultToGraphQLResponseAsync<TResponse>(ExecutionResult executionResult, CancellationToken cancellationToken = default)
+    {
+        using var stream = new MemoryStream();
+        await _documentSerializer.WriteAsync(stream, executionResult, cancellationToken).ConfigureAwait(false);
+        stream.Seek(0, SeekOrigin.Begin);
+        return await Serializer.DeserializeFromUtf8StreamAsync<TResponse>(stream, cancellationToken).ConfigureAwait(false);
     }
+
+    #endregion
 }
diff --git a/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
index ff18f49d..d5d4a7fb 100644
--- a/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
+++ b/src/GraphQL.Client.LocalExecution/ServiceCollectionExtensions.cs
@@ -4,15 +4,14 @@
 using GraphQL.Types;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace GraphQL.Client.LocalExecution
+namespace GraphQL.Client.LocalExecution;
+
+public static class ServiceCollectionExtensions
 {
-    public static class ServiceCollectionExtensions
+    public static IGraphQLBuilder AddGraphQLLocalExecutionClient<TSchema>(this IServiceCollection services) where TSchema : ISchema
     {
-        public static IGraphQLBuilder AddGraphQLLocalExecutionClient<TSchema>(this IServiceCollection services) where TSchema : ISchema
-        {
-            services.AddSingleton<GraphQLLocalExecutionClient<TSchema>>();
-            services.AddSingleton<IGraphQLClient>(p => p.GetRequiredService<GraphQLLocalExecutionClient<TSchema>>());
-            return new GraphQLBuilder(services, null);
-        }
+        services.AddSingleton<GraphQLLocalExecutionClient<TSchema>>();
+        services.AddSingleton<IGraphQLClient>(p => p.GetRequiredService<GraphQLLocalExecutionClient<TSchema>>());
+        return new GraphQLBuilder(services, null);
     }
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
index 476eed9c..d8e73a5b 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/ConstantCaseEnumConverter.cs
@@ -3,32 +3,31 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 
-namespace GraphQL.Client.Serializer.Newtonsoft
+namespace GraphQL.Client.Serializer.Newtonsoft;
+
+public class ConstantCaseEnumConverter : StringEnumConverter
 {
-    public class ConstantCaseEnumConverter : StringEnumConverter
+    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
     {
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        if (value == null)
+        {
+            writer.WriteNull();
+        }
+        else
         {
-            if (value == null)
+            var enumString = ((Enum)value).ToString("G");
+            var memberName = value.GetType()
+                .GetMember(enumString, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
+                .FirstOrDefault()?.Name;
+            if (string.IsNullOrEmpty(memberName))
             {
-                writer.WriteNull();
+                if (!AllowIntegerValues)
+                    throw new JsonSerializationException($"Integer value {value} is not allowed.");
+                writer.WriteValue(value);
             }
             else
             {
-                var enumString = ((Enum)value).ToString("G");
-                var memberName = value.GetType()
-                    .GetMember(enumString, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
-                    .FirstOrDefault()?.Name;
-                if (string.IsNullOrEmpty(memberName))
-                {
-                    if (!AllowIntegerValues)
-                        throw new JsonSerializationException($"Integer value {value} is not allowed.");
-                    writer.WriteValue(value);
-                }
-                else
-                {
-                    writer.WriteValue(memberName.ToConstantCase());
-                }
+                writer.WriteValue(memberName.ToConstantCase());
             }
         }
     }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index d1dd60f4..90b22ed8 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -1,61 +1,60 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace GraphQL.Client.Serializer.Newtonsoft
+namespace GraphQL.Client.Serializer.Newtonsoft;
+
+public class MapConverter : JsonConverter<Map>
 {
-    public class MapConverter : JsonConverter<Map>
-    {
-        public override void WriteJson(JsonWriter writer, Map value, JsonSerializer serializer) =>
-            throw new NotImplementedException(
-                "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+    public override void WriteJson(JsonWriter writer, Map value, JsonSerializer serializer) =>
+        throw new NotImplementedException(
+            "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-        public override Map ReadJson(JsonReader reader, Type objectType, Map existingValue, bool hasExistingValue, JsonSerializer serializer)
+    public override Map ReadJson(JsonReader reader, Type objectType, Map existingValue, bool hasExistingValue, JsonSerializer serializer)
+    {
+        var rootToken = JToken.ReadFrom(reader);
+        if (rootToken is JObject)
         {
-            var rootToken = JToken.ReadFrom(reader);
-            if (rootToken is JObject)
-            {
-                return (Map)ReadDictionary(rootToken, new Map());
-            }
-            else
-                throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+            return (Map)ReadDictionary(rootToken, new Map());
         }
+        else
+            throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+    }
 
-        private object? ReadToken(JToken? token) =>
-            token switch
-            {
-                JObject jObject => ReadDictionary(jObject, new Dictionary<string, object>()),
-                JArray jArray => ReadArray(jArray).ToList(),
-                JValue jValue => jValue.Value,
-                JConstructor _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
-                    "cannot deserialize a JSON constructor"),
-                JProperty _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
-                    "cannot deserialize a JSON property"),
-                JContainer _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
-                    "cannot deserialize a JSON comment"),
-                _ => throw new ArgumentOutOfRangeException(nameof(token.Type))
-            };
+    private object? ReadToken(JToken? token) =>
+        token switch
+        {
+            JObject jObject => ReadDictionary(jObject, new Dictionary<string, object>()),
+            JArray jArray => ReadArray(jArray).ToList(),
+            JValue jValue => jValue.Value,
+            JConstructor _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                "cannot deserialize a JSON constructor"),
+            JProperty _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                "cannot deserialize a JSON property"),
+            JContainer _ => throw new ArgumentOutOfRangeException(nameof(token.Type),
+                "cannot deserialize a JSON comment"),
+            _ => throw new ArgumentOutOfRangeException(nameof(token.Type))
+        };
 
-        private Dictionary<string, object> ReadDictionary(JToken element, Dictionary<string, object> to)
+    private Dictionary<string, object> ReadDictionary(JToken element, Dictionary<string, object> to)
+    {
+        foreach (var property in ((JObject)element).Properties())
         {
-            foreach (var property in ((JObject)element).Properties())
-            {
-                if (IsUnsupportedJTokenType(property.Value.Type))
-                    continue;
-                to[property.Name] = ReadToken(property.Value);
-            }
-            return to;
+            if (IsUnsupportedJTokenType(property.Value.Type))
+                continue;
+            to[property.Name] = ReadToken(property.Value);
         }
+        return to;
+    }
 
-        private IEnumerable<object?> ReadArray(JArray element)
+    private IEnumerable<object?> ReadArray(JArray element)
+    {
+        foreach (var item in element)
         {
-            foreach (var item in element)
-            {
-                if (IsUnsupportedJTokenType(item.Type))
-                    continue;
-                yield return ReadToken(item);
-            }
+            if (IsUnsupportedJTokenType(item.Type))
+                continue;
+            yield return ReadToken(item);
         }
-
-        private bool IsUnsupportedJTokenType(JTokenType type) => type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
     }
+
+    private bool IsUnsupportedJTokenType(JTokenType type) => type == JTokenType.Constructor || type == JTokenType.Property || type == JTokenType.Comment;
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 6e362c08..63cc6de3 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -4,54 +4,53 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
-namespace GraphQL.Client.Serializer.Newtonsoft
+namespace GraphQL.Client.Serializer.Newtonsoft;
+
+public class NewtonsoftJsonSerializer : IGraphQLWebsocketJsonSerializer
 {
-    public class NewtonsoftJsonSerializer : IGraphQLWebsocketJsonSerializer
+    public static JsonSerializerSettings DefaultJsonSerializerSettings => new JsonSerializerSettings
     {
-        public static JsonSerializerSettings DefaultJsonSerializerSettings => new JsonSerializerSettings
-        {
-            ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
-            MissingMemberHandling = MissingMemberHandling.Ignore,
-            Converters = { new ConstantCaseEnumConverter() }
-        };
+        ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
+        MissingMemberHandling = MissingMemberHandling.Ignore,
+        Converters = { new ConstantCaseEnumConverter() }
+    };
 
-        public JsonSerializerSettings JsonSerializerSettings { get; }
+    public JsonSerializerSettings JsonSerializerSettings { get; }
 
-        public NewtonsoftJsonSerializer() : this(DefaultJsonSerializerSettings) { }
+    public NewtonsoftJsonSerializer() : this(DefaultJsonSerializerSettings) { }
 
-        public NewtonsoftJsonSerializer(Action<JsonSerializerSettings> configure) : this(configure.AndReturn(DefaultJsonSerializerSettings)) { }
+    public NewtonsoftJsonSerializer(Action<JsonSerializerSettings> configure) : this(configure.AndReturn(DefaultJsonSerializerSettings)) { }
 
-        public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
-        {
-            JsonSerializerSettings = jsonSerializerSettings;
-            ConfigureMandatorySerializerOptions();
-        }
+    public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
+    {
+        JsonSerializerSettings = jsonSerializerSettings;
+        ConfigureMandatorySerializerOptions();
+    }
 
-        // deserialize extensions to Dictionary<string, object>
-        private void ConfigureMandatorySerializerOptions() => JsonSerializerSettings.Converters.Insert(0, new MapConverter());
+    // deserialize extensions to Dictionary<string, object>
+    private void ConfigureMandatorySerializerOptions() => JsonSerializerSettings.Converters.Insert(0, new MapConverter());
 
-        public string SerializeToString(GraphQLRequest request) => JsonConvert.SerializeObject(request, JsonSerializerSettings);
+    public string SerializeToString(GraphQLRequest request) => JsonConvert.SerializeObject(request, JsonSerializerSettings);
 
-        public byte[] SerializeToBytes(GraphQLWebSocketRequest request)
-        {
-            var json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
-            return Encoding.UTF8.GetBytes(json);
-        }
+    public byte[] SerializeToBytes(GraphQLWebSocketRequest request)
+    {
+        var json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
+        return Encoding.UTF8.GetBytes(json);
+    }
 
-        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
+    public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
 
-        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
-            JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
-                JsonSerializerSettings);
+    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
+        JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
+            JsonSerializerSettings);
 
-        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
+    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
 
-        private Task<T> DeserializeFromUtf8Stream<T>(Stream stream)
-        {
-            using var sr = new StreamReader(stream);
-            using JsonReader reader = new JsonTextReader(sr);
-            var serializer = JsonSerializer.Create(JsonSerializerSettings);
-            return Task.FromResult(serializer.Deserialize<T>(reader));
-        }
+    private Task<T> DeserializeFromUtf8Stream<T>(Stream stream)
+    {
+        using var sr = new StreamReader(stream);
+        using JsonReader reader = new JsonTextReader(sr);
+        var serializer = JsonSerializer.Create(JsonSerializerSettings);
+        return Task.FromResult(serializer.Deserialize<T>(reader));
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
index 138b0276..680503a6 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
@@ -1,10 +1,9 @@
 using System.Text.Json;
 using GraphQL.Client.Abstractions.Utilities;
 
-namespace GraphQL.Client.Serializer.SystemTextJson
+namespace GraphQL.Client.Serializer.SystemTextJson;
+
+public class ConstantCaseJsonNamingPolicy: JsonNamingPolicy
 {
-    public class ConstantCaseJsonNamingPolicy: JsonNamingPolicy
-    {
-        public override string ConvertName(string name) => name.ToConstantCase();
-    }
+    public override string ConvertName(string name) => name.ToConstantCase();
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
index 7afffe57..6424e91d 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConverterHelperExtensions.cs
@@ -3,34 +3,33 @@
 using System.Text;
 using System.Text.Json;
 
-namespace GraphQL.Client.Serializer.SystemTextJson
+namespace GraphQL.Client.Serializer.SystemTextJson;
+
+public static class ConverterHelperExtensions
 {
-    public static class ConverterHelperExtensions
+    public static object ReadNumber(this ref Utf8JsonReader reader)
     {
-        public static object ReadNumber(this ref Utf8JsonReader reader)
-        {
-            if (reader.TryGetInt32(out int i))
-                return i;
-            else if (reader.TryGetInt64(out long l))
-                return l;
-            else if (reader.TryGetDouble(out double d))
-                return reader.TryGetBigInteger(out var bi) && bi != new BigInteger(d)
-                    ? bi
-                    : (object)d;
-            else if (reader.TryGetDecimal(out decimal dd))
-                return reader.TryGetBigInteger(out var bi) && bi != new BigInteger(dd)
-                    ? bi
-                    : (object)dd;
+        if (reader.TryGetInt32(out int i))
+            return i;
+        else if (reader.TryGetInt64(out long l))
+            return l;
+        else if (reader.TryGetDouble(out double d))
+            return reader.TryGetBigInteger(out var bi) && bi != new BigInteger(d)
+                ? bi
+                : (object)d;
+        else if (reader.TryGetDecimal(out decimal dd))
+            return reader.TryGetBigInteger(out var bi) && bi != new BigInteger(dd)
+                ? bi
+                : (object)dd;
 
-            throw new NotImplementedException($"Unexpected Number value. Raw text was: {reader.GetRawString()}");
-        }
+        throw new NotImplementedException($"Unexpected Number value. Raw text was: {reader.GetRawString()}");
+    }
 
-        public static bool TryGetBigInteger(this ref Utf8JsonReader reader, out BigInteger bi) => BigInteger.TryParse(reader.GetRawString(), out bi);
+    public static bool TryGetBigInteger(this ref Utf8JsonReader reader, out BigInteger bi) => BigInteger.TryParse(reader.GetRawString(), out bi);
 
-        public static string GetRawString(this ref Utf8JsonReader reader)
-        {
-            var byteArray = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
-            return Encoding.UTF8.GetString(byteArray);
-        }
+    public static string GetRawString(this ref Utf8JsonReader reader)
+    {
+        var byteArray = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+        return Encoding.UTF8.GetString(byteArray);
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
index 4114a17a..e325dccb 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
@@ -1,48 +1,47 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GraphQL.Client.Serializer.SystemTextJson
+namespace GraphQL.Client.Serializer.SystemTextJson;
+
+public class ErrorPathConverter : JsonConverter<ErrorPath>
 {
-    public class ErrorPathConverter : JsonConverter<ErrorPath>
-    {
 
-        public override ErrorPath Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
-            new ErrorPath(ReadArray(ref reader));
+    public override ErrorPath Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
+        new ErrorPath(ReadArray(ref reader));
 
-        public override void Write(Utf8JsonWriter writer, ErrorPath value, JsonSerializerOptions options)
-            => throw new NotImplementedException(
-                "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
-        
-        private IEnumerable<object?> ReadArray(ref Utf8JsonReader reader)
+    public override void Write(Utf8JsonWriter writer, ErrorPath value, JsonSerializerOptions options)
+        => throw new NotImplementedException(
+            "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+    
+    private IEnumerable<object?> ReadArray(ref Utf8JsonReader reader)
+    {
+        if (reader.TokenType != JsonTokenType.StartArray)
         {
-            if (reader.TokenType != JsonTokenType.StartArray)
-            {
-                throw new JsonException("This converter can only parse when the root element is a JSON Array.");
-            }
-
-            var array = new List<object?>();
+            throw new JsonException("This converter can only parse when the root element is a JSON Array.");
+        }
 
-            while (reader.Read())
-            {
-                if (reader.TokenType == JsonTokenType.EndArray)
-                    break;
+        var array = new List<object?>();
 
-                array.Add(ReadValue(ref reader));
-            }
+        while (reader.Read())
+        {
+            if (reader.TokenType == JsonTokenType.EndArray)
+                break;
 
-            return array;
+            array.Add(ReadValue(ref reader));
         }
 
-        private object? ReadValue(ref Utf8JsonReader reader)
-            => reader.TokenType switch
-            {
-                JsonTokenType.None => null,
-                JsonTokenType.String => reader.GetString(),
-                JsonTokenType.Number => reader.ReadNumber(),
-                JsonTokenType.True => true,
-                JsonTokenType.False => false,
-                JsonTokenType.Null => null,
-                _ => throw new InvalidOperationException($"Unexpected token type: {reader.TokenType}")
-            };
+        return array;
     }
+
+    private object? ReadValue(ref Utf8JsonReader reader)
+        => reader.TokenType switch
+        {
+            JsonTokenType.None => null,
+            JsonTokenType.String => reader.GetString(),
+            JsonTokenType.Number => reader.ReadNumber(),
+            JsonTokenType.True => true,
+            JsonTokenType.False => false,
+            JsonTokenType.Null => null,
+            _ => throw new InvalidOperationException($"Unexpected token type: {reader.TokenType}")
+        };
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index 0c9ec398..96bad2c6 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -3,183 +3,182 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GraphQL.Client.Serializer.SystemTextJson
+namespace GraphQL.Client.Serializer.SystemTextJson;
+
+/// <summary>
+/// class for converting immutable objects, derived from https://github.com/manne/obviously/blob/master/src/system.text.json/Core/ImmutableConverter.cs
+/// </summary>
+public class ImmutableConverter : JsonConverter<object>
 {
-    /// <summary>
-    /// class for converting immutable objects, derived from https://github.com/manne/obviously/blob/master/src/system.text.json/Core/ImmutableConverter.cs
-    /// </summary>
-    public class ImmutableConverter : JsonConverter<object>
+    public override bool CanConvert(Type typeToConvert)
     {
-        public override bool CanConvert(Type typeToConvert)
-        {
-            if (typeToConvert.IsPrimitive)
-                return false;
+        if (typeToConvert.IsPrimitive)
+            return false;
 
-            var nullableUnderlyingType = Nullable.GetUnderlyingType(typeToConvert);
-            if (nullableUnderlyingType != null && nullableUnderlyingType.IsValueType)
-                return false;
+        var nullableUnderlyingType = Nullable.GetUnderlyingType(typeToConvert);
+        if (nullableUnderlyingType != null && nullableUnderlyingType.IsValueType)
+            return false;
 
-            bool result;
-            var constructors = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
-            if (constructors.Length != 1)
+        bool result;
+        var constructors = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
+        if (constructors.Length != 1)
+        {
+            result = false;
+        }
+        else
+        {
+            var constructor = constructors[0];
+            var parameters = constructor.GetParameters();
+
+            if (parameters.Length > 0)
             {
-                result = false;
+                var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                result = parameters
+                    .Select(parameter => properties.Any(p => NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous())))
+                    .All(hasMatchingProperty => hasMatchingProperty);
             }
             else
             {
-                var constructor = constructors[0];
-                var parameters = constructor.GetParameters();
-
-                if (parameters.Length > 0)
-                {
-                    var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
-                    result = parameters
-                        .Select(parameter => properties.Any(p => NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous())))
-                        .All(hasMatchingProperty => hasMatchingProperty);
-                }
-                else
-                {
-                    result = false;
-                }
+                result = false;
             }
-
-            return result;
         }
 
-        public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        return result;
+    }
+
+    public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var valueOfProperty = new Dictionary<PropertyInfo, object>();
+        var namedPropertiesMapping = GetNamedProperties(options, GetProperties(typeToConvert));
+        reader.Read();
+        while (true)
         {
-            var valueOfProperty = new Dictionary<PropertyInfo, object>();
-            var namedPropertiesMapping = GetNamedProperties(options, GetProperties(typeToConvert));
-            reader.Read();
-            while (true)
+            if (reader.TokenType != JsonTokenType.PropertyName && reader.TokenType != JsonTokenType.String)
             {
-                if (reader.TokenType != JsonTokenType.PropertyName && reader.TokenType != JsonTokenType.String)
-                {
-                    break;
-                }
-
-                string jsonPropName = reader.GetString();
-                string normalizedPropName = ConvertAndNormalizeName(jsonPropName, options);
-                if (!namedPropertiesMapping.TryGetValue(normalizedPropName, out var obProp))
-                {
-                    reader.Read();
-                }
-                else
-                {
-                    var value = JsonSerializer.Deserialize(ref reader, obProp.PropertyType, options);
-                    reader.Read();
-                    valueOfProperty[obProp] = value;
-                }
+                break;
             }
 
-            var ctor = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First();
-            var parameters = ctor.GetParameters();
-            var parameterValues = new object[parameters.Length];
-            for (int index = 0; index < parameters.Length; index++)
+            string jsonPropName = reader.GetString();
+            string normalizedPropName = ConvertAndNormalizeName(jsonPropName, options);
+            if (!namedPropertiesMapping.TryGetValue(normalizedPropName, out var obProp))
             {
-                var parameterInfo = parameters[index];
-                var value = valueOfProperty.First(prop =>
-                                                      NameOfPropertyAndParameter.Matches(prop.Key.Name, parameterInfo.Name, typeToConvert.IsAnonymous())).Value;
-
-                parameterValues[index] = value;
+                reader.Read();
             }
-
-            var instance = ctor.Invoke(parameterValues);
-            return instance;
-        }
-
-        public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
-        {
-            var strippedOptions = new JsonSerializerOptions
-            {
-                AllowTrailingCommas = options.AllowTrailingCommas,
-                DefaultBufferSize = options.DefaultBufferSize,
-                DictionaryKeyPolicy = options.DictionaryKeyPolicy,
-                Encoder = options.Encoder,
-                IgnoreNullValues = options.IgnoreNullValues,
-                IgnoreReadOnlyProperties = options.IgnoreReadOnlyProperties,
-                MaxDepth = options.MaxDepth,
-                PropertyNameCaseInsensitive = options.PropertyNameCaseInsensitive,
-                PropertyNamingPolicy = options.PropertyNamingPolicy,
-                ReadCommentHandling = options.ReadCommentHandling,
-                WriteIndented = options.WriteIndented
-            };
-            foreach (var converter in options.Converters)
+            else
             {
-                if (!(converter is ImmutableConverter))
-                    strippedOptions.Converters.Add(converter);
+                var value = JsonSerializer.Deserialize(ref reader, obProp.PropertyType, options);
+                reader.Read();
+                valueOfProperty[obProp] = value;
             }
-
-            JsonSerializer.Serialize(writer, value, strippedOptions);
         }
 
-        private static PropertyInfo[] GetProperties(IReflect typeToConvert) => typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
-
-        private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(JsonSerializerOptions options, IEnumerable<PropertyInfo> properties)
+        var ctor = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance).First();
+        var parameters = ctor.GetParameters();
+        var parameterValues = new object[parameters.Length];
+        for (int index = 0; index < parameters.Length; index++)
         {
-            var result = new Dictionary<string, PropertyInfo>();
-            foreach (var property in properties)
-            {
-                string name;
-                var nameAttribute = property.GetCustomAttribute<JsonPropertyNameAttribute>();
-                if (nameAttribute != null)
-                {
-                    name = nameAttribute.Name;
-                }
-                else
-                {
-                    name = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
-                }
-
-                string normalizedName = NormalizeName(name, options);
-                result.Add(normalizedName, property);
-            }
+            var parameterInfo = parameters[index];
+            var value = valueOfProperty.First(prop =>
+                                                  NameOfPropertyAndParameter.Matches(prop.Key.Name, parameterInfo.Name, typeToConvert.IsAnonymous())).Value;
 
-            return result;
+            parameterValues[index] = value;
         }
 
-        private static string ConvertAndNormalizeName(string name, JsonSerializerOptions options)
+        var instance = ctor.Invoke(parameterValues);
+        return instance;
+    }
+
+    public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
+    {
+        var strippedOptions = new JsonSerializerOptions
         {
-            string convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;
-            return NormalizeName(convertedName, options);
+            AllowTrailingCommas = options.AllowTrailingCommas,
+            DefaultBufferSize = options.DefaultBufferSize,
+            DictionaryKeyPolicy = options.DictionaryKeyPolicy,
+            Encoder = options.Encoder,
+            IgnoreNullValues = options.IgnoreNullValues,
+            IgnoreReadOnlyProperties = options.IgnoreReadOnlyProperties,
+            MaxDepth = options.MaxDepth,
+            PropertyNameCaseInsensitive = options.PropertyNameCaseInsensitive,
+            PropertyNamingPolicy = options.PropertyNamingPolicy,
+            ReadCommentHandling = options.ReadCommentHandling,
+            WriteIndented = options.WriteIndented
+        };
+        foreach (var converter in options.Converters)
+        {
+            if (!(converter is ImmutableConverter))
+                strippedOptions.Converters.Add(converter);
         }
 
-        private static string NormalizeName(string name, JsonSerializerOptions options) => options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
+        JsonSerializer.Serialize(writer, value, strippedOptions);
     }
 
-    internal static class NameOfPropertyAndParameter
+    private static PropertyInfo[] GetProperties(IReflect typeToConvert) => typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+
+    private static IReadOnlyDictionary<string, PropertyInfo> GetNamedProperties(JsonSerializerOptions options, IEnumerable<PropertyInfo> properties)
     {
-        public static bool Matches(string propertyName, string parameterName, bool anonymousType)
+        var result = new Dictionary<string, PropertyInfo>();
+        foreach (var property in properties)
         {
-            if (string.IsNullOrEmpty(propertyName))
+            string name;
+            var nameAttribute = property.GetCustomAttribute<JsonPropertyNameAttribute>();
+            if (nameAttribute != null)
             {
-                return string.IsNullOrEmpty(parameterName);
+                name = nameAttribute.Name;
             }
-
-            if (string.IsNullOrEmpty(parameterName))
-            {
-                return false;
-            }
-
-            if (anonymousType)
+            else
             {
-                return propertyName.Equals(parameterName, StringComparison.Ordinal);
+                name = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
             }
 
-            var xRight = propertyName.AsSpan(1);
-            var yRight = parameterName.AsSpan(1);
-            return char.ToLowerInvariant(propertyName[0]).CompareTo(parameterName[0]) == 0 && xRight.Equals(yRight, StringComparison.Ordinal);
+            string normalizedName = NormalizeName(name, options);
+            result.Add(normalizedName, property);
         }
+
+        return result;
+    }
+
+    private static string ConvertAndNormalizeName(string name, JsonSerializerOptions options)
+    {
+        string convertedName = options.PropertyNamingPolicy?.ConvertName(name) ?? name;
+        return NormalizeName(convertedName, options);
     }
 
-    internal static class TypeExtensions
+    private static string NormalizeName(string name, JsonSerializerOptions options) => options.PropertyNameCaseInsensitive ? name.ToLowerInvariant() : name;
+}
+
+internal static class NameOfPropertyAndParameter
+{
+    public static bool Matches(string propertyName, string parameterName, bool anonymousType)
     {
-        // copied from https://github.com/dahomey-technologies/Dahomey.Json/blob/master/src/Dahomey.Json/Util/TypeExtensions.cs
-        public static bool IsAnonymous(this Type type) =>
-            type.Namespace == null
-            && type.IsSealed
-            && type.BaseType == typeof(object)
-            && !type.IsPublic
-            && type.IsDefined(typeof(CompilerGeneratedAttribute), false);
+        if (string.IsNullOrEmpty(propertyName))
+        {
+            return string.IsNullOrEmpty(parameterName);
+        }
+
+        if (string.IsNullOrEmpty(parameterName))
+        {
+            return false;
+        }
+
+        if (anonymousType)
+        {
+            return propertyName.Equals(parameterName, StringComparison.Ordinal);
+        }
+
+        var xRight = propertyName.AsSpan(1);
+        var yRight = parameterName.AsSpan(1);
+        return char.ToLowerInvariant(propertyName[0]).CompareTo(parameterName[0]) == 0 && xRight.Equals(yRight, StringComparison.Ordinal);
     }
 }
+
+internal static class TypeExtensions
+{
+    // copied from https://github.com/dahomey-technologies/Dahomey.Json/blob/master/src/Dahomey.Json/Util/TypeExtensions.cs
+    public static bool IsAnonymous(this Type type) =>
+        type.Namespace == null
+        && type.IsSealed
+        && type.BaseType == typeof(object)
+        && !type.IsPublic
+        && type.IsDefined(typeof(CompilerGeneratedAttribute), false);
+}
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
index bc2ddc14..3fc8f6eb 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/JsonSerializerOptionsExtensions.cs
@@ -1,13 +1,12 @@
 using System.Text.Json;
 
-namespace GraphQL.Client.Serializer.SystemTextJson
+namespace GraphQL.Client.Serializer.SystemTextJson;
+
+public static class JsonSerializerOptionsExtensions
 {
-    public static class JsonSerializerOptionsExtensions
+    public static JsonSerializerOptions SetupImmutableConverter(this JsonSerializerOptions options)
     {
-        public static JsonSerializerOptions SetupImmutableConverter(this JsonSerializerOptions options)
-        {
-            options.Converters.Add(new ImmutableConverter());
-            return options;
-        }
+        options.Converters.Add(new ImmutableConverter());
+        return options;
     }
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
index e3ab7217..66d4aead 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
@@ -1,80 +1,79 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace GraphQL.Client.Serializer.SystemTextJson
+namespace GraphQL.Client.Serializer.SystemTextJson;
+
+/// <summary>
+/// A custom JsonConverter for reading the extension fields of <see cref="GraphQLResponse{T}"/> and <see cref="GraphQLError"/>.
+/// </summary>
+/// <remarks>
+/// Taken and modified from GraphQL.SystemTextJson.ObjectDictionaryConverter (GraphQL.NET)
+/// </remarks>
+public class MapConverter : JsonConverter<Map>
 {
-    /// <summary>
-    /// A custom JsonConverter for reading the extension fields of <see cref="GraphQLResponse{T}"/> and <see cref="GraphQLError"/>.
-    /// </summary>
-    /// <remarks>
-    /// Taken and modified from GraphQL.SystemTextJson.ObjectDictionaryConverter (GraphQL.NET)
-    /// </remarks>
-    public class MapConverter : JsonConverter<Map>
-    {
-        public override Map Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => ReadDictionary(ref reader, new Map());
+    public override Map Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => ReadDictionary(ref reader, new Map());
 
-        public override void Write(Utf8JsonWriter writer, Map value, JsonSerializerOptions options)
-            => throw new NotImplementedException(
-                "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
+    public override void Write(Utf8JsonWriter writer, Map value, JsonSerializerOptions options)
+        => throw new NotImplementedException(
+            "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-        private static TDictionary ReadDictionary<TDictionary>(ref Utf8JsonReader reader, TDictionary result)
-            where TDictionary : Dictionary<string, object>
+    private static TDictionary ReadDictionary<TDictionary>(ref Utf8JsonReader reader, TDictionary result)
+        where TDictionary : Dictionary<string, object>
+    {
+        if (reader.TokenType != JsonTokenType.StartObject)
+            throw new JsonException();
+        
+        while (reader.Read())
         {
-            if (reader.TokenType != JsonTokenType.StartObject)
-                throw new JsonException();
-            
-            while (reader.Read())
-            {
-                if (reader.TokenType == JsonTokenType.EndObject)
-                    break;
+            if (reader.TokenType == JsonTokenType.EndObject)
+                break;
 
-                if (reader.TokenType != JsonTokenType.PropertyName)
-                    throw new JsonException();
-
-                string key = reader.GetString();
+            if (reader.TokenType != JsonTokenType.PropertyName)
+                throw new JsonException();
 
-                // move to property value
-                if (!reader.Read())
-                    throw new JsonException();
+            string key = reader.GetString();
 
-                result.Add(key, ReadValue(ref reader));
-            }
+            // move to property value
+            if (!reader.Read())
+                throw new JsonException();
 
-            return result;
+            result.Add(key, ReadValue(ref reader));
         }
 
-        private static List<object> ReadArray(ref Utf8JsonReader reader)
-        {
-            if (reader.TokenType != JsonTokenType.StartArray)
-                throw new JsonException();
+        return result;
+    }
 
-            var result = new List<object>();
+    private static List<object> ReadArray(ref Utf8JsonReader reader)
+    {
+        if (reader.TokenType != JsonTokenType.StartArray)
+            throw new JsonException();
 
-            while (reader.Read())
-            {
-                if (reader.TokenType == JsonTokenType.EndArray)
-                    break;
+        var result = new List<object>();
 
-                result.Add(ReadValue(ref reader));
-            }
+        while (reader.Read())
+        {
+            if (reader.TokenType == JsonTokenType.EndArray)
+                break;
 
-            return result;
+            result.Add(ReadValue(ref reader));
         }
-        
-        private static object? ReadValue(ref Utf8JsonReader reader)
-            => reader.TokenType switch
-            {
-                JsonTokenType.StartArray => ReadArray(ref reader).ToList(),
-                JsonTokenType.StartObject => ReadDictionary(ref reader, new Dictionary<string, object>()),
-                JsonTokenType.Number => reader.ReadNumber(),
-                JsonTokenType.True => true,
-                JsonTokenType.False => false,
-                JsonTokenType.String => reader.GetString(),
-                JsonTokenType.Null => null,
-                JsonTokenType.None => null,
-                _ => throw new InvalidOperationException($"Unexpected value kind: {reader.TokenType}")
-            };
 
-        
+        return result;
     }
+    
+    private static object? ReadValue(ref Utf8JsonReader reader)
+        => reader.TokenType switch
+        {
+            JsonTokenType.StartArray => ReadArray(ref reader).ToList(),
+            JsonTokenType.StartObject => ReadDictionary(ref reader, new Dictionary<string, object>()),
+            JsonTokenType.Number => reader.ReadNumber(),
+            JsonTokenType.True => true,
+            JsonTokenType.False => false,
+            JsonTokenType.String => reader.GetString(),
+            JsonTokenType.Null => null,
+            JsonTokenType.None => null,
+            _ => throw new InvalidOperationException($"Unexpected value kind: {reader.TokenType}")
+        };
+
+    
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 05b2c2f0..4fa66c64 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -3,47 +3,46 @@
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 
-namespace GraphQL.Client.Serializer.SystemTextJson
+namespace GraphQL.Client.Serializer.SystemTextJson;
+
+public class SystemTextJsonSerializer : IGraphQLWebsocketJsonSerializer
 {
-    public class SystemTextJsonSerializer : IGraphQLWebsocketJsonSerializer
+    public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions
     {
-        public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions
-        {
-            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-            Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}
-        }.SetupImmutableConverter();
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}
+    }.SetupImmutableConverter();
 
-        public JsonSerializerOptions Options { get; }
+    public JsonSerializerOptions Options { get; }
 
-        public SystemTextJsonSerializer() : this(DefaultJsonSerializerOptions) { }
+    public SystemTextJsonSerializer() : this(DefaultJsonSerializerOptions) { }
 
-        public SystemTextJsonSerializer(Action<JsonSerializerOptions> configure) : this(configure.AndReturn(DefaultJsonSerializerOptions)) { }
+    public SystemTextJsonSerializer(Action<JsonSerializerOptions> configure) : this(configure.AndReturn(DefaultJsonSerializerOptions)) { }
 
-        public SystemTextJsonSerializer(JsonSerializerOptions options)
-        {
-            Options = options;
-            ConfigureMandatorySerializerOptions();
-        }
+    public SystemTextJsonSerializer(JsonSerializerOptions options)
+    {
+        Options = options;
+        ConfigureMandatorySerializerOptions();
+    }
 
-        private void ConfigureMandatorySerializerOptions()
-        {
-            // deserialize extensions to Dictionary<string, object>
-            Options.Converters.Insert(0, new ErrorPathConverter());
-            Options.Converters.Insert(0, new MapConverter());
-            // allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
-            Options.PropertyNameCaseInsensitive = true;
-        }
+    private void ConfigureMandatorySerializerOptions()
+    {
+        // deserialize extensions to Dictionary<string, object>
+        Options.Converters.Insert(0, new ErrorPathConverter());
+        Options.Converters.Insert(0, new MapConverter());
+        // allow the JSON field "data" to match the property "Data" even without JsonNamingPolicy.CamelCase
+        Options.PropertyNameCaseInsensitive = true;
+    }
 
-        public string SerializeToString(GraphQLRequest request) => JsonSerializer.Serialize(request, Options);
+    public string SerializeToString(GraphQLRequest request) => JsonSerializer.Serialize(request, Options);
 
-        public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options, cancellationToken).AsTask();
+    public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => JsonSerializer.DeserializeAsync<GraphQLResponse<TResponse>>(stream, Options, cancellationToken).AsTask();
 
-        public byte[] SerializeToBytes(GraphQLWebSocketRequest request) => JsonSerializer.SerializeToUtf8Bytes(request, Options);
+    public byte[] SerializeToBytes(GraphQLWebSocketRequest request) => JsonSerializer.SerializeToUtf8Bytes(request, Options);
 
-        public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
+    public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
 
-        public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
-            JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
-                Options);
-    }
+    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
+        JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
+            Options);
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index a0b20c5d..eda4b6f9 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -4,188 +4,187 @@
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
 
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http;
+
+public class GraphQLHttpClient : IGraphQLClient, IDisposable
 {
-    public class GraphQLHttpClient : IGraphQLClient, IDisposable
-    {
-        private readonly Lazy<GraphQLHttpWebSocket> _lazyHttpWebSocket;
-        private GraphQLHttpWebSocket GraphQlHttpWebSocket => _lazyHttpWebSocket.Value;
+    private readonly Lazy<GraphQLHttpWebSocket> _lazyHttpWebSocket;
+    private GraphQLHttpWebSocket GraphQlHttpWebSocket => _lazyHttpWebSocket.Value;
 
-        private readonly CancellationTokenSource _cancellationTokenSource = new();
+    private readonly CancellationTokenSource _cancellationTokenSource = new();
 
-        private readonly bool _disposeHttpClient = false;
+    private readonly bool _disposeHttpClient = false;
 
-        /// <summary>
-        /// the json serializer
-        /// </summary>
-        public IGraphQLWebsocketJsonSerializer JsonSerializer { get; }
+    /// <summary>
+    /// the json serializer
+    /// </summary>
+    public IGraphQLWebsocketJsonSerializer JsonSerializer { get; }
 
-        /// <summary>
-        /// the instance of <see cref="HttpClient"/> which is used internally
-        /// </summary>
-        public HttpClient HttpClient { get; }
+    /// <summary>
+    /// the instance of <see cref="HttpClient"/> which is used internally
+    /// </summary>
+    public HttpClient HttpClient { get; }
 
-        /// <summary>
-        /// The Options	to be used
-        /// </summary>
-        public GraphQLHttpClientOptions Options { get; }
+    /// <summary>
+    /// The Options	to be used
+    /// </summary>
+    public GraphQLHttpClientOptions Options { get; }
 
-        /// <summary>
-        /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
-        /// </summary>
-        public IObservable<Exception> WebSocketReceiveErrors => GraphQlHttpWebSocket.ReceiveErrors;
+    /// <summary>
+    /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+    /// </summary>
+    public IObservable<Exception> WebSocketReceiveErrors => GraphQlHttpWebSocket.ReceiveErrors;
 
-        /// <summary>
-        /// the websocket connection state
-        /// </summary>
-        public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => GraphQlHttpWebSocket.ConnectionState;
+    /// <summary>
+    /// the websocket connection state
+    /// </summary>
+    public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => GraphQlHttpWebSocket.ConnectionState;
 
-        #region Constructors
+    #region Constructors
 
-        public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serializer)
-            : this(new Uri(endPoint), serializer) { }
+    public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serializer)
+        : this(new Uri(endPoint), serializer) { }
 
-        public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serializer)
-            : this(o => o.EndPoint = endPoint, serializer) { }
+    public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serializer)
+        : this(o => o.EndPoint = endPoint, serializer) { }
 
-        public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer)
-            : this(configure.New(), serializer) { }
+    public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer)
+        : this(configure.New(), serializer) { }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer)
-            : this(options, serializer, new HttpClient(options.HttpMessageHandler))
-        {
-            // set this flag to dispose the internally created HttpClient when GraphQLHttpClient gets disposed
-            _disposeHttpClient = true;
-        }
+    public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer)
+        : this(options, serializer, new HttpClient(options.HttpMessageHandler))
+    {
+        // set this flag to dispose the internally created HttpClient when GraphQLHttpClient gets disposed
+        _disposeHttpClient = true;
+    }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
-        {
-            Options = options ?? throw new ArgumentNullException(nameof(options));
-            JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
-            HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
+    public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
+    {
+        Options = options ?? throw new ArgumentNullException(nameof(options));
+        JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
+        HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
 
-            if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
-                HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
+        if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
+            HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
 
-            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
-        }
+        _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
+    }
 
-        #endregion
+    #endregion
 
-        #region IGraphQLClient
+    #region IGraphQLClient
 
-        /// <inheritdoc />
-        public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-        {
-            if (Options.UseWebSocketForQueriesAndMutations ||
-                !(Options.WebSocketEndPoint is null) && Options.EndPoint is null ||
-                Options.EndPoint.HasWebSocketScheme())
-                return await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken).ConfigureAwait(false);
+    /// <inheritdoc />
+    public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+    {
+        if (Options.UseWebSocketForQueriesAndMutations ||
+            !(Options.WebSocketEndPoint is null) && Options.EndPoint is null ||
+            Options.EndPoint.HasWebSocketScheme())
+            return await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken).ConfigureAwait(false);
 
-            return await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
-        }
+        return await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
+    }
 
-        /// <inheritdoc />
-        public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request,
-            CancellationToken cancellationToken = default)
-            => SendQueryAsync<TResponse>(request, cancellationToken);
+    /// <inheritdoc />
+    public Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(GraphQLRequest request,
+        CancellationToken cancellationToken = default)
+        => SendQueryAsync<TResponse>(request, cancellationToken);
 
-        /// <inheritdoc />
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request)
-            => CreateSubscriptionStream<TResponse>(request, null);
+    /// <inheritdoc />
+    public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request)
+        => CreateSubscriptionStream<TResponse>(request, null);
 
-        /// <inheritdoc />
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception>? exceptionHandler)
-        {
-            if (_disposed)
-                throw new ObjectDisposedException(nameof(GraphQLHttpClient));
+    /// <inheritdoc />
+    public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception>? exceptionHandler)
+    {
+        if (_disposed)
+            throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-            var observable = GraphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
-            return observable;
-        }
+        var observable = GraphQlHttpWebSocket.CreateSubscriptionStream<TResponse>(request, exceptionHandler);
+        return observable;
+    }
 
-        #endregion
+    #endregion
 
-        /// <summary>
-        /// Explicitly opens the websocket connection. Will be closed again on disposing the last subscription.
-        /// </summary>
-        /// <returns></returns>
-        public Task InitializeWebsocketConnection() => GraphQlHttpWebSocket.InitializeWebSocket();
+    /// <summary>
+    /// Explicitly opens the websocket connection. Will be closed again on disposing the last subscription.
+    /// </summary>
+    /// <returns></returns>
+    public Task InitializeWebsocketConnection() => GraphQlHttpWebSocket.InitializeWebSocket();
 
-        #region Private Methods
+    #region Private Methods
 
-        private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
-        {
-            var preprocessedRequest = await Options.PreprocessRequest(request, this).ConfigureAwait(false);
+    private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
+    {
+        var preprocessedRequest = await Options.PreprocessRequest(request, this).ConfigureAwait(false);
 
-            using var httpRequestMessage = preprocessedRequest.ToHttpRequestMessage(Options, JsonSerializer);
-            using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+        using var httpRequestMessage = preprocessedRequest.ToHttpRequestMessage(Options, JsonSerializer);
+        using var httpResponseMessage = await HttpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
 
-            var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
+        var contentStream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
 
-            if (Options.IsValidResponseToDeserialize(httpResponseMessage))
-            {
-                var graphQLResponse = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(contentStream, cancellationToken).ConfigureAwait(false);
-                return graphQLResponse.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
-            }
+        if (Options.IsValidResponseToDeserialize(httpResponseMessage))
+        {
+            var graphQLResponse = await JsonSerializer.DeserializeFromUtf8StreamAsync<TResponse>(contentStream, cancellationToken).ConfigureAwait(false);
+            return graphQLResponse.ToGraphQLHttpResponse(httpResponseMessage.Headers, httpResponseMessage.StatusCode);
+        }
 
-            // error handling
-            string content = null;
-            if (contentStream != null)
-                using (var sr = new StreamReader(contentStream))
-                    content = await sr.ReadToEndAsync().ConfigureAwait(false);
+        // error handling
+        string content = null;
+        if (contentStream != null)
+            using (var sr = new StreamReader(contentStream))
+                content = await sr.ReadToEndAsync().ConfigureAwait(false);
 
-            throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
-        }
+        throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
+    }
 
-        private GraphQLHttpWebSocket CreateGraphQLHttpWebSocket()
-        {
-            if(Options.WebSocketEndPoint is null && Options.EndPoint is null)
-                throw new InvalidOperationException("no endpoint configured");
+    private GraphQLHttpWebSocket CreateGraphQLHttpWebSocket()
+    {
+        if(Options.WebSocketEndPoint is null && Options.EndPoint is null)
+            throw new InvalidOperationException("no endpoint configured");
 
-            var webSocketEndpoint = Options.WebSocketEndPoint ?? Options.EndPoint.GetWebSocketUri();
-            if (!webSocketEndpoint.HasWebSocketScheme())
-                throw new InvalidOperationException($"uri \"{webSocketEndpoint}\" is not a websocket endpoint");
+        var webSocketEndpoint = Options.WebSocketEndPoint ?? Options.EndPoint.GetWebSocketUri();
+        if (!webSocketEndpoint.HasWebSocketScheme())
+            throw new InvalidOperationException($"uri \"{webSocketEndpoint}\" is not a websocket endpoint");
 
-            return new GraphQLHttpWebSocket(webSocketEndpoint, this);
-        }
+        return new GraphQLHttpWebSocket(webSocketEndpoint, this);
+    }
 
-        #endregion
+    #endregion
 
-        #region IDisposable
+    #region IDisposable
 
-        /// <summary>
-        /// Releases unmanaged resources
-        /// </summary>
-        public void Dispose()
+    /// <summary>
+    /// Releases unmanaged resources
+    /// </summary>
+    public void Dispose()
+    {
+        lock (_disposeLocker)
         {
-            lock (_disposeLocker)
+            if (!_disposed)
             {
-                if (!_disposed)
-                {
-                    _disposed = true;
-                    Dispose(true);
-                }
+                _disposed = true;
+                Dispose(true);
             }
         }
+    }
 
-        private volatile bool _disposed;
-        private readonly object _disposeLocker = new();
+    private volatile bool _disposed;
+    private readonly object _disposeLocker = new();
 
-        protected virtual void Dispose(bool disposing)
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
         {
-            if (disposing)
-            {
-                Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
-                _cancellationTokenSource.Cancel();
-                if(_disposeHttpClient)
-                    HttpClient.Dispose();
-                if ( _lazyHttpWebSocket.IsValueCreated )
-                    _lazyHttpWebSocket.Value.Dispose();
-                _cancellationTokenSource.Dispose();
-            }
+            Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
+            _cancellationTokenSource.Cancel();
+            if(_disposeHttpClient)
+                HttpClient.Dispose();
+            if ( _lazyHttpWebSocket.IsValueCreated )
+                _lazyHttpWebSocket.Value.Dispose();
+            _cancellationTokenSource.Dispose();
         }
-
-        #endregion
     }
+
+    #endregion
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
index c3f49dfb..1da01413 100644
--- a/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientExtensions.cs
@@ -1,45 +1,44 @@
 using System.Net.WebSockets;
 using GraphQL.Client.Abstractions;
 
-namespace GraphQL.Client.Http
-{
-    public static class GraphQLHttpClientExtensions
-    {
-        /// <summary>
-        /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
-        /// All subscriptions made to this stream share the same hot observable.<br/>
-        /// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
-        /// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
-        /// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
-        /// </summary>
-        /// <param name="client">the GraphQL client</param>
-        /// <param name="request">the GraphQL request for this subscription</param>
-        /// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occurring within the sequence</param>
-        /// <returns>an observable stream for the specified subscription</returns>
-        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(this IGraphQLClient client,
-            GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) =>
-            client.CreateSubscriptionStream<TResponse>(request, e =>
-            {
-                if (e is WebSocketException webSocketException)
-                    webSocketExceptionHandler(webSocketException);
-                else
-                    throw e;
-            });
+namespace GraphQL.Client.Http;
 
-        /// <inheritdoc cref="CreateSubscriptionStream{TResponse}(IGraphQLClient,GraphQLRequest,Action{WebSocketException})"/>
-        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
+public static class GraphQLHttpClientExtensions
+{
+    /// <summary>
+    /// Creates a subscription to a GraphQL server. The connection is not established until the first actual subscription is made.<br/>
+    /// All subscriptions made to this stream share the same hot observable.<br/>
+    /// All <see cref="WebSocketException"/>s are passed to the <paramref name="webSocketExceptionHandler"/> to be handled externally.<br/>
+    /// If the <paramref name="webSocketExceptionHandler"/> completes normally, the subscription is recreated with a new connection attempt.<br/>
+    /// Other <see cref="Exception"/>s or any exception thrown by <paramref name="webSocketExceptionHandler"/> will cause the sequence to fail.
+    /// </summary>
+    /// <param name="client">the GraphQL client</param>
+    /// <param name="request">the GraphQL request for this subscription</param>
+    /// <param name="webSocketExceptionHandler">an external handler for all <see cref="WebSocketException"/>s occurring within the sequence</param>
+    /// <returns>an observable stream for the specified subscription</returns>
+    public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(this IGraphQLClient client,
+        GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler) =>
+        client.CreateSubscriptionStream<TResponse>(request, e =>
         {
-            _ = defineResponseType;
-            return client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
-        }
+            if (e is WebSocketException webSocketException)
+                webSocketExceptionHandler(webSocketException);
+            else
+                throw e;
+        });
 
-        /// <inheritdoc cref="GraphQLHttpClient.CreateSubscriptionStream{TResponse}(GraphQLRequest)"/>
-        public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
-            this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
-        {
-            _ = defineResponseType;
-            return client.CreateSubscriptionStream<TResponse>(request);
-        }
+    /// <inheritdoc cref="CreateSubscriptionStream{TResponse}(IGraphQLClient,GraphQLRequest,Action{WebSocketException})"/>
+    public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+        this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType, Action<WebSocketException> webSocketExceptionHandler)
+    {
+        _ = defineResponseType;
+        return client.CreateSubscriptionStream<TResponse>(request, webSocketExceptionHandler);
+    }
+
+    /// <inheritdoc cref="GraphQLHttpClient.CreateSubscriptionStream{TResponse}(GraphQLRequest)"/>
+    public static IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(
+        this IGraphQLClient client, GraphQLRequest request, Func<TResponse> defineResponseType)
+    {
+        _ = defineResponseType;
+        return client.CreateSubscriptionStream<TResponse>(request);
     }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index acbdfaab..12fad5e3 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -2,73 +2,72 @@
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
 
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http;
+
+/// <summary>
+/// The Options that the <see cref="GraphQLHttpClient"/> will use.
+/// </summary>
+public class GraphQLHttpClientOptions
 {
     /// <summary>
-    /// The Options that the <see cref="GraphQLHttpClient"/> will use.
+    /// The GraphQL EndPoint to be used
     /// </summary>
-    public class GraphQLHttpClientOptions
-    {
-        /// <summary>
-        /// The GraphQL EndPoint to be used
-        /// </summary>
-        public Uri? EndPoint { get; set; }
+    public Uri? EndPoint { get; set; }
 
-        /// <summary>
-        /// The GraphQL EndPoint to be used for websocket connections
-        /// </summary>
-        public Uri? WebSocketEndPoint { get; set; }
+    /// <summary>
+    /// The GraphQL EndPoint to be used for websocket connections
+    /// </summary>
+    public Uri? WebSocketEndPoint { get; set; }
 
-        /// <summary>
-        /// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
-        /// </summary>
-        public HttpMessageHandler HttpMessageHandler { get; set; } = new HttpClientHandler();
+    /// <summary>
+    /// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
+    /// </summary>
+    public HttpMessageHandler HttpMessageHandler { get; set; } = new HttpClientHandler();
 
-        /// <summary>
-        /// The <see cref="MediaTypeHeaderValue"/> that will be send on POST
-        /// </summary>
-        public string MediaType { get; set; } = "application/json"; // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
+    /// <summary>
+    /// The <see cref="MediaTypeHeaderValue"/> that will be send on POST
+    /// </summary>
+    public string MediaType { get; set; } = "application/json"; // This should be "application/graphql" also "application/x-www-form-urlencoded" is Accepted
 
-        /// <summary>
-        /// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
-        /// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
-        /// </summary>
-        public Func<int, TimeSpan> BackOffStrategy { get; set; } = n =>
-        {
-            var rnd = new Random();
-            return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
-        };
+    /// <summary>
+    /// The back-off strategy for automatic websocket/subscription reconnects. Calculates the delay before the next connection attempt is made.<br/>
+    /// default formula: min(n, 5) * 1,5 * random(0.0, 1.0)
+    /// </summary>
+    public Func<int, TimeSpan> BackOffStrategy { get; set; } = n =>
+    {
+        var rnd = new Random();
+        return TimeSpan.FromSeconds(Math.Min(n, 5) * 1.5 + rnd.NextDouble());
+    };
 
-        /// <summary>
-        /// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
-        /// </summary>
-        public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
+    /// <summary>
+    /// If <see langword="true"/>, the websocket connection is also used for regular queries and mutations
+    /// </summary>
+    public bool UseWebSocketForQueriesAndMutations { get; set; } = false;
 
-        /// <summary>
-        /// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
-        /// </summary>
-        public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLHttpRequest>> PreprocessRequest { get; set; } = (request, client) =>
-            Task.FromResult(request is GraphQLHttpRequest graphQLHttpRequest ? graphQLHttpRequest : new GraphQLHttpRequest(request));
+    /// <summary>
+    /// Request preprocessing function. Can be used i.e. to inject authorization info into a GraphQL request payload.
+    /// </summary>
+    public Func<GraphQLRequest, GraphQLHttpClient, Task<GraphQLHttpRequest>> PreprocessRequest { get; set; } = (request, client) =>
+        Task.FromResult(request is GraphQLHttpRequest graphQLHttpRequest ? graphQLHttpRequest : new GraphQLHttpRequest(request));
 
-        /// <summary>
-        /// Delegate to determine if GraphQL response may be properly deserialized into <see cref="GraphQLResponse{T}"/>.
-        /// </summary>
-        public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = r => r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest;
+    /// <summary>
+    /// Delegate to determine if GraphQL response may be properly deserialized into <see cref="GraphQLResponse{T}"/>.
+    /// </summary>
+    public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = r => r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest;
 
-        /// <summary>
-        /// This callback is called after successfully establishing a websocket connection but before any regular request is made.
-        /// </summary>
-        public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
+    /// <summary>
+    /// This callback is called after successfully establishing a websocket connection but before any regular request is made.
+    /// </summary>
+    public Func<GraphQLHttpClient, Task> OnWebsocketConnected { get; set; } = client => Task.CompletedTask;
 
-        /// <summary>
-        /// Configure additional websocket options (i.e. headers). This will not be invoked on Windows 7 when targeting .NET Framework 4.x.
-        /// </summary>
-        public Action<ClientWebSocketOptions> ConfigureWebsocketOptions { get; set; } = options => { };
+    /// <summary>
+    /// Configure additional websocket options (i.e. headers). This will not be invoked on Windows 7 when targeting .NET Framework 4.x.
+    /// </summary>
+    public Action<ClientWebSocketOptions> ConfigureWebsocketOptions { get; set; } = options => { };
 
-        /// <summary>
-        /// Sets the `ConnectionParams` object sent with the GQL_CONNECTION_INIT message on establishing a GraphQL websocket connection.
-        /// See https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_connection_init.
-        /// </summary>
-        public Func<GraphQLHttpClientOptions, object?> ConfigureWebSocketConnectionInitPayload { get; set; } = options => null;
-    }
+    /// <summary>
+    /// Sets the `ConnectionParams` object sent with the GQL_CONNECTION_INIT message on establishing a GraphQL websocket connection.
+    /// See https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_connection_init.
+    /// </summary>
+    public Func<GraphQLHttpClientOptions, object?> ConfigureWebSocketConnectionInitPayload { get; set; } = options => null;
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index ac62c6a8..b0591e57 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -2,47 +2,46 @@
 using System.Text;
 using GraphQL.Client.Abstractions;
 
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http;
+
+public class GraphQLHttpRequest : GraphQLRequest
 {
-    public class GraphQLHttpRequest : GraphQLRequest
+    public GraphQLHttpRequest()
     {
-        public GraphQLHttpRequest()
-        {
-        }
+    }
 
-        public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null) : base(query, variables, operationName)
-        {
-        }
+    public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null) : base(query, variables, operationName)
+    {
+    }
 
-        public GraphQLHttpRequest(GraphQLRequest other): base(other)
-        {
-        }
+    public GraphQLHttpRequest(GraphQLRequest other): base(other)
+    {
+    }
 
-        /// <summary>
-        /// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
-        /// </summary>
-        [IgnoreDataMember]
-        [Obsolete("Inherit from GraphQLHttpRequest and override ToHttpRequestMessage() to customize the HttpRequestMessage. Will be removed in v4.0.0.")]
-        public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
+    /// <summary>
+    /// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
+    /// </summary>
+    [IgnoreDataMember]
+    [Obsolete("Inherit from GraphQLHttpRequest and override ToHttpRequestMessage() to customize the HttpRequestMessage. Will be removed in v4.0.0.")]
+    public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
 
-        /// <summary>
-        /// Creates a <see cref="HttpRequestMessage"/> from this <see cref="GraphQLHttpRequest"/>.
-        /// Used by <see cref="GraphQLHttpClient"/> to convert GraphQL requests when sending them as regular HTTP requests.
-        /// </summary>
-        /// <param name="options">the <see cref="GraphQLHttpClientOptions"/> passed from <see cref="GraphQLHttpClient"/></param>
-        /// <param name="serializer">the <see cref="IGraphQLJsonSerializer"/> passed from <see cref="GraphQLHttpClient"/></param>
-        /// <returns></returns>
-        public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions options, IGraphQLJsonSerializer serializer)
+    /// <summary>
+    /// Creates a <see cref="HttpRequestMessage"/> from this <see cref="GraphQLHttpRequest"/>.
+    /// Used by <see cref="GraphQLHttpClient"/> to convert GraphQL requests when sending them as regular HTTP requests.
+    /// </summary>
+    /// <param name="options">the <see cref="GraphQLHttpClientOptions"/> passed from <see cref="GraphQLHttpClient"/></param>
+    /// <param name="serializer">the <see cref="IGraphQLJsonSerializer"/> passed from <see cref="GraphQLHttpClient"/></param>
+    /// <returns></returns>
+    public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions options, IGraphQLJsonSerializer serializer)
+    {
+        var message = new HttpRequestMessage(HttpMethod.Post, options.EndPoint)
         {
-            var message = new HttpRequestMessage(HttpMethod.Post, options.EndPoint)
-            {
-                Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
-            };
+            Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
+        };
 
 #pragma warning disable CS0618 // Type or member is obsolete
-            PreprocessHttpRequestMessage(message);
+        PreprocessHttpRequestMessage(message);
 #pragma warning restore CS0618 // Type or member is obsolete
-            return message;
-        }
+        return message;
     }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequestException.cs b/src/GraphQL.Client/GraphQLHttpRequestException.cs
index faf7e6c5..808f1417 100644
--- a/src/GraphQL.Client/GraphQLHttpRequestException.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequestException.cs
@@ -1,40 +1,38 @@
 using System.Net;
 using System.Net.Http.Headers;
 
-namespace GraphQL.Client.Http
-{
+namespace GraphQL.Client.Http;
 
+/// <summary>
+/// An exception thrown on unexpected <see cref="System.Net.Http.HttpResponseMessage"/>
+/// </summary>
+public class GraphQLHttpRequestException : Exception
+{
     /// <summary>
-    /// An exception thrown on unexpected <see cref="System.Net.Http.HttpResponseMessage"/>
+    /// The returned status code
     /// </summary>
-    public class GraphQLHttpRequestException : Exception
-    {
-        /// <summary>
-        /// The returned status code
-        /// </summary>
-        public HttpStatusCode StatusCode { get; }
+    public HttpStatusCode StatusCode { get; }
 
-        /// <summary>
-        /// the returned response headers
-        /// </summary>
-        public HttpResponseHeaders ResponseHeaders { get; }
+    /// <summary>
+    /// the returned response headers
+    /// </summary>
+    public HttpResponseHeaders ResponseHeaders { get; }
 
-        /// <summary>
-        /// the returned content
-        /// </summary>
-        public string? Content { get; }
+    /// <summary>
+    /// the returned content
+    /// </summary>
+    public string? Content { get; }
 
-        /// <summary>
-        /// Creates a new instance of <see cref="GraphQLHttpRequestException"/>
-        /// </summary>
-        /// <param name="statusCode"></param>
-        /// <param name="responseHeaders"></param>
-        /// <param name="content"></param>
-        public GraphQLHttpRequestException(HttpStatusCode statusCode, HttpResponseHeaders responseHeaders, string? content) : base($"The HTTP request failed with status code {statusCode}")
-        {
-            StatusCode = statusCode;
-            ResponseHeaders = responseHeaders;
-            Content = content;
-        }
+    /// <summary>
+    /// Creates a new instance of <see cref="GraphQLHttpRequestException"/>
+    /// </summary>
+    /// <param name="statusCode"></param>
+    /// <param name="responseHeaders"></param>
+    /// <param name="content"></param>
+    public GraphQLHttpRequestException(HttpStatusCode statusCode, HttpResponseHeaders responseHeaders, string? content) : base($"The HTTP request failed with status code {statusCode}")
+    {
+        StatusCode = statusCode;
+        ResponseHeaders = responseHeaders;
+        Content = content;
     }
 }
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index 8888ff61..cebada2e 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -1,35 +1,34 @@
 using System.Net;
 using System.Net.Http.Headers;
 
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http;
+
+public class GraphQLHttpResponse<T> : GraphQLResponse<T>
 {
-    public class GraphQLHttpResponse<T> : GraphQLResponse<T>
+    public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode)
     {
-        public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode)
-        {
-            Data = response.Data;
-            Errors = response.Errors;
-            Extensions = response.Extensions;
-            ResponseHeaders = responseHeaders;
-            StatusCode = statusCode;
-        }
+        Data = response.Data;
+        Errors = response.Errors;
+        Extensions = response.Extensions;
+        ResponseHeaders = responseHeaders;
+        StatusCode = statusCode;
+    }
 
-        public HttpResponseHeaders ResponseHeaders { get; set; }
+    public HttpResponseHeaders ResponseHeaders { get; set; }
 
-        public HttpStatusCode StatusCode { get; set; }
-    }
+    public HttpStatusCode StatusCode { get; set; }
+}
 
-    public static class GraphQLResponseExtensions
-    {
-        public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) => new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
+public static class GraphQLResponseExtensions
+{
+    public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) => new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
 
-        /// <summary>
-        /// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws if the cast fails.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="response"></param>
-        /// <exception cref="InvalidCastException"><paramref name="response"/> is not a <see cref="GraphQLHttpResponse{T}"/></exception>
-        /// <returns></returns>
-        public static GraphQLHttpResponse<T> AsGraphQLHttpResponse<T>(this GraphQLResponse<T> response) => (GraphQLHttpResponse<T>)response;
-    }
+    /// <summary>
+    /// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws if the cast fails.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="response"></param>
+    /// <exception cref="InvalidCastException"><paramref name="response"/> is not a <see cref="GraphQLHttpResponse{T}"/></exception>
+    /// <returns></returns>
+    public static GraphQLHttpResponse<T> AsGraphQLHttpResponse<T>(this GraphQLResponse<T> response) => (GraphQLHttpResponse<T>)response;
 }
diff --git a/src/GraphQL.Client/GraphQLSubscriptionException.cs b/src/GraphQL.Client/GraphQLSubscriptionException.cs
index 28e8566c..ccaab426 100644
--- a/src/GraphQL.Client/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client/GraphQLSubscriptionException.cs
@@ -1,29 +1,28 @@
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http;
+
+[Serializable]
+public class GraphQLSubscriptionException : Exception
 {
-    [Serializable]
-    public class GraphQLSubscriptionException : Exception
-    {
-        //
-        // For guidelines regarding the creation of new exception types, see
-        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
-        // and
-        //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
-        //
+    //
+    // For guidelines regarding the creation of new exception types, see
+    //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+    // and
+    //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+    //
 
-        public GraphQLSubscriptionException()
-        {
-        }
+    public GraphQLSubscriptionException()
+    {
+    }
 
-        public GraphQLSubscriptionException(object error) : base(error.ToString())
-        {
-        }
+    public GraphQLSubscriptionException(object error) : base(error.ToString())
+    {
+    }
 
-        protected GraphQLSubscriptionException(
-            SerializationInfo info,
-            StreamingContext context) : base(info, context)
-        {
-        }
+    protected GraphQLSubscriptionException(
+        SerializationInfo info,
+        StreamingContext context) : base(info, context)
+    {
     }
 }
diff --git a/src/GraphQL.Client/UriExtensions.cs b/src/GraphQL.Client/UriExtensions.cs
index 1e2e53e2..47f5841c 100644
--- a/src/GraphQL.Client/UriExtensions.cs
+++ b/src/GraphQL.Client/UriExtensions.cs
@@ -1,39 +1,38 @@
-namespace GraphQL.Client.Http
+namespace GraphQL.Client.Http;
+
+public static class UriExtensions
 {
-    public static class UriExtensions
-    {
-        /// <summary>
-        /// Returns true if <see cref="Uri.Scheme"/> equals "wss" or "ws"
-        /// </summary>
-        /// <param name="uri"></param>
-        /// <returns></returns>
-        public static bool HasWebSocketScheme(this Uri? uri) =>
-            !(uri is null) &&
-            (uri.Scheme.Equals("wss", StringComparison.OrdinalIgnoreCase) || uri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase));
+    /// <summary>
+    /// Returns true if <see cref="Uri.Scheme"/> equals "wss" or "ws"
+    /// </summary>
+    /// <param name="uri"></param>
+    /// <returns></returns>
+    public static bool HasWebSocketScheme(this Uri? uri) =>
+        !(uri is null) &&
+        (uri.Scheme.Equals("wss", StringComparison.OrdinalIgnoreCase) || uri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase));
 
-        /// <summary>
-        /// Infers the websocket uri from <paramref name="uri"/>.
-        /// </summary>
-        /// <param name="uri"></param>
-        /// <returns></returns>
-        public static Uri GetWebSocketUri(this Uri uri)
-        {
-            if (uri is null)
-                throw new ArgumentNullException(nameof(uri));
+    /// <summary>
+    /// Infers the websocket uri from <paramref name="uri"/>.
+    /// </summary>
+    /// <param name="uri"></param>
+    /// <returns></returns>
+    public static Uri GetWebSocketUri(this Uri uri)
+    {
+        if (uri is null)
+            throw new ArgumentNullException(nameof(uri));
 
-            if (uri.HasWebSocketScheme())
-                return uri;
+        if (uri.HasWebSocketScheme())
+            return uri;
 
-            string webSocketScheme;
+        string webSocketScheme;
 
-            if (uri.Scheme == Uri.UriSchemeHttps)
-                webSocketScheme = "wss";
-            else if (uri.Scheme == Uri.UriSchemeHttp)
-                webSocketScheme = "ws";
-            else
-                throw new NotSupportedException($"cannot infer websocket uri from uri scheme {uri.Scheme}");
+        if (uri.Scheme == Uri.UriSchemeHttps)
+            webSocketScheme = "wss";
+        else if (uri.Scheme == Uri.UriSchemeHttp)
+            webSocketScheme = "ws";
+        else
+            throw new NotSupportedException($"cannot infer websocket uri from uri scheme {uri.Scheme}");
 
-            return new UriBuilder(uri){Scheme = webSocketScheme}.Uri;
-        }
+        return new UriBuilder(uri){Scheme = webSocketScheme}.Uri;
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 0aa60818..28b721eb 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -8,370 +8,370 @@
 using System.Text;
 using GraphQL.Client.Abstractions.Websocket;
 
-namespace GraphQL.Client.Http.Websocket
+namespace GraphQL.Client.Http.Websocket;
+
+internal class GraphQLHttpWebSocket : IDisposable
 {
-    internal class GraphQLHttpWebSocket : IDisposable
-    {
 
-        #region Private fields
+    #region Private fields
 
-        private readonly Uri _webSocketUri;
-        private readonly GraphQLHttpClient _client;
-        private readonly ArraySegment<byte> _buffer;
-        private readonly CancellationTokenSource _internalCancellationTokenSource = new CancellationTokenSource();
-        private readonly CancellationToken _internalCancellationToken;
-        private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
-        private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
-        private readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject =
-            new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
-        private readonly IDisposable _requestSubscription;
+    private readonly Uri _webSocketUri;
+    private readonly GraphQLHttpClient _client;
+    private readonly ArraySegment<byte> _buffer;
+    private readonly CancellationTokenSource _internalCancellationTokenSource = new CancellationTokenSource();
+    private readonly CancellationToken _internalCancellationToken;
+    private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+    private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
+    private readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject =
+        new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
+    private readonly IDisposable _requestSubscription;
 
-        private int _connectionAttempt = 0;
-        private IConnectableObservable<WebsocketMessageWrapper> _incomingMessages;
-        private IDisposable _incomingMessagesConnection;
-        private GraphQLHttpClientOptions Options => _client.Options;
+    private int _connectionAttempt = 0;
+    private IConnectableObservable<WebsocketMessageWrapper> _incomingMessages;
+    private IDisposable _incomingMessagesConnection;
+    private GraphQLHttpClientOptions Options => _client.Options;
 
-        private Task _initializeWebSocketTask = Task.CompletedTask;
-        private readonly object _initializeLock = new object();
+    private Task _initializeWebSocketTask = Task.CompletedTask;
+    private readonly object _initializeLock = new object();
 
 #if NETFRAMEWORK
 		private WebSocket _clientWebSocket = null;
 #else
-        private ClientWebSocket _clientWebSocket = null;
+    private ClientWebSocket _clientWebSocket = null;
 #endif
 
-        #endregion
+    #endregion
 
-        #region Public properties
+    #region Public properties
 
-        /// <summary>
-        /// The current websocket state
-        /// </summary>
-        public WebSocketState WebSocketState => _clientWebSocket?.State ?? WebSocketState.None;
+    /// <summary>
+    /// The current websocket state
+    /// </summary>
+    public WebSocketState WebSocketState => _clientWebSocket?.State ?? WebSocketState.None;
 
-        /// <summary>
-        /// Publishes all errors which occur within the receive pipeline
-        /// </summary>
-        public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
+    /// <summary>
+    /// Publishes all errors which occur within the receive pipeline
+    /// </summary>
+    public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
 
-        /// <summary>
-        /// Publishes the connection state of the <see cref="GraphQLHttpWebSocket"/>
-        /// </summary>
-        public IObservable<GraphQLWebsocketConnectionState> ConnectionState => _stateSubject.DistinctUntilChanged();
+    /// <summary>
+    /// Publishes the connection state of the <see cref="GraphQLHttpWebSocket"/>
+    /// </summary>
+    public IObservable<GraphQLWebsocketConnectionState> ConnectionState => _stateSubject.DistinctUntilChanged();
 
-        /// <summary>
-        /// Publishes all messages which are received on the websocket
-        /// </summary>
-        public IObservable<WebsocketMessageWrapper> IncomingMessageStream { get; }
+    /// <summary>
+    /// Publishes all messages which are received on the websocket
+    /// </summary>
+    public IObservable<WebsocketMessageWrapper> IncomingMessageStream { get; }
 
-        #endregion
+    #endregion
 
-        public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
-        {
-            _internalCancellationToken = _internalCancellationTokenSource.Token;
-            _webSocketUri = webSocketUri;
-            _client = client;
-            _buffer = new ArraySegment<byte>(new byte[8192]);
-            IncomingMessageStream = GetMessageStream();
-
-            _requestSubscription = _requestSubject
-                .Select(request => Observable.FromAsync(() => SendWebSocketRequestAsync(request)))
-                .Concat()
-                .Subscribe();
-        }
+    public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
+    {
+        _internalCancellationToken = _internalCancellationTokenSource.Token;
+        _webSocketUri = webSocketUri;
+        _client = client;
+        _buffer = new ArraySegment<byte>(new byte[8192]);
+        IncomingMessageStream = GetMessageStream();
+
+        _requestSubscription = _requestSubject
+            .Select(request => Observable.FromAsync(() => SendWebSocketRequestAsync(request)))
+            .Concat()
+            .Subscribe();
+    }
 
-        #region Send requests
-
-        /// <summary>
-        /// Create a new subscription stream
-        /// </summary>
-        /// <typeparam name="TResponse">the response type</typeparam>
-        /// <param name="request">the <see cref="GraphQLRequest"/> to start the subscription</param>
-        /// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
-        /// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
-        public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception>? exceptionHandler = null) =>
-            Observable.Defer(() =>
-                    Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+    #region Send requests
+
+    /// <summary>
+    /// Create a new subscription stream
+    /// </summary>
+    /// <typeparam name="TResponse">the response type</typeparam>
+    /// <param name="request">the <see cref="GraphQLRequest"/> to start the subscription</param>
+    /// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
+    /// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
+    public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception>? exceptionHandler = null) =>
+        Observable.Defer(() =>
+                Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+                {
+                    Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
+                    var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
+
+                    var startRequest = new GraphQLWebSocketRequest
+                    {
+                        Id = Guid.NewGuid().ToString("N"),
+                        Type = GraphQLWebSocketMessageType.GQL_START,
+                        Payload = preprocessedRequest
+                    };
+                    var stopRequest = new GraphQLWebSocketRequest
                     {
-                        Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
-                        var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
+                        Id = startRequest.Id,
+                        Type = GraphQLWebSocketMessageType.GQL_STOP
+                    };
 
-                        var startRequest = new GraphQLWebSocketRequest
-                        {
-                            Id = Guid.NewGuid().ToString("N"),
-                            Type = GraphQLWebSocketMessageType.GQL_START,
-                            Payload = preprocessedRequest
-                        };
-                        var stopRequest = new GraphQLWebSocketRequest
-                        {
-                            Id = startRequest.Id,
-                            Type = GraphQLWebSocketMessageType.GQL_STOP
-                        };
-
-                        var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
-                            IncomingMessageStream
-                                // ignore null values and messages for other requests
-                                .Where(response => response != null && response.Id == startRequest.Id)
-                                .Subscribe(response =>
-                                    {
-                                        // terminate the sequence when a 'complete' message is received
-                                        if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-                                        {
-                                            Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-                                            o.OnCompleted();
-                                            return;
-                                        }
-
-                                        // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-                                        Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
-                                        var typedResponse =
-                                            _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-                                                response.MessageBytes);
-                                        Debug.WriteLine($"payload => {System.Text.Encoding.UTF8.GetString(response.MessageBytes)}");
-                                        o.OnNext(typedResponse.Payload);
-
-                                        // in case of a GraphQL error, terminate the sequence after the response has been posted
-                                        if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
-                                        {
-                                            Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
-                                            o.OnCompleted();
-                                        }
-                                    },
-                                    e =>
+                    var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
+                        IncomingMessageStream
+                            // ignore null values and messages for other requests
+                            .Where(response => response != null && response.Id == startRequest.Id)
+                            .Subscribe(response =>
+                                {
+                                    // terminate the sequence when a 'complete' message is received
+                                    if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
                                     {
-                                        Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
-                                        o.OnError(e);
-                                    },
-                                    () =>
+                                        Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+                                        o.OnCompleted();
+                                        return;
+                                    }
+
+                                    // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+                                    Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+                                    var typedResponse =
+                                        _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                                            response.MessageBytes);
+                                    Debug.WriteLine($"payload => {System.Text.Encoding.UTF8.GetString(response.MessageBytes)}");
+                                    o.OnNext(typedResponse.Payload);
+
+                                    // in case of a GraphQL error, terminate the sequence after the response has been posted
+                                    if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
                                     {
-                                        Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+                                        Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
                                         o.OnCompleted();
-                                    })
-                        );
+                                    }
+                                },
+                                e =>
+                                {
+                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
+                                    o.OnError(e);
+                                },
+                                () =>
+                                {
+                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+                                    o.OnCompleted();
+                                })
+                    );
 
-                        try
-                        {
-                            // initialize websocket (completes immediately if socket is already open)
-                            await InitializeWebSocket().ConfigureAwait(false);
-                        }
-                        catch (Exception e)
+                    try
+                    {
+                        // initialize websocket (completes immediately if socket is already open)
+                        await InitializeWebSocket().ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        // subscribe observer to failed observable
+                        return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+                    }
+
+                    var disposable = new CompositeDisposable(
+                        observable.Subscribe(observer),
+                        Disposable.Create(async () =>
                         {
-                            // subscribe observer to failed observable
-                            return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-                        }
+                            Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{WebSocketState}'");
+                            // only try to send close request on open websocket
+                            if (WebSocketState != WebSocketState.Open)
+                                return;
 
-                        var disposable = new CompositeDisposable(
-                            observable.Subscribe(observer),
-                            Disposable.Create(async () =>
+                            try
                             {
-                                Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{WebSocketState}'");
-                                // only try to send close request on open websocket
-                                if (WebSocketState != WebSocketState.Open)
-                                    return;
-
-                                try
-                                {
-                                    Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
-                                    await QueueWebSocketRequest(stopRequest).ConfigureAwait(false);
-                                }
-                                // do not break on disposing
-                                catch (OperationCanceledException) { }
-                            })
-                        );
-
-                        Debug.WriteLine($"sending start message on subscription {startRequest.Id}");
-                        // send subscription request
-                        try
-                        {
-                            await QueueWebSocketRequest(startRequest).ConfigureAwait(false);
-                        }
-                        catch (Exception e)
-                        {
-                            Debug.WriteLine(e);
-                            throw;
-                        }
-
-                        return disposable;
-                    }))
-                // complete sequence on OperationCanceledException, this is triggered by the cancellation token
-                .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-                    Observable.Empty<GraphQLResponse<TResponse>>())
-                // wrap results
-                .Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
-                // do exception handling
-                .Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e =>
-                {
+                                Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
+                                await QueueWebSocketRequest(stopRequest).ConfigureAwait(false);
+                            }
+                            // do not break on disposing
+                            catch (OperationCanceledException) { }
+                        })
+                    );
+
+                    Debug.WriteLine($"sending start message on subscription {startRequest.Id}");
+                    // send subscription request
                     try
                     {
-                        if (exceptionHandler == null)
-                        {
-                            // if the external handler is not set, propagate all exceptions except WebSocketExceptions
-                            // this will ensure that the client tries to re-establish subscriptions on connection loss
-                            if (!(e is WebSocketException))
-                                throw e;
-                        }
-                        else
-                        {
-                            // exceptions thrown by the handler will propagate to OnError()
-                            exceptionHandler?.Invoke(e);
-                        }
-
-                        // throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
-                        if (_internalCancellationToken.IsCancellationRequested)
-                            return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
-                        else
-                        {
-                            Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
-                            return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
-                        }
+                        await QueueWebSocketRequest(startRequest).ConfigureAwait(false);
                     }
-                    catch (Exception exception)
+                    catch (Exception e)
                     {
-                        // wrap all other exceptions to be propagated behind retry
-                        return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
+                        Debug.WriteLine(e);
+                        throw;
                     }
-                })
-                // attempt to recreate the websocket for rethrown exceptions
-                .Retry()
-                // unwrap and push results or throw wrapped exceptions
-                .SelectMany(t =>
+
+                    return disposable;
+                }))
+            // complete sequence on OperationCanceledException, this is triggered by the cancellation token
+            .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+                Observable.Empty<GraphQLResponse<TResponse>>())
+            // wrap results
+            .Select(response => new Tuple<GraphQLResponse<TResponse>, Exception>(response, null))
+            // do exception handling
+            .Catch<Tuple<GraphQLResponse<TResponse>, Exception>, Exception>(e =>
+            {
+                try
                 {
-                    // if the result contains an exception, throw it on the observable
-                    if (t.Item2 != null)
+                    if (exceptionHandler == null)
                     {
-                        Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId} => {t.Item2}");
-                        return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
+                        // if the external handler is not set, propagate all exceptions except WebSocketExceptions
+                        // this will ensure that the client tries to re-establish subscriptions on connection loss
+                        if (!(e is WebSocketException))
+                            throw e;
                     }
-                    if (t.Item1 == null)
+                    else
                     {
-                        Debug.WriteLine($"empty item thread id: {Thread.CurrentThread.ManagedThreadId}");
-                        return Observable.Empty<GraphQLResponse<TResponse>>();
+                        // exceptions thrown by the handler will propagate to OnError()
+                        exceptionHandler?.Invoke(e);
                     }
-                    return Observable.Return(t.Item1);
-                });
-        /// <summary>
-        /// Send a regular GraphQL request (query, mutation) via websocket
-        /// </summary>
-        /// <typeparam name="TResponse">the response type</typeparam>
-        /// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
-        /// <param name="cancellationToken">the token to cancel the request</param>
-        /// <returns></returns>
-        public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-            Observable.Create<GraphQLResponse<TResponse>>(async observer =>
-            {
-                var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
-                var websocketRequest = new GraphQLWebSocketRequest
-                {
-                    Id = Guid.NewGuid().ToString("N"),
-                    Type = GraphQLWebSocketMessageType.GQL_START,
-                    Payload = preprocessedRequest
-                };
-                var observable = IncomingMessageStream
-                    .Where(response => response != null && response.Id == websocketRequest.Id)
-                    .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-                    .Select(response =>
-                    {
-                        Debug.WriteLine($"received response for request {websocketRequest.Id}");
-                        var typedResponse =
-                            _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-                                response.MessageBytes);
-                        return typedResponse.Payload;
-                    });
 
-                try
-                {
-                    // initialize websocket (completes immediately if socket is already open)
-                    await InitializeWebSocket().ConfigureAwait(false);
+                    // throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
+                    if (_internalCancellationToken.IsCancellationRequested)
+                        return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
+                    else
+                    {
+                        Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
+                        return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
+                    }
                 }
-                catch (Exception e)
+                catch (Exception exception)
                 {
-                    // subscribe observer to failed observable
-                    return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+                    // wrap all other exceptions to be propagated behind retry
+                    return Observable.Return(new Tuple<GraphQLResponse<TResponse>, Exception>(null, exception));
                 }
-
-                var disposable = new CompositeDisposable(
-                    observable.Subscribe(observer)
-                );
-
-                Debug.WriteLine($"submitting request {websocketRequest.Id}");
-                // send request
-                try
+            })
+            // attempt to recreate the websocket for rethrown exceptions
+            .Retry()
+            // unwrap and push results or throw wrapped exceptions
+            .SelectMany(t =>
+            {
+                // if the result contains an exception, throw it on the observable
+                if (t.Item2 != null)
                 {
-                    await QueueWebSocketRequest(websocketRequest).ConfigureAwait(false);
+                    Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId} => {t.Item2}");
+                    return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
                 }
-                catch (Exception e)
+                if (t.Item1 == null)
                 {
-                    Debug.WriteLine(e);
-                    throw;
+                    Debug.WriteLine($"empty item thread id: {Thread.CurrentThread.ManagedThreadId}");
+                    return Observable.Empty<GraphQLResponse<TResponse>>();
                 }
-
-                return disposable;
-            })
-                // complete sequence on OperationCanceledException, this is triggered by the cancellation token
-                .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-                    Observable.Empty<GraphQLResponse<TResponse>>())
-                .FirstAsync()
-                .ToTask(cancellationToken);
-
-        private Task QueueWebSocketRequest(GraphQLWebSocketRequest request)
-        {
-            _requestSubject.OnNext(request);
-            return request.SendTask();
-        }
-
-        private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
+                return Observable.Return(t.Item1);
+            });
+    /// <summary>
+    /// Send a regular GraphQL request (query, mutation) via websocket
+    /// </summary>
+    /// <typeparam name="TResponse">the response type</typeparam>
+    /// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
+    /// <param name="cancellationToken">the token to cancel the request</param>
+    /// <returns></returns>
+    public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) =>
+        Observable.Create<GraphQLResponse<TResponse>>(async observer =>
         {
-            try
+            var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
+            var websocketRequest = new GraphQLWebSocketRequest
             {
-                if (_internalCancellationToken.IsCancellationRequested)
+                Id = Guid.NewGuid().ToString("N"),
+                Type = GraphQLWebSocketMessageType.GQL_START,
+                Payload = preprocessedRequest
+            };
+            var observable = IncomingMessageStream
+                .Where(response => response != null && response.Id == websocketRequest.Id)
+                .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                .Select(response =>
                 {
-                    request.SendCanceled();
-                    return Unit.Default;
-                }
+                    Debug.WriteLine($"received response for request {websocketRequest.Id}");
+                    var typedResponse =
+                        _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
+                            response.MessageBytes);
+                    return typedResponse.Payload;
+                });
 
+            try
+            {
+                // initialize websocket (completes immediately if socket is already open)
                 await InitializeWebSocket().ConfigureAwait(false);
-                await SendWebSocketMessageAsync(request, _internalCancellationToken).ConfigureAwait(false);
-                request.SendCompleted();
             }
             catch (Exception e)
             {
-                request.SendFailed(e);
+                // subscribe observer to failed observable
+                return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
             }
-            return Unit.Default;
-        }
 
-        private async Task SendWebSocketMessageAsync(GraphQLWebSocketRequest request, CancellationToken cancellationToken = default)
+            var disposable = new CompositeDisposable(
+                observable.Subscribe(observer)
+            );
+
+            Debug.WriteLine($"submitting request {websocketRequest.Id}");
+            // send request
+            try
+            {
+                await QueueWebSocketRequest(websocketRequest).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine(e);
+                throw;
+            }
+
+            return disposable;
+        })
+            // complete sequence on OperationCanceledException, this is triggered by the cancellation token
+            .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+                Observable.Empty<GraphQLResponse<TResponse>>())
+            .FirstAsync()
+            .ToTask(cancellationToken);
+
+    private Task QueueWebSocketRequest(GraphQLWebSocketRequest request)
+    {
+        _requestSubject.OnNext(request);
+        return request.SendTask();
+    }
+
+    private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
+    {
+        try
+        {
+            if (_internalCancellationToken.IsCancellationRequested)
+            {
+                request.SendCanceled();
+                return Unit.Default;
+            }
+
+            await InitializeWebSocket().ConfigureAwait(false);
+            await SendWebSocketMessageAsync(request, _internalCancellationToken).ConfigureAwait(false);
+            request.SendCompleted();
+        }
+        catch (Exception e)
         {
-            var requestBytes = _client.JsonSerializer.SerializeToBytes(request);
-            await _clientWebSocket.SendAsync(
-                new ArraySegment<byte>(requestBytes),
-                WebSocketMessageType.Text,
-                true,
-                cancellationToken).ConfigureAwait(false);
+            request.SendFailed(e);
         }
+        return Unit.Default;
+    }
 
-        #endregion
+    private async Task SendWebSocketMessageAsync(GraphQLWebSocketRequest request, CancellationToken cancellationToken = default)
+    {
+        var requestBytes = _client.JsonSerializer.SerializeToBytes(request);
+        await _clientWebSocket.SendAsync(
+            new ArraySegment<byte>(requestBytes),
+            WebSocketMessageType.Text,
+            true,
+            cancellationToken).ConfigureAwait(false);
+    }
 
-        public Task InitializeWebSocket()
-        {
-            // do not attempt to initialize if cancellation is requested
-            if (Completion != null)
-                throw new OperationCanceledException();
+    #endregion
 
-            lock (_initializeLock)
-            {
-                // if an initialization task is already running, return that
-                if (_initializeWebSocketTask != null &&
-                   !_initializeWebSocketTask.IsFaulted &&
-                   !_initializeWebSocketTask.IsCompleted)
-                    return _initializeWebSocketTask;
+    public Task InitializeWebSocket()
+    {
+        // do not attempt to initialize if cancellation is requested
+        if (Completion != null)
+            throw new OperationCanceledException();
 
-                // if the websocket is open, return a completed task
-                if (_clientWebSocket != null && _clientWebSocket.State == WebSocketState.Open)
-                    return Task.CompletedTask;
+        lock (_initializeLock)
+        {
+            // if an initialization task is already running, return that
+            if (_initializeWebSocketTask != null &&
+               !_initializeWebSocketTask.IsFaulted &&
+               !_initializeWebSocketTask.IsCompleted)
+                return _initializeWebSocketTask;
+
+            // if the websocket is open, return a completed task
+            if (_clientWebSocket != null && _clientWebSocket.State == WebSocketState.Open)
+                return Task.CompletedTask;
 
-                // else (re-)create websocket and connect
-                _clientWebSocket?.Dispose();
+            // else (re-)create websocket and connect
+            _clientWebSocket?.Dispose();
 
 #if NETFRAMEWORK
 				// fix websocket not supported on win 7 using
@@ -382,310 +382,309 @@ public Task InitializeWebSocket()
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
 						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
 						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
-                        Options.ConfigureWebsocketOptions(nativeWebSocket.Options);
-                        break;
+                    Options.ConfigureWebsocketOptions(nativeWebSocket.Options);
+                    break;
 					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
 						managedWebSocket.Options.AddSubProtocol("graphql-ws");
 						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
 						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
-                        break;
+                    break;
 					default:
 						throw new NotSupportedException($"unknown websocket type {_clientWebSocket.GetType().Name}");
 				}
 #else
-                _clientWebSocket = new ClientWebSocket();
-                _clientWebSocket.Options.AddSubProtocol("graphql-ws");
+            _clientWebSocket = new ClientWebSocket();
+            _clientWebSocket.Options.AddSubProtocol("graphql-ws");
 
-                // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
-                try
-                {
-                    _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
-                }
-                catch (NotImplementedException)
-                {
-                    Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not implemented by current platform");
-                }
-                catch (PlatformNotSupportedException)
-                {
-                    Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not supported by current platform");
-                }
+            // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
+            try
+            {
+                _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+            }
+            catch (NotImplementedException)
+            {
+                Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not implemented by current platform");
+            }
+            catch (PlatformNotSupportedException)
+            {
+                Debug.WriteLine("property 'ClientWebSocketOptions.ClientCertificates' not supported by current platform");
+            }
 
-                try
-                {
-                    _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
-                }
-                catch (NotImplementedException)
-                {
-                    Debug.WriteLine("property 'ClientWebSocketOptions.UseDefaultCredentials' not implemented by current platform");
-                }
-                catch (PlatformNotSupportedException)
-                {
-                    Debug.WriteLine("Property 'ClientWebSocketOptions.UseDefaultCredentials' not supported by current platform");
-                }
+            try
+            {
+                _clientWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+            }
+            catch (NotImplementedException)
+            {
+                Debug.WriteLine("property 'ClientWebSocketOptions.UseDefaultCredentials' not implemented by current platform");
+            }
+            catch (PlatformNotSupportedException)
+            {
+                Debug.WriteLine("Property 'ClientWebSocketOptions.UseDefaultCredentials' not supported by current platform");
+            }
 
-                Options.ConfigureWebsocketOptions(_clientWebSocket.Options);
+            Options.ConfigureWebsocketOptions(_clientWebSocket.Options);
 #endif
-                return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);
-            }
+            return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);
         }
+    }
 
-        private async Task ConnectAsync(CancellationToken token)
+    private async Task ConnectAsync(CancellationToken token)
+    {
+        try
         {
-            try
+            await BackOff().ConfigureAwait(false);
+            _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
+            Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
+            await _clientWebSocket.ConnectAsync(_webSocketUri, token).ConfigureAwait(false);
+            _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
+            Debug.WriteLine($"connection established on websocket {_clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
+            await (Options.OnWebsocketConnected?.Invoke(_client) ?? Task.CompletedTask).ConfigureAwait(false);
+            Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {_clientWebSocket.GetHashCode()}");
+            _connectionAttempt = 1;
+
+            // create receiving observable
+            _incomingMessages = Observable
+                .Defer(() => GetReceiveTask().ToObservable())
+                .Repeat()
+                // complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
+                .Catch<WebsocketMessageWrapper, OperationCanceledException>(exception => Observable.Empty<WebsocketMessageWrapper>())
+                .Publish();
+
+            // subscribe maintenance
+            var maintenanceSubscription = _incomingMessages.Subscribe(_ => { }, ex =>
             {
-                await BackOff().ConfigureAwait(false);
-                _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
-                Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
-                await _clientWebSocket.ConnectAsync(_webSocketUri, token).ConfigureAwait(false);
-                _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
-                Debug.WriteLine($"connection established on websocket {_clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
-                await (Options.OnWebsocketConnected?.Invoke(_client) ?? Task.CompletedTask).ConfigureAwait(false);
-                Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {_clientWebSocket.GetHashCode()}");
-                _connectionAttempt = 1;
-
-                // create receiving observable
-                _incomingMessages = Observable
-                    .Defer(() => GetReceiveTask().ToObservable())
-                    .Repeat()
-                    // complete sequence on OperationCanceledException, this is triggered by the cancellation token on disposal
-                    .Catch<WebsocketMessageWrapper, OperationCanceledException>(exception => Observable.Empty<WebsocketMessageWrapper>())
-                    .Publish();
-
-                // subscribe maintenance
-                var maintenanceSubscription = _incomingMessages.Subscribe(_ => { }, ex =>
+                Debug.WriteLine($"incoming message stream {_incomingMessages.GetHashCode()} received an error: {ex}");
+                _exceptionSubject.OnNext(ex);
+                _incomingMessagesConnection?.Dispose();
+                _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+            },
+                () =>
                 {
-                    Debug.WriteLine($"incoming message stream {_incomingMessages.GetHashCode()} received an error: {ex}");
-                    _exceptionSubject.OnNext(ex);
+                    Debug.WriteLine($"incoming message stream {_incomingMessages.GetHashCode()} completed");
                     _incomingMessagesConnection?.Dispose();
                     _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-                },
-                    () =>
-                    {
-                        Debug.WriteLine($"incoming message stream {_incomingMessages.GetHashCode()} completed");
-                        _incomingMessagesConnection?.Dispose();
-                        _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-                    });
-
+                });
 
-                // connect observable
-                var connection = _incomingMessages.Connect();
-                Debug.WriteLine($"new incoming message stream {_incomingMessages.GetHashCode()} created");
 
-                _incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
+            // connect observable
+            var connection = _incomingMessages.Connect();
+            Debug.WriteLine($"new incoming message stream {_incomingMessages.GetHashCode()} created");
 
-                var initRequest = new GraphQLWebSocketRequest
-                {
-                    Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                    Payload = Options.ConfigureWebSocketConnectionInitPayload(Options)
-                };
+            _incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
 
-                // setup task to await connection_ack message
-                var ackTask = _incomingMessages
-                    .Where(response => response != null)
-                    .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
-                                           response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
-                    .LastAsync()
-                    .ToTask();
-
-                // send connection init
-                Debug.WriteLine($"sending connection init message");
-                await SendWebSocketMessageAsync(initRequest).ConfigureAwait(false);
-                var response = await ackTask.ConfigureAwait(false);
-
-                if (response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
-                    Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
-                else
-                {
-                    var errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
-                    Debug.WriteLine($"connection error received: {errorPayload}");
-                    throw new GraphQLWebsocketConnectionException(errorPayload);
-                }
-            }
-            catch (Exception e)
+            var initRequest = new GraphQLWebSocketRequest
             {
-                Debug.WriteLine($"failed to establish websocket connection");
-                _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
-                _exceptionSubject.OnNext(e);
-                throw;
+                Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+                Payload = Options.ConfigureWebSocketConnectionInitPayload(Options)
+            };
+
+            // setup task to await connection_ack message
+            var ackTask = _incomingMessages
+                .Where(response => response != null)
+                .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
+                                       response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
+                .LastAsync()
+                .ToTask();
+
+            // send connection init
+            Debug.WriteLine($"sending connection init message");
+            await SendWebSocketMessageAsync(initRequest).ConfigureAwait(false);
+            var response = await ackTask.ConfigureAwait(false);
+
+            if (response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
+                Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
+            else
+            {
+                var errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
+                Debug.WriteLine($"connection error received: {errorPayload}");
+                throw new GraphQLWebsocketConnectionException(errorPayload);
             }
         }
-
-        /// <summary>
-        /// delay the next connection attempt using <see cref="GraphQLHttpClientOptions.BackOffStrategy"/>
-        /// </summary>
-        /// <returns></returns>
-        private Task BackOff()
+        catch (Exception e)
         {
-            _connectionAttempt++;
-
-            if (_connectionAttempt == 1)
-                return Task.CompletedTask;
-
-            var delay = Options.BackOffStrategy?.Invoke(_connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
-            Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
-            return Task.Delay(delay, _internalCancellationToken);
+            Debug.WriteLine($"failed to establish websocket connection");
+            _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+            _exceptionSubject.OnNext(e);
+            throw;
         }
+    }
 
-        private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
-            Observable.Create<WebsocketMessageWrapper>(async observer =>
-                {
-                    // make sure the websocket is connected
-                    await InitializeWebSocket().ConfigureAwait(false);
-                    // subscribe observer to message stream
-                    var subscription = new CompositeDisposable(_incomingMessages
-                        .Subscribe(observer))
-                    {
-                        // register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
-                        _internalCancellationTokenSource.Token.Register(observer.OnCompleted)
-                    };
+    /// <summary>
+    /// delay the next connection attempt using <see cref="GraphQLHttpClientOptions.BackOffStrategy"/>
+    /// </summary>
+    /// <returns></returns>
+    private Task BackOff()
+    {
+        _connectionAttempt++;
 
-                    // add some debug output
-                    var hashCode = subscription.GetHashCode();
-                    subscription.Add(Disposable.Create(() => Debug.WriteLine($"incoming message subscription {hashCode} disposed")));
-                    Debug.WriteLine($"new incoming message subscription {hashCode} created");
+        if (_connectionAttempt == 1)
+            return Task.CompletedTask;
 
-                    return subscription;
-                });
+        var delay = Options.BackOffStrategy?.Invoke(_connectionAttempt - 1) ?? TimeSpan.FromSeconds(5);
+        Debug.WriteLine($"connection attempt #{_connectionAttempt}, backing off for {delay.TotalSeconds} s");
+        return Task.Delay(delay, _internalCancellationToken);
+    }
 
-        private Task<WebsocketMessageWrapper> _receiveAsyncTask = null;
-        private readonly object _receiveTaskLocker = new object();
-        /// <summary>
-        /// wrapper method to pick up the existing request task if already running
-        /// </summary>
-        /// <returns></returns>
-        private Task<WebsocketMessageWrapper> GetReceiveTask()
-        {
-            lock (_receiveTaskLocker)
+    private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
+        Observable.Create<WebsocketMessageWrapper>(async observer =>
             {
-                _internalCancellationToken.ThrowIfCancellationRequested();
-                if (_receiveAsyncTask == null ||
-                    _receiveAsyncTask.IsFaulted ||
-                    _receiveAsyncTask.IsCompleted)
-                    _receiveAsyncTask = ReceiveWebsocketMessagesAsync();
-            }
+                // make sure the websocket is connected
+                await InitializeWebSocket().ConfigureAwait(false);
+                // subscribe observer to message stream
+                var subscription = new CompositeDisposable(_incomingMessages
+                    .Subscribe(observer))
+                {
+                    // register the observer's OnCompleted method with the cancellation token to complete the sequence on disposal
+                    _internalCancellationTokenSource.Token.Register(observer.OnCompleted)
+                };
 
-            return _receiveAsyncTask;
+                // add some debug output
+                var hashCode = subscription.GetHashCode();
+                subscription.Add(Disposable.Create(() => Debug.WriteLine($"incoming message subscription {hashCode} disposed")));
+                Debug.WriteLine($"new incoming message subscription {hashCode} created");
+
+                return subscription;
+            });
+
+    private Task<WebsocketMessageWrapper> _receiveAsyncTask = null;
+    private readonly object _receiveTaskLocker = new object();
+    /// <summary>
+    /// wrapper method to pick up the existing request task if already running
+    /// </summary>
+    /// <returns></returns>
+    private Task<WebsocketMessageWrapper> GetReceiveTask()
+    {
+        lock (_receiveTaskLocker)
+        {
+            _internalCancellationToken.ThrowIfCancellationRequested();
+            if (_receiveAsyncTask == null ||
+                _receiveAsyncTask.IsFaulted ||
+                _receiveAsyncTask.IsCompleted)
+                _receiveAsyncTask = ReceiveWebsocketMessagesAsync();
         }
 
-        /// <summary>
-        /// read a single message from the websocket
-        /// </summary>
-        /// <returns></returns>
-        private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
+        return _receiveAsyncTask;
+    }
+
+    /// <summary>
+    /// read a single message from the websocket
+    /// </summary>
+    /// <returns></returns>
+    private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
+    {
+        _internalCancellationToken.ThrowIfCancellationRequested();
+
+        try
         {
-            _internalCancellationToken.ThrowIfCancellationRequested();
+            Debug.WriteLine($"waiting for data on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
 
-            try
+            using var ms = new MemoryStream();
+            WebSocketReceiveResult webSocketReceiveResult = null;
+            do
             {
-                Debug.WriteLine($"waiting for data on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
-
-                using var ms = new MemoryStream();
-                WebSocketReceiveResult webSocketReceiveResult = null;
-                do
-                {
-                    // cancellation is done implicitly via the close method
-                    webSocketReceiveResult = await _clientWebSocket.ReceiveAsync(_buffer, CancellationToken.None).ConfigureAwait(false);
-                    ms.Write(_buffer.Array, _buffer.Offset, webSocketReceiveResult.Count);
-                }
-                while (!webSocketReceiveResult.EndOfMessage && !_internalCancellationToken.IsCancellationRequested);
+                // cancellation is done implicitly via the close method
+                webSocketReceiveResult = await _clientWebSocket.ReceiveAsync(_buffer, CancellationToken.None).ConfigureAwait(false);
+                ms.Write(_buffer.Array, _buffer.Offset, webSocketReceiveResult.Count);
+            }
+            while (!webSocketReceiveResult.EndOfMessage && !_internalCancellationToken.IsCancellationRequested);
 
-                _internalCancellationToken.ThrowIfCancellationRequested();
-                ms.Seek(0, SeekOrigin.Begin);
+            _internalCancellationToken.ThrowIfCancellationRequested();
+            ms.Seek(0, SeekOrigin.Begin);
 
-                switch (webSocketReceiveResult.MessageType)
-                {
-                    case WebSocketMessageType.Text:
-                        var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
-                        response.MessageBytes = ms.ToArray();
-                        Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
-                        return response;
+            switch (webSocketReceiveResult.MessageType)
+            {
+                case WebSocketMessageType.Text:
+                    var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
+                    response.MessageBytes = ms.ToArray();
+                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+                    return response;
 
-                    case WebSocketMessageType.Close:
-                        var closeResponse = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
-                        closeResponse.MessageBytes = ms.ToArray();
-                        Debug.WriteLine($"Connection closed by the server.");
-                        throw new Exception("Connection closed by the server.");
+                case WebSocketMessageType.Close:
+                    var closeResponse = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
+                    closeResponse.MessageBytes = ms.ToArray();
+                    Debug.WriteLine($"Connection closed by the server.");
+                    throw new Exception("Connection closed by the server.");
 
-                    default:
-                        throw new NotSupportedException($"Websocket message type {webSocketReceiveResult.MessageType} not supported.");
+                default:
+                    throw new NotSupportedException($"Websocket message type {webSocketReceiveResult.MessageType} not supported.");
 
-                }
-            }
-            catch (Exception e)
-            {
-                Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
-                throw;
             }
         }
-
-        private async Task CloseAsync()
+        catch (Exception e)
         {
-            if (_clientWebSocket == null)
-                return;
-
-            // don't attempt to close the websocket if it is in a failed state
-            if (_clientWebSocket.State != WebSocketState.Open &&
-                _clientWebSocket.State != WebSocketState.CloseReceived &&
-                _clientWebSocket.State != WebSocketState.CloseSent)
-            {
-                Debug.WriteLine($"websocket {_clientWebSocket.GetHashCode()} state = {_clientWebSocket.State}");
-                return;
-            }
+            Debug.WriteLine($"exception thrown while receiving websocket data: {e}");
+            throw;
+        }
+    }
 
-            Debug.WriteLine($"send \"connection_terminate\" message");
-            await SendWebSocketMessageAsync(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE }).ConfigureAwait(false);
+    private async Task CloseAsync()
+    {
+        if (_clientWebSocket == null)
+            return;
 
-            Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
-            await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false);
-            _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+        // don't attempt to close the websocket if it is in a failed state
+        if (_clientWebSocket.State != WebSocketState.Open &&
+            _clientWebSocket.State != WebSocketState.CloseReceived &&
+            _clientWebSocket.State != WebSocketState.CloseSent)
+        {
+            Debug.WriteLine($"websocket {_clientWebSocket.GetHashCode()} state = {_clientWebSocket.State}");
+            return;
         }
 
-        #region IDisposable
+        Debug.WriteLine($"send \"connection_terminate\" message");
+        await SendWebSocketMessageAsync(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE }).ConfigureAwait(false);
+
+        Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
+        await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false);
+        _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+    }
+
+    #region IDisposable
 
-        public void Dispose() => Complete();
+    public void Dispose() => Complete();
 
-        /// <summary>
-        /// Cancels the current operation, closes the websocket connection and disposes of internal resources.
-        /// </summary>
-        public void Complete()
+    /// <summary>
+    /// Cancels the current operation, closes the websocket connection and disposes of internal resources.
+    /// </summary>
+    public void Complete()
+    {
+        lock (_completedLocker)
         {
-            lock (_completedLocker)
-            {
-                if (Completion == null)
-                    Completion = CompleteAsync();
-            }
+            if (Completion == null)
+                Completion = CompleteAsync();
         }
+    }
 
-        /// <summary>
-        /// Task to await the completion (a.k.a. disposal) of this websocket.
-        /// </summary>
-        /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-        public Task? Completion { get; private set; }
-
-        private readonly object _completedLocker = new object();
-        private async Task CompleteAsync()
-        {
-            Debug.WriteLine("disposing GraphQLHttpWebSocket...");
+    /// <summary>
+    /// Task to await the completion (a.k.a. disposal) of this websocket.
+    /// </summary>
+    /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+    public Task? Completion { get; private set; }
 
-            _incomingMessagesConnection?.Dispose();
+    private readonly object _completedLocker = new object();
+    private async Task CompleteAsync()
+    {
+        Debug.WriteLine("disposing GraphQLHttpWebSocket...");
 
-            if (!_internalCancellationTokenSource.IsCancellationRequested)
-                _internalCancellationTokenSource.Cancel();
+        _incomingMessagesConnection?.Dispose();
 
-            await CloseAsync().ConfigureAwait(false);
-            _requestSubscription?.Dispose();
-            _clientWebSocket?.Dispose();
+        if (!_internalCancellationTokenSource.IsCancellationRequested)
+            _internalCancellationTokenSource.Cancel();
 
-            _stateSubject?.OnCompleted();
-            _stateSubject?.Dispose();
+        await CloseAsync().ConfigureAwait(false);
+        _requestSubscription?.Dispose();
+        _clientWebSocket?.Dispose();
 
-            _exceptionSubject?.OnCompleted();
-            _exceptionSubject?.Dispose();
-            _internalCancellationTokenSource.Dispose();
+        _stateSubject?.OnCompleted();
+        _stateSubject?.Dispose();
 
-            Debug.WriteLine("GraphQLHttpWebSocket disposed");
-        }
+        _exceptionSubject?.OnCompleted();
+        _exceptionSubject?.Dispose();
+        _internalCancellationTokenSource.Dispose();
 
-        #endregion
+        Debug.WriteLine("GraphQLHttpWebSocket disposed");
     }
+
+    #endregion
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
index a1416948..ea4140fb 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
@@ -1,24 +1,23 @@
 using System.Runtime.Serialization;
 
-namespace GraphQL.Client.Http.Websocket
+namespace GraphQL.Client.Http.Websocket;
+
+[Serializable]
+public class GraphQLWebsocketConnectionException: Exception
 {
-    [Serializable]
-    public class GraphQLWebsocketConnectionException: Exception
+    public GraphQLWebsocketConnectionException()
     {
-        public GraphQLWebsocketConnectionException()
-        {
-        }
+    }
 
-        protected GraphQLWebsocketConnectionException(SerializationInfo info, StreamingContext context) : base(info, context)
-        {
-        }
+    protected GraphQLWebsocketConnectionException(SerializationInfo info, StreamingContext context) : base(info, context)
+    {
+    }
 
-        public GraphQLWebsocketConnectionException(string message) : base(message)
-        {
-        }
+    public GraphQLWebsocketConnectionException(string message) : base(message)
+    {
+    }
 
-        public GraphQLWebsocketConnectionException(string message, Exception innerException) : base(message, innerException)
-        {
-        }
+    public GraphQLWebsocketConnectionException(string message, Exception innerException) : base(message, innerException)
+    {
     }
 }
diff --git a/src/GraphQL.Primitives/ErrorPath.cs b/src/GraphQL.Primitives/ErrorPath.cs
index dd449d73..a43bf02e 100644
--- a/src/GraphQL.Primitives/ErrorPath.cs
+++ b/src/GraphQL.Primitives/ErrorPath.cs
@@ -1,13 +1,12 @@
-namespace GraphQL
+namespace GraphQL;
+
+public class ErrorPath : List<object>
 {
-    public class ErrorPath : List<object>
+    public ErrorPath()
     {
-        public ErrorPath()
-        {
-        }
+    }
 
-        public ErrorPath(IEnumerable<object> collection) : base(collection)
-        {
-        }
+    public ErrorPath(IEnumerable<object> collection) : base(collection)
+    {
     }
 }
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 7b3e9a1a..29a94250 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -1,115 +1,114 @@
 using System.Runtime.Serialization;
 
-namespace GraphQL
+namespace GraphQL;
+
+/// <summary>
+/// Represents a GraphQL Error of a GraphQL Query
+/// </summary>
+public class GraphQLError : IEquatable<GraphQLError?>
 {
     /// <summary>
-    /// Represents a GraphQL Error of a GraphQL Query
+    /// The locations of the error
     /// </summary>
-    public class GraphQLError : IEquatable<GraphQLError?>
-    {
-        /// <summary>
-        /// The locations of the error
-        /// </summary>
-        [DataMember(Name = "locations")]
-        public GraphQLLocation[]? Locations { get; set; }
+    [DataMember(Name = "locations")]
+    public GraphQLLocation[]? Locations { get; set; }
 
-        /// <summary>
-        /// The message of the error
-        /// </summary>
-        [DataMember(Name = "message")]
-        public string Message { get; set; }
+    /// <summary>
+    /// The message of the error
+    /// </summary>
+    [DataMember(Name = "message")]
+    public string Message { get; set; }
 
-        /// <summary>
-        /// The Path of the error
-        /// </summary>
-        [DataMember(Name = "path")]
-        public ErrorPath? Path { get; set; }
+    /// <summary>
+    /// The Path of the error
+    /// </summary>
+    [DataMember(Name = "path")]
+    public ErrorPath? Path { get; set; }
 
-        /// <summary>
-        /// The extensions of the error
-        /// </summary> 
-        [DataMember(Name = "extensions")]
-        public Map? Extensions { get; set; }
+    /// <summary>
+    /// The extensions of the error
+    /// </summary> 
+    [DataMember(Name = "extensions")]
+    public Map? Extensions { get; set; }
 
-        /// <summary>
-        /// Returns a value that indicates whether this instance is equal to a specified object
-        /// </summary>
-        /// <param name="obj">The object to compare with this instance</param>
-        /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
-        public override bool Equals(object? obj) => Equals(obj as GraphQLError);
+    /// <summary>
+    /// Returns a value that indicates whether this instance is equal to a specified object
+    /// </summary>
+    /// <param name="obj">The object to compare with this instance</param>
+    /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
+    public override bool Equals(object? obj) => Equals(obj as GraphQLError);
 
-        /// <summary>
-        /// Returns a value that indicates whether this instance is equal to a specified object
-        /// </summary>
-        /// <param name="other">The object to compare with this instance</param>
-        /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
-        public bool Equals(GraphQLError? other)
+    /// <summary>
+    /// Returns a value that indicates whether this instance is equal to a specified object
+    /// </summary>
+    /// <param name="other">The object to compare with this instance</param>
+    /// <returns>true if obj is an instance of <see cref="GraphQLError"/> and equals the value of the instance; otherwise, false</returns>
+    public bool Equals(GraphQLError? other)
+    {
+        if (other == null)
+        { return false; }
+        if (ReferenceEquals(this, other))
+        { return true; }
         {
-            if (other == null)
-            { return false; }
-            if (ReferenceEquals(this, other))
-            { return true; }
+            if (Locations != null && other.Locations != null)
             {
-                if (Locations != null && other.Locations != null)
-                {
-                    if (!Locations.SequenceEqual(other.Locations))
-                    { return false; }
-                }
-                else if (Locations != null && other.Locations == null)
-                { return false; }
-                else if (Locations == null && other.Locations != null)
+                if (!Locations.SequenceEqual(other.Locations))
                 { return false; }
             }
-            if (!EqualityComparer<string>.Default.Equals(Message, other.Message))
+            else if (Locations != null && other.Locations == null)
             { return false; }
+            else if (Locations == null && other.Locations != null)
+            { return false; }
+        }
+        if (!EqualityComparer<string>.Default.Equals(Message, other.Message))
+        { return false; }
+        {
+            if (Path != null && other.Path != null)
             {
-                if (Path != null && other.Path != null)
-                {
-                    if (!Path.SequenceEqual(other.Path))
-                    { return false; }
-                }
-                else if (Path != null && other.Path == null)
-                { return false; }
-                else if (Path == null && other.Path != null)
+                if (!Path.SequenceEqual(other.Path))
                 { return false; }
             }
-            return true;
+            else if (Path != null && other.Path == null)
+            { return false; }
+            else if (Path == null && other.Path != null)
+            { return false; }
         }
+        return true;
+    }
 
-        /// <summary>
-        /// <inheritdoc cref="object.GetHashCode"/>
-        /// </summary>
-        public override int GetHashCode()
+    /// <summary>
+    /// <inheritdoc cref="object.GetHashCode"/>
+    /// </summary>
+    public override int GetHashCode()
+    {
+        var hashCode = 0;
+        if (Locations != null)
         {
-            var hashCode = 0;
-            if (Locations != null)
-            {
-                hashCode ^= EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(Locations);
-            }
-            hashCode ^= EqualityComparer<string>.Default.GetHashCode(Message);
-            if (Path != null)
-            {
-                hashCode ^= EqualityComparer<dynamic>.Default.GetHashCode(Path);
-            }
-            return hashCode;
+            hashCode ^= EqualityComparer<GraphQLLocation[]>.Default.GetHashCode(Locations);
+        }
+        hashCode ^= EqualityComparer<string>.Default.GetHashCode(Message);
+        if (Path != null)
+        {
+            hashCode ^= EqualityComparer<dynamic>.Default.GetHashCode(Path);
         }
+        return hashCode;
+    }
 
-        /// <summary>
-        /// Tests whether two specified <see cref="GraphQLError"/> instances are equivalent
-        /// </summary>
-        /// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the equality operator</param>
-        /// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the equality operator</param>
-        /// <returns>true if left and right are equal; otherwise, false</returns>
-        public static bool operator ==(GraphQLError? left, GraphQLError? right) =>
-            EqualityComparer<GraphQLError?>.Default.Equals(left, right);
+    /// <summary>
+    /// Tests whether two specified <see cref="GraphQLError"/> instances are equivalent
+    /// </summary>
+    /// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the equality operator</param>
+    /// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the equality operator</param>
+    /// <returns>true if left and right are equal; otherwise, false</returns>
+    public static bool operator ==(GraphQLError? left, GraphQLError? right) =>
+        EqualityComparer<GraphQLError?>.Default.Equals(left, right);
 
-        /// <summary>
-        /// Tests whether two specified <see cref="GraphQLError"/> instances are not equal
-        /// </summary>
-        /// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the not equal operator</param>
-        /// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the not equal operator</param>
-        /// <returns>true if left and right are unequal; otherwise, false</returns>
-        public static bool operator !=(GraphQLError? left, GraphQLError? right) =>
-            !EqualityComparer<GraphQLError?>.Default.Equals(left, right);
-    }
+    /// <summary>
+    /// Tests whether two specified <see cref="GraphQLError"/> instances are not equal
+    /// </summary>
+    /// <param name="left">The <see cref="GraphQLError"/> instance that is to the left of the not equal operator</param>
+    /// <param name="right">The <see cref="GraphQLError"/> instance that is to the right of the not equal operator</param>
+    /// <returns>true if left and right are unequal; otherwise, false</returns>
+    public static bool operator !=(GraphQLError? left, GraphQLError? right) =>
+        !EqualityComparer<GraphQLError?>.Default.Equals(left, right);
 }
diff --git a/src/GraphQL.Primitives/GraphQLLocation.cs b/src/GraphQL.Primitives/GraphQLLocation.cs
index 4a499031..efec6256 100644
--- a/src/GraphQL.Primitives/GraphQLLocation.cs
+++ b/src/GraphQL.Primitives/GraphQLLocation.cs
@@ -1,64 +1,63 @@
-namespace GraphQL
+namespace GraphQL;
+
+/// <summary>
+/// Represents a GraphQL Location of a GraphQL Query
+/// </summary>
+public sealed class GraphQLLocation : IEquatable<GraphQLLocation?>
 {
     /// <summary>
-    /// Represents a GraphQL Location of a GraphQL Query
+    /// The Column
     /// </summary>
-    public sealed class GraphQLLocation : IEquatable<GraphQLLocation?>
-    {
-        /// <summary>
-        /// The Column
-        /// </summary>
-        public uint Column { get; set; }
+    public uint Column { get; set; }
 
-        /// <summary>
-        /// The Line
-        /// </summary>
-        public uint Line { get; set; }
+    /// <summary>
+    /// The Line
+    /// </summary>
+    public uint Line { get; set; }
 
-        /// <summary>
-        /// Returns a value that indicates whether this instance is equal to a specified object
-        /// </summary>
-        /// <param name="obj">The object to compare with this instance</param>
-        /// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
-        public override bool Equals(object obj) => Equals(obj as GraphQLLocation);
+    /// <summary>
+    /// Returns a value that indicates whether this instance is equal to a specified object
+    /// </summary>
+    /// <param name="obj">The object to compare with this instance</param>
+    /// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
+    public override bool Equals(object obj) => Equals(obj as GraphQLLocation);
 
-        /// <summary>
-        /// Returns a value that indicates whether this instance is equal to a specified object
-        /// </summary>
-        /// <param name="other">The object to compare with this instance</param>
-        /// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
-        public bool Equals(GraphQLLocation? other)
-        {
-            if (other == null)
-            { return false; }
-            if (ReferenceEquals(this, other))
-            { return true; }
-            return EqualityComparer<uint>.Default.Equals(Column, other.Column) &&
-                EqualityComparer<uint>.Default.Equals(Line, other.Line);
-        }
+    /// <summary>
+    /// Returns a value that indicates whether this instance is equal to a specified object
+    /// </summary>
+    /// <param name="other">The object to compare with this instance</param>
+    /// <returns>true if obj is an instance of <see cref="GraphQLLocation"/> and equals the value of the instance; otherwise, false</returns>
+    public bool Equals(GraphQLLocation? other)
+    {
+        if (other == null)
+        { return false; }
+        if (ReferenceEquals(this, other))
+        { return true; }
+        return EqualityComparer<uint>.Default.Equals(Column, other.Column) &&
+            EqualityComparer<uint>.Default.Equals(Line, other.Line);
+    }
 
-        /// <summary>
-        /// <inheritdoc cref="object.GetHashCode"/>
-        /// </summary>
-        public override int GetHashCode() =>
-            Column.GetHashCode() ^ Line.GetHashCode();
+    /// <summary>
+    /// <inheritdoc cref="object.GetHashCode"/>
+    /// </summary>
+    public override int GetHashCode() =>
+        Column.GetHashCode() ^ Line.GetHashCode();
 
-        /// <summary>
-        /// Tests whether two specified <see cref="GraphQLLocation"/> instances are equivalent
-        /// </summary>
-        /// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the equality operator</param>
-        /// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the equality operator</param>
-        /// <returns>true if left and right are equal; otherwise, false</returns>
-        public static bool operator ==(GraphQLLocation? left, GraphQLLocation? right) =>
-            EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
+    /// <summary>
+    /// Tests whether two specified <see cref="GraphQLLocation"/> instances are equivalent
+    /// </summary>
+    /// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the equality operator</param>
+    /// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the equality operator</param>
+    /// <returns>true if left and right are equal; otherwise, false</returns>
+    public static bool operator ==(GraphQLLocation? left, GraphQLLocation? right) =>
+        EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
 
-        /// <summary>
-        /// Tests whether two specified <see cref="GraphQLLocation"/> instances are not equal
-        /// </summary>
-        /// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the not equal operator</param>
-        /// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the not equal operator</param>
-        /// <returns>true if left and right are unequal; otherwise, false</returns>
-        public static bool operator !=(GraphQLLocation? left, GraphQLLocation? right) =>
-            !EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
-    }
+    /// <summary>
+    /// Tests whether two specified <see cref="GraphQLLocation"/> instances are not equal
+    /// </summary>
+    /// <param name="left">The <see cref="GraphQLLocation"/> instance that is to the left of the not equal operator</param>
+    /// <param name="right">The <see cref="GraphQLLocation"/> instance that is to the right of the not equal operator</param>
+    /// <returns>true if left and right are unequal; otherwise, false</returns>
+    public static bool operator !=(GraphQLLocation? left, GraphQLLocation? right) =>
+        !EqualityComparer<GraphQLLocation?>.Default.Equals(left, right);
 }
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 5dbb766d..7d9ee10c 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -1,112 +1,111 @@
-namespace GraphQL
+namespace GraphQL;
+
+/// <summary>
+/// A GraphQL request
+/// </summary>
+public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequest?>
 {
+    public const string OPERATION_NAME_KEY = "operationName";
+    public const string QUERY_KEY = "query";
+    public const string VARIABLES_KEY = "variables";
+    public const string EXTENSIONS_KEY = "extensions";
+
     /// <summary>
-    /// A GraphQL request
+    /// The Query
     /// </summary>
-    public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequest?>
+    public string Query
     {
-        public const string OPERATION_NAME_KEY = "operationName";
-        public const string QUERY_KEY = "query";
-        public const string VARIABLES_KEY = "variables";
-        public const string EXTENSIONS_KEY = "extensions";
-
-        /// <summary>
-        /// The Query
-        /// </summary>
-        public string Query
-        {
-            get => TryGetValue(QUERY_KEY, out object value) ? (string)value : null;
-            set => this[QUERY_KEY] = value;
-        }
+        get => TryGetValue(QUERY_KEY, out object value) ? (string)value : null;
+        set => this[QUERY_KEY] = value;
+    }
 
-        /// <summary>
-        /// The name of the Operation
-        /// </summary>
-        public string? OperationName
-        {
-            get => TryGetValue(OPERATION_NAME_KEY, out object value) ? (string)value : null;
-            set => this[OPERATION_NAME_KEY] = value;
-        }
+    /// <summary>
+    /// The name of the Operation
+    /// </summary>
+    public string? OperationName
+    {
+        get => TryGetValue(OPERATION_NAME_KEY, out object value) ? (string)value : null;
+        set => this[OPERATION_NAME_KEY] = value;
+    }
 
-        /// <summary>
-        /// Represents the request variables
-        /// </summary>
-        public object? Variables
-        {
-            get => TryGetValue(VARIABLES_KEY, out object value) ? value : null;
-            set => this[VARIABLES_KEY] = value;
-        }
+    /// <summary>
+    /// Represents the request variables
+    /// </summary>
+    public object? Variables
+    {
+        get => TryGetValue(VARIABLES_KEY, out object value) ? value : null;
+        set => this[VARIABLES_KEY] = value;
+    }
 
-        /// <summary>
-        /// Represents the request extensions
-        /// </summary>
-        public object? Extensions
-        {
-            get => TryGetValue(EXTENSIONS_KEY, out object value) ? value : null;
-            set => this[EXTENSIONS_KEY] = value;
-        }
+    /// <summary>
+    /// Represents the request extensions
+    /// </summary>
+    public object? Extensions
+    {
+        get => TryGetValue(EXTENSIONS_KEY, out object value) ? value : null;
+        set => this[EXTENSIONS_KEY] = value;
+    }
 
-        public GraphQLRequest() { }
+    public GraphQLRequest() { }
 
-        public GraphQLRequest(string query, object? variables = null, string? operationName = null, object? extensions = null)
-        {
-            Query = query;
-            Variables = variables;
-            OperationName = operationName;
-            Extensions = extensions;
-        }
+    public GraphQLRequest(string query, object? variables = null, string? operationName = null, object? extensions = null)
+    {
+        Query = query;
+        Variables = variables;
+        OperationName = operationName;
+        Extensions = extensions;
+    }
 
-        public GraphQLRequest(GraphQLRequest other): base(other) { }
+    public GraphQLRequest(GraphQLRequest other): base(other) { }
 
-        /// <summary>
-        /// Returns a value that indicates whether this instance is equal to a specified object
-        /// </summary>
-        /// <param name="obj">The object to compare with this instance</param>
-        /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-        public override bool Equals(object? obj)
-        {
-            if (obj is null)
-                return false;
-            if (ReferenceEquals(this, obj))
-                return true;
-            if (obj.GetType() != GetType())
-                return false;
-            return Equals((GraphQLRequest)obj);
-        }
+    /// <summary>
+    /// Returns a value that indicates whether this instance is equal to a specified object
+    /// </summary>
+    /// <param name="obj">The object to compare with this instance</param>
+    /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
+    public override bool Equals(object? obj)
+    {
+        if (obj is null)
+            return false;
+        if (ReferenceEquals(this, obj))
+            return true;
+        if (obj.GetType() != GetType())
+            return false;
+        return Equals((GraphQLRequest)obj);
+    }
 
-        /// <summary>
-        /// Returns a value that indicates whether this instance is equal to a specified object
-        /// </summary>
-        /// <param name="other">The object to compare with this instance</param>
-        /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
-        public virtual bool Equals(GraphQLRequest? other)
-        {
-            if (other is null)
-                return false;
-            if (ReferenceEquals(this, other))
-                return true;
-            return Count == other.Count && !this.Except(other).Any();
-        }
+    /// <summary>
+    /// Returns a value that indicates whether this instance is equal to a specified object
+    /// </summary>
+    /// <param name="other">The object to compare with this instance</param>
+    /// <returns>true if obj is an instance of <see cref="GraphQLRequest"/> and equals the value of the instance; otherwise, false</returns>
+    public virtual bool Equals(GraphQLRequest? other)
+    {
+        if (other is null)
+            return false;
+        if (ReferenceEquals(this, other))
+            return true;
+        return Count == other.Count && !this.Except(other).Any();
+    }
 
-        /// <summary>
-        /// <inheritdoc cref="object.GetHashCode"/>
-        /// </summary>
-        public override int GetHashCode() => (Query, OperationName, Variables, Extensions).GetHashCode();
+    /// <summary>
+    /// <inheritdoc cref="object.GetHashCode"/>
+    /// </summary>
+    public override int GetHashCode() => (Query, OperationName, Variables, Extensions).GetHashCode();
 
-        /// <summary>
-        /// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
-        /// </summary>
-        /// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the equality operator</param>
-        /// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the equality operator</param>
-        /// <returns>true if left and right are equal; otherwise, false</returns>
-        public static bool operator ==(GraphQLRequest? left, GraphQLRequest? right) => EqualityComparer<GraphQLRequest?>.Default.Equals(left, right);
+    /// <summary>
+    /// Tests whether two specified <see cref="GraphQLRequest"/> instances are equivalent
+    /// </summary>
+    /// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the equality operator</param>
+    /// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the equality operator</param>
+    /// <returns>true if left and right are equal; otherwise, false</returns>
+    public static bool operator ==(GraphQLRequest? left, GraphQLRequest? right) => EqualityComparer<GraphQLRequest?>.Default.Equals(left, right);
 
-        /// <summary>
-        /// Tests whether two specified <see cref="GraphQLRequest"/> instances are not equal
-        /// </summary>
-        /// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the not equal operator</param>
-        /// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the not equal operator</param>
-        /// <returns>true if left and right are unequal; otherwise, false</returns>
-        public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
-    }
+    /// <summary>
+    /// Tests whether two specified <see cref="GraphQLRequest"/> instances are not equal
+    /// </summary>
+    /// <param name="left">The <see cref="GraphQLRequest"/> instance that is to the left of the not equal operator</param>
+    /// <param name="right">The <see cref="GraphQLRequest"/> instance that is to the right of the not equal operator</param>
+    /// <returns>true if left and right are unequal; otherwise, false</returns>
+    public static bool operator !=(GraphQLRequest? left, GraphQLRequest? right) => !(left == right);
 }
diff --git a/src/GraphQL.Primitives/GraphQLResponse.cs b/src/GraphQL.Primitives/GraphQLResponse.cs
index c4c8a010..adcd6457 100644
--- a/src/GraphQL.Primitives/GraphQLResponse.cs
+++ b/src/GraphQL.Primitives/GraphQLResponse.cs
@@ -1,89 +1,88 @@
 using System.Runtime.Serialization;
 
-namespace GraphQL
+namespace GraphQL;
+
+public class GraphQLResponse<T> : IGraphQLResponse, IEquatable<GraphQLResponse<T>?>
 {
-    public class GraphQLResponse<T> : IGraphQLResponse, IEquatable<GraphQLResponse<T>?>
-    {
-        [DataMember(Name = "data")]
-        public T Data { get; set; }
-        object IGraphQLResponse.Data => Data;
+    [DataMember(Name = "data")]
+    public T Data { get; set; }
+    object IGraphQLResponse.Data => Data;
 
-        [DataMember(Name = "errors")]
-        public GraphQLError[]? Errors { get; set; }
+    [DataMember(Name = "errors")]
+    public GraphQLError[]? Errors { get; set; }
 
-        [DataMember(Name = "extensions")]
-        public Map? Extensions { get; set; }
+    [DataMember(Name = "extensions")]
+    public Map? Extensions { get; set; }
 
-        public override bool Equals(object? obj) => Equals(obj as GraphQLResponse<T>);
+    public override bool Equals(object? obj) => Equals(obj as GraphQLResponse<T>);
 
-        public bool Equals(GraphQLResponse<T>? other)
-        {
-            if (other == null)
-            { return false; }
-            if (ReferenceEquals(this, other))
-            { return true; }
-            if (!EqualityComparer<T>.Default.Equals(Data, other.Data))
-            { return false; }
+    public bool Equals(GraphQLResponse<T>? other)
+    {
+        if (other == null)
+        { return false; }
+        if (ReferenceEquals(this, other))
+        { return true; }
+        if (!EqualityComparer<T>.Default.Equals(Data, other.Data))
+        { return false; }
 
-            if (Errors != null && other.Errors != null)
-            {
-                if (!Enumerable.SequenceEqual(Errors, other.Errors))
-                { return false; }
-            }
-            else if (Errors != null && other.Errors == null)
-            { return false; }
-            else if (Errors == null && other.Errors != null)
+        if (Errors != null && other.Errors != null)
+        {
+            if (!Enumerable.SequenceEqual(Errors, other.Errors))
             { return false; }
+        }
+        else if (Errors != null && other.Errors == null)
+        { return false; }
+        else if (Errors == null && other.Errors != null)
+        { return false; }
 
-            if (Extensions != null && other.Extensions != null)
-            {
-                if (!Enumerable.SequenceEqual(Extensions, other.Extensions))
-                { return false; }
-            }
-            else if (Extensions != null && other.Extensions == null)
-            { return false; }
-            else if (Extensions == null && other.Extensions != null)
+        if (Extensions != null && other.Extensions != null)
+        {
+            if (!Enumerable.SequenceEqual(Extensions, other.Extensions))
             { return false; }
-
-            return true;
         }
+        else if (Extensions != null && other.Extensions == null)
+        { return false; }
+        else if (Extensions == null && other.Extensions != null)
+        { return false; }
 
-        public override int GetHashCode()
+        return true;
+    }
+
+    public override int GetHashCode()
+    {
+        unchecked
         {
-            unchecked
+            var hashCode = EqualityComparer<T>.Default.GetHashCode(Data);
             {
-                var hashCode = EqualityComparer<T>.Default.GetHashCode(Data);
+                if (Errors != null)
                 {
-                    if (Errors != null)
-                    {
-                        foreach (var element in Errors)
-                        {
-                            hashCode = (hashCode * 397) ^ EqualityComparer<GraphQLError?>.Default.GetHashCode(element);
-                        }
-                    }
-                    else
+                    foreach (var element in Errors)
                     {
-                        hashCode = (hashCode * 397) ^ 0;
+                        hashCode = (hashCode * 397) ^ EqualityComparer<GraphQLError?>.Default.GetHashCode(element);
                     }
+                }
+                else
+                {
+                    hashCode = (hashCode * 397) ^ 0;
+                }
 
-                    if (Extensions != null)
-                    {
-                        foreach (var element in Extensions)
-                        {
-                            hashCode = (hashCode * 397) ^ EqualityComparer<KeyValuePair<string, object>>.Default.GetHashCode(element);
-                        }
-                    }
-                    else
+                if (Extensions != null)
+                {
+                    foreach (var element in Extensions)
                     {
-                        hashCode = (hashCode * 397) ^ 0;
+                        hashCode = (hashCode * 397) ^ EqualityComparer<KeyValuePair<string, object>>.Default.GetHashCode(element);
                     }
                 }
-                return hashCode;
+                else
+                {
+                    hashCode = (hashCode * 397) ^ 0;
+                }
             }
+            return hashCode;
         }
+    }
 
-        public static bool operator ==(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => EqualityComparer<GraphQLResponse<T>?>.Default.Equals(response1, response2);
+    public static bool operator ==(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => EqualityComparer<GraphQLResponse<T>?>.Default.Equals(response1, response2);
 
-        public static bool operator !=(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => !(response1 == response2);
-    }
+    public static bool operator !=(GraphQLResponse<T>? response1, GraphQLResponse<T>? response2) => !(response1 == response2);
 }
diff --git a/src/GraphQL.Primitives/IGraphQLResponse.cs b/src/GraphQL.Primitives/IGraphQLResponse.cs
index 789d686f..4d4c2f93 100644
--- a/src/GraphQL.Primitives/IGraphQLResponse.cs
+++ b/src/GraphQL.Primitives/IGraphQLResponse.cs
@@ -1,11 +1,10 @@
-namespace GraphQL
+namespace GraphQL;
+
+public interface IGraphQLResponse
 {
-    public interface IGraphQLResponse
-    {
-        object Data { get; }
+    object Data { get; }
 
-        GraphQLError[]? Errors { get; set; }
+    GraphQLError[]? Errors { get; set; }
 
-        Map? Extensions { get; set; }
-    }
+    Map? Extensions { get; set; }
 }
diff --git a/src/GraphQL.Primitives/Map.cs b/src/GraphQL.Primitives/Map.cs
index b51f5a85..7c5823f1 100644
--- a/src/GraphQL.Primitives/Map.cs
+++ b/src/GraphQL.Primitives/Map.cs
@@ -1,7 +1,6 @@
-namespace GraphQL
-{
-    /// <summary>
-    /// A type equivalent to a javascript map. Create a custom json converter for this class to customize your serializers behaviour
-    /// </summary>
-    public class Map : Dictionary<string, object> { }
-}
+namespace GraphQL;
+
+/// <summary>
+/// A type equivalent to a javascript map. Create a custom json converter for this class to customize your serializers behaviour
+/// </summary>
+public class Map : Dictionary<string, object> { }
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index ce3d51f6..9d97fea3 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -9,65 +9,64 @@
 using GraphQL.Client.Tests.Common.Helpers;
 using Xunit;
 
-namespace GraphQL.Client.Serializer.Tests
+namespace GraphQL.Client.Serializer.Tests;
+
+public abstract class BaseSerializeNoCamelCaseTest
 {
-    public abstract class BaseSerializeNoCamelCaseTest
-    {
-        public IGraphQLWebsocketJsonSerializer ClientSerializer { get; }
+    public IGraphQLWebsocketJsonSerializer ClientSerializer { get; }
 
-        public IGraphQLTextSerializer ServerSerializer { get; }
+    public IGraphQLTextSerializer ServerSerializer { get; }
 
-        public IGraphQLClient ChatClient { get; }
+    public IGraphQLClient ChatClient { get; }
 
-        public IGraphQLClient StarWarsClient { get; }
+    public IGraphQLClient StarWarsClient { get; }
 
-        protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
-        {
-            ClientSerializer = clientSerializer;
-            ServerSerializer = serverSerializer;
-            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), clientSerializer, serverSerializer);
-            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), clientSerializer, serverSerializer);
-        }
+    protected BaseSerializeNoCamelCaseTest(IGraphQLWebsocketJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
+    {
+        ClientSerializer = clientSerializer;
+        ServerSerializer = serverSerializer;
+        ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), clientSerializer, serverSerializer);
+        StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), clientSerializer, serverSerializer);
+    }
 
-        [Theory]
-        [ClassData(typeof(SerializeToStringTestData))]
-        public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
-        {
-            var json = ClientSerializer.SerializeToString(request).RemoveWhitespace();
-            json.Should().Be(expectedJson.RemoveWhitespace());
-        }
+    [Theory]
+    [ClassData(typeof(SerializeToStringTestData))]
+    public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
+    {
+        var json = ClientSerializer.SerializeToString(request).RemoveWhitespace();
+        json.Should().Be(expectedJson.RemoveWhitespace());
+    }
 
-        [Theory]
-        [ClassData(typeof(SerializeToBytesTestData))]
-        public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
-        {
-            var json = Encoding.UTF8.GetString(ClientSerializer.SerializeToBytes(request)).RemoveWhitespace();
-            json.Should().Be(expectedJson.RemoveWhitespace());
-        }
+    [Theory]
+    [ClassData(typeof(SerializeToBytesTestData))]
+    public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
+    {
+        var json = Encoding.UTF8.GetString(ClientSerializer.SerializeToBytes(request)).RemoveWhitespace();
+        json.Should().Be(expectedJson.RemoveWhitespace());
+    }
 
-        [Fact]
-        public async void WorksWithoutCamelCaseNamingStrategy()
-        {
+    [Fact]
+    public async void WorksWithoutCamelCaseNamingStrategy()
+    {
 
-            const string message = "some random testing message";
-            var graphQLRequest = new GraphQLRequest(
-                @"mutation($input: MessageInputType){
+        const string message = "some random testing message";
+        var graphQLRequest = new GraphQLRequest(
+            @"mutation($input: MessageInputType){
 				  addMessage(message: $input){
 				    content
 				  }
 				}",
-                new
+            new
+            {
+                input = new
                 {
-                    input = new
-                    {
-                        fromId = "2",
-                        content = message,
-                        sentAt = DateTime.Now
-                    }
-                });
-            var response = await ChatClient.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
+                    fromId = "2",
+                    content = message,
+                    sentAt = DateTime.Now
+                }
+            });
+        var response = await ChatClient.SendMutationAsync(graphQLRequest, () => new { addMessage = new { content = "" } });
 
-            Assert.Equal(message, response.Data.addMessage.content);
-        }
+        Assert.Equal(message, response.Data.addMessage.content);
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 8efdccdf..2021a792 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -18,115 +18,115 @@
 using GraphQL.Client.Tests.Common.StarWars.TestData;
 using Xunit;
 
-namespace GraphQL.Client.Serializer.Tests
+namespace GraphQL.Client.Serializer.Tests;
+
+public abstract class BaseSerializerTest
 {
-    public abstract class BaseSerializerTest
-    {
-        public IGraphQLWebsocketJsonSerializer ClientSerializer { get; }
+    public IGraphQLWebsocketJsonSerializer ClientSerializer { get; }
 
-        public IGraphQLTextSerializer ServerSerializer { get; }
+    public IGraphQLTextSerializer ServerSerializer { get; }
 
-        public IGraphQLClient ChatClient { get; }
+    public IGraphQLClient ChatClient { get; }
 
-        public IGraphQLClient StarWarsClient { get; }
+    public IGraphQLClient StarWarsClient { get; }
 
-        protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
-        {
-            ClientSerializer = clientSerializer;
-            ServerSerializer = serverSerializer;
-            ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), clientSerializer, serverSerializer);
-            StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), clientSerializer, serverSerializer);
-        }
+    protected BaseSerializerTest(IGraphQLWebsocketJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
+    {
+        ClientSerializer = clientSerializer;
+        ServerSerializer = serverSerializer;
+        ChatClient = GraphQLLocalExecutionClient.New(Common.GetChatSchema(), clientSerializer, serverSerializer);
+        StarWarsClient = GraphQLLocalExecutionClient.New(Common.GetStarWarsSchema(), clientSerializer, serverSerializer);
+    }
 
-        [Theory]
-        [ClassData(typeof(SerializeToStringTestData))]
-        public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
-        {
-            var json = ClientSerializer.SerializeToString(request).RemoveWhitespace();
-            json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
-        }
+    [Theory]
+    [ClassData(typeof(SerializeToStringTestData))]
+    public void SerializeToStringTest(string expectedJson, GraphQLRequest request)
+    {
+        var json = ClientSerializer.SerializeToString(request).RemoveWhitespace();
+        json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
+    }
 
-        [Theory]
-        [ClassData(typeof(SerializeToBytesTestData))]
-        public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
-        {
-            var json = Encoding.UTF8.GetString(ClientSerializer.SerializeToBytes(request)).RemoveWhitespace();
-            json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
-        }
+    [Theory]
+    [ClassData(typeof(SerializeToBytesTestData))]
+    public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest request)
+    {
+        var json = Encoding.UTF8.GetString(ClientSerializer.SerializeToBytes(request)).RemoveWhitespace();
+        json.Should().BeEquivalentTo(expectedJson.RemoveWhitespace());
+    }
 
-        [Theory]
-        [ClassData(typeof(DeserializeResponseTestData))]
-        public async void DeserializeFromUtf8StreamTest(string json, IGraphQLResponse expectedResponse)
-        {
-            var jsonBytes = Encoding.UTF8.GetBytes(json);
-            await using var ms = new MemoryStream(jsonBytes);
-            var response = await DeserializeToUnknownType(expectedResponse.Data?.GetType() ?? typeof(object), ms);
+    [Theory]
+    [ClassData(typeof(DeserializeResponseTestData))]
+    public async void DeserializeFromUtf8StreamTest(string json, IGraphQLResponse expectedResponse)
+    {
+        var jsonBytes = Encoding.UTF8.GetBytes(json);
+        await using var ms = new MemoryStream(jsonBytes);
+        var response = await DeserializeToUnknownType(expectedResponse.Data?.GetType() ?? typeof(object), ms);
 
-            //var response = await Serializer.DeserializeFromUtf8StreamAsync<object>(ms, CancellationToken.None);
+        //var response = await Serializer.DeserializeFromUtf8StreamAsync<object>(ms, CancellationToken.None);
 
-            response.Data.Should().BeEquivalentTo(expectedResponse.Data, options => options.WithAutoConversion());
+        response.Data.Should().BeEquivalentTo(expectedResponse.Data, options => options.WithAutoConversion());
 
-            if (expectedResponse.Errors is null)
-                response.Errors.Should().BeNull();
-            else
+        if (expectedResponse.Errors is null)
+            response.Errors.Should().BeNull();
+        else
+        {
+            using (new AssertionScope())
             {
-                using (new AssertionScope())
+                response.Errors.Should().NotBeNull();
+                response.Errors.Should().HaveSameCount(expectedResponse.Errors);
+                for (int i = 0; i < expectedResponse.Errors.Length; i++)
                 {
-                    response.Errors.Should().NotBeNull();
-                    response.Errors.Should().HaveSameCount(expectedResponse.Errors);
-                    for (int i = 0; i < expectedResponse.Errors.Length; i++)
-                    {
-                        response.Errors[i].Message.Should().BeEquivalentTo(expectedResponse.Errors[i].Message);
-                        response.Errors[i].Locations.Should().BeEquivalentTo(expectedResponse.Errors[i].Locations?.ToList());
-                        response.Errors[i].Path.Should().BeEquivalentTo(expectedResponse.Errors[i].Path);
-                        response.Errors[i].Extensions.Should().BeEquivalentTo(expectedResponse.Errors[i].Extensions);
-                    }
+                    response.Errors[i].Message.Should().BeEquivalentTo(expectedResponse.Errors[i].Message);
+                    response.Errors[i].Locations.Should().BeEquivalentTo(expectedResponse.Errors[i].Locations?.ToList());
+                    response.Errors[i].Path.Should().BeEquivalentTo(expectedResponse.Errors[i].Path);
+                    response.Errors[i].Extensions.Should().BeEquivalentTo(expectedResponse.Errors[i].Extensions);
                 }
             }
+        }
 
-            if (expectedResponse.Extensions == null)
-                response.Extensions.Should().BeNull();
-            else
+        if (expectedResponse.Extensions == null)
+            response.Extensions.Should().BeNull();
+        else
+        {
+            foreach (var element in expectedResponse.Extensions)
             {
-                foreach (var element in expectedResponse.Extensions)
-                {
-                    response.Extensions.Should().ContainKey(element.Key);
-                    response.Extensions[element.Key].Should().BeEquivalentTo(element.Value);
-                }
+                response.Extensions.Should().ContainKey(element.Key);
+                response.Extensions[element.Key].Should().BeEquivalentTo(element.Value);
             }
         }
+    }
 
-        public async Task<IGraphQLResponse> DeserializeToUnknownType(Type dataType, Stream stream)
-        {
-            MethodInfo mi = ClientSerializer.GetType().GetMethod("DeserializeFromUtf8StreamAsync", BindingFlags.Instance | BindingFlags.Public);
-            MethodInfo mi2 = mi.MakeGenericMethod(dataType);
-            var task = (Task)mi2.Invoke(ClientSerializer, new object[] { stream, CancellationToken.None });
-            await task;
-            var resultProperty = task.GetType().GetProperty("Result", BindingFlags.Public | BindingFlags.Instance);
-            var result = resultProperty.GetValue(task);
-            return (IGraphQLResponse)result;
-        }
+    public async Task<IGraphQLResponse> DeserializeToUnknownType(Type dataType, Stream stream)
+    {
+        MethodInfo mi = ClientSerializer.GetType().GetMethod("DeserializeFromUtf8StreamAsync", BindingFlags.Instance | BindingFlags.Public);
+        MethodInfo mi2 = mi.MakeGenericMethod(dataType);
+        var task = (Task)mi2.Invoke(ClientSerializer, new object[] { stream, CancellationToken.None });
+        await task;
+        var resultProperty = task.GetType().GetProperty("Result", BindingFlags.Public | BindingFlags.Instance);
+        var result = resultProperty.GetValue(task);
+        return (IGraphQLResponse)result;
+    }
 
-        [Fact]
-        public async void CanDeserializeExtensions()
-        {
-            var response = await ChatClient.SendQueryAsync(
-                new GraphQLRequest("query { extensionsTest }"),
-                () => new { extensionsTest = "" });
+    [Fact]
+    public async void CanDeserializeExtensions()
+    {
+        var response = await ChatClient.SendQueryAsync(
+            new GraphQLRequest("query { extensionsTest }"),
+            () => new { extensionsTest = "" });
 
-            response.Errors.Should().NotBeNull();
-            response.Errors.Should().ContainSingle();
-            response.Errors[0].Extensions.Should().NotBeNull();
-            response.Errors[0].Extensions.Should().ContainKey("data");
+        response.Errors.Should().NotBeNull();
+        response.Errors.Should().ContainSingle();
+        response.Errors[0].Extensions.Should().NotBeNull();
+        response.Errors[0].Extensions.Should().ContainKey("data");
 
-            response.Errors[0].Extensions["data"].Should().BeEquivalentTo(ChatQuery.TestExtensions);
-        }
+        response.Errors[0].Extensions["data"].Should().BeEquivalentTo(ChatQuery.TestExtensions);
+    }
 
-        [Theory]
-        [ClassData(typeof(StarWarsHumans))]
-        public async void CanDoSerializationWithAnonymousTypes(int id, string name)
-        {
-            var graphQLRequest = new GraphQLRequest(@"
+    [Theory]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void CanDoSerializationWithAnonymousTypes(int id, string name)
+    {
+        var graphQLRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
@@ -138,62 +138,61 @@ query Droid($id: String!) {
 				    name
 				  }
 				}",
-                new { id = id.ToString() },
-                "Human");
+            new { id = id.ToString() },
+            "Human");
 
-            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
-            Assert.Null(response.Errors);
-            Assert.Equal(name, response.Data.Human.Name);
-        }
+        Assert.Null(response.Errors);
+        Assert.Equal(name, response.Data.Human.Name);
+    }
 
-        [Fact]
-        public async void CanDoSerializationWithPredefinedTypes()
-        {
-            const string message = "some random testing message";
-            var response = await ChatClient.AddMessageAsync(message);
+    [Fact]
+    public async void CanDoSerializationWithPredefinedTypes()
+    {
+        const string message = "some random testing message";
+        var response = await ChatClient.AddMessageAsync(message);
 
-            Assert.Equal(message, response.Data.AddMessage.Content);
-        }
+        Assert.Equal(message, response.Data.AddMessage.Content);
+    }
 
-        public class WithNullable
-        {
-            public int? NullableInt { get; set; }
-        }
+    public class WithNullable
+    {
+        public int? NullableInt { get; set; }
+    }
 
-        [Fact]
-        public void CanSerializeNullableInt()
+    [Fact]
+    public void CanSerializeNullableInt()
+    {
+        Action action = () => ClientSerializer.SerializeToString(new GraphQLRequest
         {
-            Action action = () => ClientSerializer.SerializeToString(new GraphQLRequest
+            Query = "{}",
+            Variables = new WithNullable
             {
-                Query = "{}",
-                Variables = new WithNullable
-                {
-                    NullableInt = 2
-                }
-            });
+                NullableInt = 2
+            }
+        });
 
-            action.Should().NotThrow();
-        }
+        action.Should().NotThrow();
+    }
 
-        public class WithNullableStruct
-        {
-            public DateTime? NullableStruct { get; set; }
-        }
+    public class WithNullableStruct
+    {
+        public DateTime? NullableStruct { get; set; }
+    }
 
-        [Fact]
-        public void CanSerializeNullableStruct()
+    [Fact]
+    public void CanSerializeNullableStruct()
+    {
+        Action action = () => ClientSerializer.SerializeToString(new GraphQLRequest
         {
-            Action action = () => ClientSerializer.SerializeToString(new GraphQLRequest
+            Query = "{}",
+            Variables = new WithNullableStruct
             {
-                Query = "{}",
-                Variables = new WithNullableStruct
-                {
-                    NullableStruct = DateTime.Now
-                }
-            });
+                NullableStruct = DateTime.Now
+            }
+        });
 
-            action.Should().NotThrow();
-        }
+        action.Should().NotThrow();
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
index 2fe14e7c..3bafce7c 100644
--- a/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
@@ -6,14 +6,14 @@
 using Newtonsoft.Json;
 using Xunit;
 
-namespace GraphQL.Client.Serializer.Tests
+namespace GraphQL.Client.Serializer.Tests;
+
+public class ConsistencyTests
 {
-    public class ConsistencyTests
+    [Fact]
+    public void MapConvertersShouldBehaveConsistent()
     {
-        [Fact]
-        public void MapConvertersShouldBehaveConsistent()
-        {
-            const string json = @"{
+        const string json = @"{
                 ""array"": [
                   ""some stuff"",
                   ""something else""
@@ -29,34 +29,33 @@ public void MapConvertersShouldBehaveConsistent()
                   {""number"": 567.8}
                 ]
             }";
-            
-            var newtonsoftSerializer = new NewtonsoftJsonSerializer();
-            var systemTextJsonSerializer = new SystemTextJsonSerializer();
+        
+        var newtonsoftSerializer = new NewtonsoftJsonSerializer();
+        var systemTextJsonSerializer = new SystemTextJsonSerializer();
 
-            var newtonsoftMap = JsonConvert.DeserializeObject<Map>(json, newtonsoftSerializer.JsonSerializerSettings);
-            var systemTextJsonMap = System.Text.Json.JsonSerializer.Deserialize<Map>(json, systemTextJsonSerializer.Options);
+        var newtonsoftMap = JsonConvert.DeserializeObject<Map>(json, newtonsoftSerializer.JsonSerializerSettings);
+        var systemTextJsonMap = System.Text.Json.JsonSerializer.Deserialize<Map>(json, systemTextJsonSerializer.Options);
 
 
-            using(new AssertionScope())
-            {
-                CompareMaps(newtonsoftMap, systemTextJsonMap);
-            }
-
-            newtonsoftMap.Should().BeEquivalentTo(systemTextJsonMap, options => options
-                .RespectingRuntimeTypes());
+        using(new AssertionScope())
+        {
+            CompareMaps(newtonsoftMap, systemTextJsonMap);
         }
 
-        private void CompareMaps(Dictionary<string, object> first, Dictionary<string, object> second)
+        newtonsoftMap.Should().BeEquivalentTo(systemTextJsonMap, options => options
+            .RespectingRuntimeTypes());
+    }
+
+    private void CompareMaps(Dictionary<string, object> first, Dictionary<string, object> second)
+    {
+        foreach (var keyValuePair in first)
         {
-            foreach (var keyValuePair in first)
-            {
-                second.Should().ContainKey(keyValuePair.Key);
-                second[keyValuePair.Key].Should().BeOfType(keyValuePair.Value.GetType());
-                if(keyValuePair.Value is Dictionary<string, object> map)
-                    CompareMaps(map, (Dictionary<string, object>)second[keyValuePair.Key]);
-                else
-                    keyValuePair.Value.Should().BeEquivalentTo(second[keyValuePair.Key]);
-            }
+            second.Should().ContainKey(keyValuePair.Key);
+            second[keyValuePair.Key].Should().BeOfType(keyValuePair.Value.GetType());
+            if(keyValuePair.Value is Dictionary<string, object> map)
+                CompareMaps(map, (Dictionary<string, object>)second[keyValuePair.Key]);
+            else
+                keyValuePair.Value.Should().BeEquivalentTo(second[keyValuePair.Key]);
         }
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 481a23c0..42e392c4 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -1,17 +1,16 @@
 using GraphQL.Client.Serializer.Newtonsoft;
 using Newtonsoft.Json;
 
-namespace GraphQL.Client.Serializer.Tests
+namespace GraphQL.Client.Serializer.Tests;
+
+public class NewtonsoftSerializerTest : BaseSerializerTest
 {
-    public class NewtonsoftSerializerTest : BaseSerializerTest
-    {
-        public NewtonsoftSerializerTest()
-            : base(new NewtonsoftJsonSerializer(), new NewtonsoftJson.GraphQLSerializer()) { }
-    }
+    public NewtonsoftSerializerTest()
+        : base(new NewtonsoftJsonSerializer(), new NewtonsoftJson.GraphQLSerializer()) { }
+}
 
-    public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
-    {
-        public NewtonsoftSerializeNoCamelCaseTest()
-            : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings { Converters = { new ConstantCaseEnumConverter() } }), new NewtonsoftJson.GraphQLSerializer()) { }
-    }
+public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
+{
+    public NewtonsoftSerializeNoCamelCaseTest()
+        : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings { Converters = { new ConstantCaseEnumConverter() } }), new NewtonsoftJson.GraphQLSerializer()) { }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index d5e04733..bece29bd 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -2,17 +2,16 @@
 using System.Text.Json.Serialization;
 using GraphQL.Client.Serializer.SystemTextJson;
 
-namespace GraphQL.Client.Serializer.Tests
+namespace GraphQL.Client.Serializer.Tests;
+
+public class SystemTextJsonSerializerTests : BaseSerializerTest
 {
-    public class SystemTextJsonSerializerTests : BaseSerializerTest
-    {
-        public SystemTextJsonSerializerTests()
-            : base(new SystemTextJsonSerializer(), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
-    }
+    public SystemTextJsonSerializerTests()
+        : base(new SystemTextJsonSerializer(), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
+}
 
-    public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
-    {
-        public SystemTextJsonSerializeNoCamelCaseTest()
-            : base(new SystemTextJsonSerializer(new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter()), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
-    }
+public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
+{
+    public SystemTextJsonSerializeNoCamelCaseTest()
+        : base(new SystemTextJsonSerializer(new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter()), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
index 31d02eed..6b388483 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -1,46 +1,46 @@
 using System.Collections;
 using System.Collections.Generic;
 
-namespace GraphQL.Client.Serializer.Tests.TestData
+namespace GraphQL.Client.Serializer.Tests.TestData;
+
+public class DeserializeResponseTestData : IEnumerable<object[]>
 {
-    public class DeserializeResponseTestData : IEnumerable<object[]>
+    public IEnumerator<object[]> GetEnumerator()
     {
-        public IEnumerator<object[]> GetEnumerator()
-        {
-            // object array structure:
-            // [0]: input json
-            // [1]: expected deserialized response
+        // object array structure:
+        // [0]: input json
+        // [1]: expected deserialized response
 
-            yield return new object[] {
-                "{\"errors\":[{\"message\":\"Throttled\",\"extensions\":{\"code\":\"THROTTLED\",\"documentation\":\"https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits\"}}],\"extensions\":{\"cost\":{\"requestedQueryCost\":992,\"actualQueryCost\":null,\"throttleStatus\":{\"maximumAvailable\":1000,\"currentlyAvailable\":632,\"restoreRate\":50}}}}",
-                new GraphQLResponse<object> {
-                    Data = null,
-                    Errors = new[] {
-                        new GraphQLError {
-                            Message = "Throttled",
-                            Extensions = new Map {
-                                {"code", "THROTTLED" },
-                                {"documentation", "https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits" }
-                            }
+        yield return new object[] {
+            "{\"errors\":[{\"message\":\"Throttled\",\"extensions\":{\"code\":\"THROTTLED\",\"documentation\":\"https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits\"}}],\"extensions\":{\"cost\":{\"requestedQueryCost\":992,\"actualQueryCost\":null,\"throttleStatus\":{\"maximumAvailable\":1000,\"currentlyAvailable\":632,\"restoreRate\":50}}}}",
+            new GraphQLResponse<object> {
+                Data = null,
+                Errors = new[] {
+                    new GraphQLError {
+                        Message = "Throttled",
+                        Extensions = new Map {
+                            {"code", "THROTTLED" },
+                            {"documentation", "https://help.shopify.com/api/graphql-admin-api/graphql-admin-api-rate-limits" }
                         }
-                    },
-                    Extensions = new Map {
-                        {"cost", new Dictionary<string, object> {
-                            {"requestedQueryCost", 992},
-                            {"actualQueryCost", null},
-                            {"throttleStatus", new Dictionary<string, object> {
-                                {"maximumAvailable", 1000},
-                                {"currentlyAvailable", 632},
-                                {"restoreRate", 50}
-                            }}
-                        }}
                     }
+                },
+                Extensions = new Map {
+                    {"cost", new Dictionary<string, object> {
+                        {"requestedQueryCost", 992},
+                        {"actualQueryCost", null},
+                        {"throttleStatus", new Dictionary<string, object> {
+                            {"maximumAvailable", 1000},
+                            {"currentlyAvailable", 632},
+                            {"restoreRate", 50}
+                        }}
+                    }}
                 }
-            };
+            }
+        };
 
-            yield return new object[]
-            {
-                @"{
+        yield return new object[]
+        {
+            @"{
                     ""errors"": [
                         {
                             ""message"": ""Name for character with ID 1002 could not be fetched."",
@@ -78,65 +78,64 @@ public IEnumerator<object[]> GetEnumerator()
                         }
                     }
                 }",
-                NewAnonymouslyTypedGraphQLResponse(new
+            NewAnonymouslyTypedGraphQLResponse(new
+                {
+                    hero = new
                     {
-                        hero = new
+                        name = "R2-D2",
+                        heroFriends = new List<Friend>
                         {
-                            name = "R2-D2",
-                            heroFriends = new List<Friend>
-                            {
-                                new Friend {Id = "1000", Name = "Luke Skywalker"},
-                                new Friend {Id = "1002", Name = null},
-                                new Friend {Id = "1003", Name = "Leia Organa"}
-                            }
-                        }
-                    },
-                    new[] {
-                        new GraphQLError {
-                            Message = "Name for character with ID 1002 could not be fetched.",
-                            Locations = new [] { new GraphQLLocation{Line = 6, Column = 7 }},
-                            Path = new ErrorPath{"hero", "heroFriends", 1, "name"}
+                            new Friend {Id = "1000", Name = "Luke Skywalker"},
+                            new Friend {Id = "1002", Name = null},
+                            new Friend {Id = "1003", Name = "Leia Organa"}
                         }
-                    })
-            };
+                    }
+                },
+                new[] {
+                    new GraphQLError {
+                        Message = "Name for character with ID 1002 could not be fetched.",
+                        Locations = new [] { new GraphQLLocation{Line = 6, Column = 7 }},
+                        Path = new ErrorPath{"hero", "heroFriends", 1, "name"}
+                    }
+                })
+        };
 
-            // add test for github issue #230 : https://github.com/graphql-dotnet/graphql-client/issues/230
-            yield return new object[] {
-                "{\"data\":{\"getMyModelType\":{\"id\":\"foo\",\"title\":\"The best Foo movie!\"}}}",
-                new GraphQLResponse<GetMyModelTypeResponse> {
-                    Data = new GetMyModelTypeResponse
+        // add test for github issue #230 : https://github.com/graphql-dotnet/graphql-client/issues/230
+        yield return new object[] {
+            "{\"data\":{\"getMyModelType\":{\"id\":\"foo\",\"title\":\"The best Foo movie!\"}}}",
+            new GraphQLResponse<GetMyModelTypeResponse> {
+                Data = new GetMyModelTypeResponse
+                {
+                    getMyModelType = new Movie
                     {
-                        getMyModelType = new Movie
-                        {
-                            id = "foo",
-                            title = "The best Foo movie!"
-                        }
-                    },
-                }
-            };
-        }
+                        id = "foo",
+                        title = "The best Foo movie!"
+                    }
+                },
+            }
+        };
+    }
 
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-        private GraphQLResponse<T> NewAnonymouslyTypedGraphQLResponse<T>(T data, GraphQLError[]? errors = null, Map? extensions = null)
-            => new GraphQLResponse<T> {Data = data, Errors = errors, Extensions = extensions};
-    }
+    private GraphQLResponse<T> NewAnonymouslyTypedGraphQLResponse<T>(T data, GraphQLError[]? errors = null, Map? extensions = null)
+        => new GraphQLResponse<T> {Data = data, Errors = errors, Extensions = extensions};
+}
 
-    public class Friend
-    {
-        public string Id { get; set; }
-        public string? Name { get; set; }
-    }
+public class Friend
+{
+    public string Id { get; set; }
+    public string? Name { get; set; }
+}
 
-    public class GetMyModelTypeResponse
-    {
-        //--- Properties ---
-        public Movie getMyModelType { get; set; }
-    }
-    public class Movie
-    {
-        //--- Properties ---
-        public string id { get; set; }
-        public string title { get; set; }
-    }
+public class GetMyModelTypeResponse
+{
+    //--- Properties ---
+    public Movie getMyModelType { get; set; }
+}
+public class Movie
+{
+    //--- Properties ---
+    public string id { get; set; }
+    public string title { get; set; }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
index 3b581cc5..977ea5af 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
@@ -2,31 +2,30 @@
 using System.Collections.Generic;
 using GraphQL.Client.Abstractions.Websocket;
 
-namespace GraphQL.Client.Serializer.Tests.TestData
+namespace GraphQL.Client.Serializer.Tests.TestData;
+
+public class SerializeToBytesTestData : IEnumerable<object[]>
 {
-    public class SerializeToBytesTestData : IEnumerable<object[]>
+    public IEnumerator<object[]> GetEnumerator()
     {
-        public IEnumerator<object[]> GetEnumerator()
-        {
-            yield return new object[] {
-                "{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null}}",
-                new GraphQLWebSocketRequest {
-                    Id = "1234567",
-                    Type = GraphQLWebSocketMessageType.GQL_START,
-                    Payload = new GraphQLRequest("simplequerystring")
-                }
-            };
-            yield return new object[] {
-                "{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null,\"extensions\":null}}",
-                new GraphQLWebSocketRequest {
-                    Id = "34476567",
-                    Type = GraphQLWebSocketMessageType.GQL_START,
-                    Payload = new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
-                }
-
-            };
-        }
+        yield return new object[] {
+            "{\"id\":\"1234567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null}}",
+            new GraphQLWebSocketRequest {
+                Id = "1234567",
+                Type = GraphQLWebSocketMessageType.GQL_START,
+                Payload = new GraphQLRequest("simplequerystring")
+            }
+        };
+        yield return new object[] {
+            "{\"id\":\"34476567\",\"type\":\"start\",\"payload\":{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null,\"extensions\":null}}",
+            new GraphQLWebSocketRequest {
+                Id = "34476567",
+                Type = GraphQLWebSocketMessageType.GQL_START,
+                Payload = new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
+            }
 
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        };
     }
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 87634dad..395b9efc 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -3,40 +3,39 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace GraphQL.Client.Serializer.Tests.TestData
+namespace GraphQL.Client.Serializer.Tests.TestData;
+
+public class SerializeToStringTestData : IEnumerable<object[]>
 {
-    public class SerializeToStringTestData : IEnumerable<object[]>
+    public IEnumerator<object[]> GetEnumerator()
     {
-        public IEnumerator<object[]> GetEnumerator()
-        {
-            yield return new object[] {
-                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null}",
-                new GraphQLRequest("simple query string")
-            };
-            yield return new object[] {
-                "{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null,\"extensions\":null}",
-                new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
-            };
-            yield return new object[] {
-                "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null,\"authentication\":\"an-authentication-token\"}",
-                new GraphQLRequest("simple query string"){{"authentication", "an-authentication-token"}}
-            };
-            yield return new object[] {
-                "{\"query\":\"enumtest\",\"variables\":{\"enums\":[\"REGULAR\",\"PASCAL_CASE\",\"CAMEL_CASE\",\"LOWER\",\"UPPER\",\"CONSTANT_CASE\"]},\"operationName\":null,\"extensions\":null}",
-                new GraphQLRequest("enumtest", new { enums = Enum.GetValues(typeof(TestEnum)).Cast<TestEnum>()})
-            };
-        }
+        yield return new object[] {
+            "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null}",
+            new GraphQLRequest("simple query string")
+        };
+        yield return new object[] {
+            "{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null,\"extensions\":null}",
+            new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})
+        };
+        yield return new object[] {
+            "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null,\"authentication\":\"an-authentication-token\"}",
+            new GraphQLRequest("simple query string"){{"authentication", "an-authentication-token"}}
+        };
+        yield return new object[] {
+            "{\"query\":\"enumtest\",\"variables\":{\"enums\":[\"REGULAR\",\"PASCAL_CASE\",\"CAMEL_CASE\",\"LOWER\",\"UPPER\",\"CONSTANT_CASE\"]},\"operationName\":null,\"extensions\":null}",
+            new GraphQLRequest("enumtest", new { enums = Enum.GetValues(typeof(TestEnum)).Cast<TestEnum>()})
+        };
+    }
 
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-        public enum TestEnum
-        {
-            Regular,
-            PascalCase,
-            camelCase,
-            lower,
-            UPPER,
-            CONSTANT_CASE
-        }
+    public enum TestEnum
+    {
+        Regular,
+        PascalCase,
+        camelCase,
+        lower,
+        UPPER,
+        CONSTANT_CASE
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
index 70a51a72..b2c551ce 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageMutationResult.cs
@@ -1,12 +1,11 @@
-namespace GraphQL.Client.Tests.Common.Chat
+namespace GraphQL.Client.Tests.Common.Chat;
+
+public class AddMessageMutationResult
 {
-    public class AddMessageMutationResult
-    {
-        public AddMessageContent AddMessage { get; set; }
+    public AddMessageContent AddMessage { get; set; }
 
-        public class AddMessageContent
-        {
-            public string Content { get; set; }
-        }
+    public class AddMessageContent
+    {
+        public string Content { get; set; }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
index 916054e8..8f55c02c 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/AddMessageVariables.cs
@@ -1,16 +1,15 @@
-namespace GraphQL.Client.Tests.Common.Chat
+namespace GraphQL.Client.Tests.Common.Chat;
+
+public class AddMessageVariables
 {
-    public class AddMessageVariables
-    {
-        public AddMessageInput Input { get; set; }
+    public AddMessageInput Input { get; set; }
 
-        public class AddMessageInput
-        {
-            public string FromId { get; set; }
+    public class AddMessageInput
+    {
+        public string FromId { get; set; }
 
-            public string Content { get; set; }
+        public string Content { get; set; }
 
-            public string SentAt { get; set; }
-        }
+        public string SentAt { get; set; }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
index 47edfc28..fa10984a 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/GraphQLClientChatExtensions.cs
@@ -1,46 +1,45 @@
 using GraphQL.Client.Abstractions;
 
-namespace GraphQL.Client.Tests.Common.Chat
+namespace GraphQL.Client.Tests.Common.Chat;
+
+public static class GraphQLClientChatExtensions
 {
-    public static class GraphQLClientChatExtensions
-    {
-        public const string ADD_MESSAGE_QUERY =
+    public const string ADD_MESSAGE_QUERY =
 @"mutation($input: MessageInputType){
   addMessage(message: $input){
     content
   }
 }";
 
-        public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message)
+    public static Task<GraphQLResponse<AddMessageMutationResult>> AddMessageAsync(this IGraphQLClient client, string message)
+    {
+        var variables = new AddMessageVariables
         {
-            var variables = new AddMessageVariables
+            Input = new AddMessageVariables.AddMessageInput
             {
-                Input = new AddMessageVariables.AddMessageInput
-                {
-                    FromId = "2",
-                    Content = message,
-                    SentAt = DateTime.Now.ToString("s")
-                }
-            };
+                FromId = "2",
+                Content = message,
+                SentAt = DateTime.Now.ToString("s")
+            }
+        };
 
-            var graphQLRequest = new GraphQLRequest(ADD_MESSAGE_QUERY, variables);
-            return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
-        }
+        var graphQLRequest = new GraphQLRequest(ADD_MESSAGE_QUERY, variables);
+        return client.SendMutationAsync<AddMessageMutationResult>(graphQLRequest);
+    }
 
-        public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this IGraphQLClient client)
-        {
-            var graphQLRequest = new GraphQLRequest(@"
+    public static Task<GraphQLResponse<JoinDeveloperMutationResult>> JoinDeveloperUser(this IGraphQLClient client)
+    {
+        var graphQLRequest = new GraphQLRequest(@"
 				mutation($userId: String){
 				  join(userId: $userId){
 				    displayName
 				    id
 				  }
 				}",
-                new
-                {
-                    userId = "1"
-                });
-            return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
-        }
+            new
+            {
+                userId = "1"
+            });
+        return client.SendMutationAsync<JoinDeveloperMutationResult>(graphQLRequest);
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
index c9910444..d55bf0ca 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/JoinDeveloperMutationResult.cs
@@ -1,14 +1,13 @@
-namespace GraphQL.Client.Tests.Common.Chat
+namespace GraphQL.Client.Tests.Common.Chat;
+
+public class JoinDeveloperMutationResult
 {
-    public class JoinDeveloperMutationResult
-    {
-        public JoinContent Join { get; set; }
+    public JoinContent Join { get; set; }
 
-        public class JoinContent
-        {
-            public string DisplayName { get; set; }
+    public class JoinContent
+    {
+        public string DisplayName { get; set; }
 
-            public string Id { get; set; }
-        }
+        public string Id { get; set; }
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
index ecfeaf00..a1f185fb 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
@@ -1,16 +1,15 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class CapitalizedFieldsGraphType : ObjectGraphType
 {
-    public class CapitalizedFieldsGraphType : ObjectGraphType
+    public CapitalizedFieldsGraphType()
     {
-        public CapitalizedFieldsGraphType()
-        {
-            Name = "CapitalizedFields";
+        Name = "CapitalizedFields";
 
-            Field<StringGraphType>()
-                .Name("StringField")
-                .Resolve(context => "hello world");
-        }
+        Field<StringGraphType>()
+            .Name("StringField")
+            .Resolve(context => "hello world");
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
index b005ebc2..788eaaba 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
@@ -1,42 +1,41 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class ChatMutation : ObjectGraphType<object>
 {
-    public class ChatMutation : ObjectGraphType<object>
+    public ChatMutation(IChat chat)
     {
-        public ChatMutation(IChat chat)
-        {
-            Field<MessageType>("addMessage",
-                arguments: new QueryArguments(
-                    new QueryArgument<MessageInputType> { Name = "message" }
-                ),
-                resolve: context =>
-                {
-                    var receivedMessage = context.GetArgument<ReceivedMessage>("message");
-                    var message = chat.AddMessage(receivedMessage);
-                    return message;
-                });
+        Field<MessageType>("addMessage",
+            arguments: new QueryArguments(
+                new QueryArgument<MessageInputType> { Name = "message" }
+            ),
+            resolve: context =>
+            {
+                var receivedMessage = context.GetArgument<ReceivedMessage>("message");
+                var message = chat.AddMessage(receivedMessage);
+                return message;
+            });
 
-            Field<MessageFromType>("join",
-                arguments: new QueryArguments(
-                    new QueryArgument<StringGraphType> { Name = "userId" }
-                ),
-                resolve: context =>
-                {
-                    var userId = context.GetArgument<string>("userId");
-                    var userJoined = chat.Join(userId);
-                    return userJoined;
-                });
-        }
+        Field<MessageFromType>("join",
+            arguments: new QueryArguments(
+                new QueryArgument<StringGraphType> { Name = "userId" }
+            ),
+            resolve: context =>
+            {
+                var userId = context.GetArgument<string>("userId");
+                var userJoined = chat.Join(userId);
+                return userJoined;
+            });
     }
+}
 
-    public class MessageInputType : InputObjectGraphType
+public class MessageInputType : InputObjectGraphType
+{
+    public MessageInputType()
     {
-        public MessageInputType()
-        {
-            Field<StringGraphType>("fromId");
-            Field<StringGraphType>("content");
-            Field<DateTimeGraphType>("sentAt");
-        }
+        Field<StringGraphType>("fromId");
+        Field<StringGraphType>("content");
+        Field<DateTimeGraphType>("sentAt");
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 5645beb8..854a4a75 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -1,43 +1,42 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class ChatQuery : ObjectGraphType
 {
-    public class ChatQuery : ObjectGraphType
+    public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
+        {"extension1", "hello world"},
+        {"another extension", 4711},
+        {"long", 19942590700}
+    };
+
+    // properties for unit testing
+
+    public readonly ManualResetEventSlim LongRunningQueryBlocker = new ManualResetEventSlim();
+    public readonly ManualResetEventSlim WaitingOnQueryBlocker = new ManualResetEventSlim();
+
+    public ChatQuery(IChat chat)
     {
-        public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
-            {"extension1", "hello world"},
-            {"another extension", 4711},
-            {"long", 19942590700}
-        };
-
-        // properties for unit testing
-
-        public readonly ManualResetEventSlim LongRunningQueryBlocker = new ManualResetEventSlim();
-        public readonly ManualResetEventSlim WaitingOnQueryBlocker = new ManualResetEventSlim();
-
-        public ChatQuery(IChat chat)
-        {
-            Name = "ChatQuery";
-
-            Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
-
-            Field<StringGraphType>()
-                .Name("extensionsTest")
-                .Resolve(context =>
-                {
-                    context.Errors.Add(new ExecutionError("this error contains extension fields", TestExtensions));
-                    return null;
-                });
-
-            Field<StringGraphType>()
-                .Name("longRunning")
-                .Resolve(context =>
-                {
-                    WaitingOnQueryBlocker.Set();
-                    LongRunningQueryBlocker.Wait();
-                    WaitingOnQueryBlocker.Reset();
-                    return "finally returned";
-                });
-        }
+        Name = "ChatQuery";
+
+        Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+
+        Field<StringGraphType>()
+            .Name("extensionsTest")
+            .Resolve(context =>
+            {
+                context.Errors.Add(new ExecutionError("this error contains extension fields", TestExtensions));
+                return null;
+            });
+
+        Field<StringGraphType>()
+            .Name("longRunning")
+            .Resolve(context =>
+            {
+                WaitingOnQueryBlocker.Set();
+                LongRunningQueryBlocker.Wait();
+                WaitingOnQueryBlocker.Reset();
+                return "finally returned";
+            });
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
index d606cdbd..9cacc7d4 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSchema.cs
@@ -1,15 +1,14 @@
 using Microsoft.Extensions.DependencyInjection;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class ChatSchema : Types.Schema
 {
-    public class ChatSchema : Types.Schema
+    public ChatSchema(IServiceProvider services)
+        : base(services)
     {
-        public ChatSchema(IServiceProvider services)
-            : base(services)
-        {
-            Query = services.GetRequiredService<ChatQuery>();
-            Mutation = services.GetRequiredService<ChatMutation>();
-            Subscription = services.GetRequiredService<ChatSubscriptions>();
-        }
+        Query = services.GetRequiredService<ChatQuery>();
+        Mutation = services.GetRequiredService<ChatMutation>();
+        Subscription = services.GetRequiredService<ChatSubscriptions>();
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
index 58dcd240..3a4f62e1 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
@@ -4,92 +4,91 @@
 using GraphQL.Server.Transports.Subscriptions.Abstractions;
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class ChatSubscriptions : ObjectGraphType<object>
 {
-    public class ChatSubscriptions : ObjectGraphType<object>
+    private readonly IChat _chat;
+
+    public ChatSubscriptions(IChat chat)
     {
-        private readonly IChat _chat;
+        _chat = chat;
+        AddField(new FieldType
+        {
+            Name = "messageAdded",
+            Type = typeof(MessageType),
+            Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+            StreamResolver = new SourceStreamResolver<Message>(Subscribe)
+        });
+
+        AddField(new FieldType
+        {
+            Name = "contentAdded",
+            Type = typeof(MessageType),
+            Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+            StreamResolver = new SourceStreamResolver<Message>(Subscribe)
+        });
 
-        public ChatSubscriptions(IChat chat)
+        AddField(new FieldType
         {
-            _chat = chat;
-            AddField(new FieldType
-            {
-                Name = "messageAdded",
-                Type = typeof(MessageType),
-                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                StreamResolver = new SourceStreamResolver<Message>(Subscribe)
-            });
-
-            AddField(new FieldType
-            {
-                Name = "contentAdded",
-                Type = typeof(MessageType),
-                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                StreamResolver = new SourceStreamResolver<Message>(Subscribe)
-            });
-
-            AddField(new FieldType
-            {
-                Name = "messageAddedByUser",
-                Arguments = new QueryArguments(
-                    new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id" }
-                ),
-                Type = typeof(MessageType),
-                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                StreamResolver = new SourceStreamResolver<Message>(SubscribeById)
-            });
-
-            AddField(new FieldType
-            {
-                Name = "userJoined",
-                Type = typeof(MessageFromType),
-                Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
-                StreamResolver = new SourceStreamResolver<MessageFrom>(context => _chat.UserJoined())
-            });
-
-
-            AddField(new FieldType
-            {
-                Name = "failImmediately",
-                Type = typeof(MessageType),
-                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
-                StreamResolver = new SourceStreamResolver<Message>((Func<IResolveFieldContext, IObservable<Message>>)(context => throw new NotSupportedException("this is supposed to fail")))
-            });
-        }
-
-        private IObservable<Message> SubscribeById(IResolveFieldContext context)
+            Name = "messageAddedByUser",
+            Arguments = new QueryArguments(
+                new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id" }
+            ),
+            Type = typeof(MessageType),
+            Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+            StreamResolver = new SourceStreamResolver<Message>(SubscribeById)
+        });
+
+        AddField(new FieldType
         {
-            var messageContext = (MessageHandlingContext)context.UserContext;
-            var user = messageContext.Get<ClaimsPrincipal>("user");
+            Name = "userJoined",
+            Type = typeof(MessageFromType),
+            Resolver = new FuncFieldResolver<MessageFrom>(context => context.Source as MessageFrom),
+            StreamResolver = new SourceStreamResolver<MessageFrom>(context => _chat.UserJoined())
+        });
 
-            var sub = "Anonymous";
-            if (user != null)
-                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
 
-            var messages = _chat.Messages(sub);
+        AddField(new FieldType
+        {
+            Name = "failImmediately",
+            Type = typeof(MessageType),
+            Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+            StreamResolver = new SourceStreamResolver<Message>((Func<IResolveFieldContext, IObservable<Message>>)(context => throw new NotSupportedException("this is supposed to fail")))
+        });
+    }
 
-            var id = context.GetArgument<string>("id");
-            return messages.Where(message => message.From.Id == id);
-        }
+    private IObservable<Message> SubscribeById(IResolveFieldContext context)
+    {
+        var messageContext = (MessageHandlingContext)context.UserContext;
+        var user = messageContext.Get<ClaimsPrincipal>("user");
 
-        private Message ResolveMessage(IResolveFieldContext context)
-        {
-            var message = context.Source as Message;
+        var sub = "Anonymous";
+        if (user != null)
+            sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
 
-            return message;
-        }
+        var messages = _chat.Messages(sub);
 
-        private IObservable<Message> Subscribe(IResolveFieldContext context)
-        {
-            var messageContext = (MessageHandlingContext)context.UserContext;
-            var user = messageContext.Get<ClaimsPrincipal>("user");
+        var id = context.GetArgument<string>("id");
+        return messages.Where(message => message.From.Id == id);
+    }
+
+    private Message ResolveMessage(IResolveFieldContext context)
+    {
+        var message = context.Source as Message;
+
+        return message;
+    }
+
+    private IObservable<Message> Subscribe(IResolveFieldContext context)
+    {
+        var messageContext = (MessageHandlingContext)context.UserContext;
+        var user = messageContext.Get<ClaimsPrincipal>("user");
 
-            var sub = "Anonymous";
-            if (user != null)
-                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+        var sub = "Anonymous";
+        if (user != null)
+            sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
 
-            return _chat.Messages(sub);
-        }
+        return _chat.Messages(sub);
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
index bfbdeb32..a00a35dc 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/IChat.cs
@@ -4,108 +4,107 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public interface IChat
 {
-    public interface IChat
-    {
-        ConcurrentStack<Message> AllMessages { get; }
+    ConcurrentStack<Message> AllMessages { get; }
 
-        Message AddMessage(Message message);
+    Message AddMessage(Message message);
 
-        MessageFrom Join(string userId);
+    MessageFrom Join(string userId);
 
-        IObservable<Message> Messages(string user);
-        IObservable<MessageFrom> UserJoined();
+    IObservable<Message> Messages(string user);
+    IObservable<MessageFrom> UserJoined();
 
-        Message AddMessage(ReceivedMessage message);
-    }
+    Message AddMessage(ReceivedMessage message);
+}
 
-    public class Chat : IChat
-    {
-        private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
-        private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
+public class Chat : IChat
+{
+    private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+    private readonly ISubject<MessageFrom> _userJoined = new Subject<MessageFrom>();
 
-        public Chat()
+    public Chat()
+    {
+        AllMessages = new ConcurrentStack<Message>();
+        Users = new ConcurrentDictionary<string, string>
         {
-            AllMessages = new ConcurrentStack<Message>();
-            Users = new ConcurrentDictionary<string, string>
-            {
-                ["1"] = "developer",
-                ["2"] = "tester"
-            };
-        }
+            ["1"] = "developer",
+            ["2"] = "tester"
+        };
+    }
 
-        public ConcurrentDictionary<string, string> Users { get; private set; }
+    public ConcurrentDictionary<string, string> Users { get; private set; }
 
-        public ConcurrentStack<Message> AllMessages { get; private set; }
+    public ConcurrentStack<Message> AllMessages { get; private set; }
+
+    public Message AddMessage(ReceivedMessage message)
+    {
+        if (!Users.TryGetValue(message.FromId, out var displayName))
+        {
+            displayName = "(unknown)";
+        }
 
-        public Message AddMessage(ReceivedMessage message)
+        return AddMessage(new Message
         {
-            if (!Users.TryGetValue(message.FromId, out var displayName))
+            Content = message.Content,
+            SentAt = message.SentAt,
+            From = new MessageFrom
             {
-                displayName = "(unknown)";
+                DisplayName = displayName,
+                Id = message.FromId
             }
+        });
+    }
 
-            return AddMessage(new Message
-            {
-                Content = message.Content,
-                SentAt = message.SentAt,
-                From = new MessageFrom
-                {
-                    DisplayName = displayName,
-                    Id = message.FromId
-                }
-            });
-        }
+    public Message AddMessage(Message message)
+    {
+        AllMessages.Push(message);
+        _messageStream.OnNext(message);
+        return message;
+    }
 
-        public Message AddMessage(Message message)
+    public MessageFrom Join(string userId)
+    {
+        if (!Users.TryGetValue(userId, out var displayName))
         {
-            AllMessages.Push(message);
-            _messageStream.OnNext(message);
-            return message;
+            displayName = "(unknown)";
         }
 
-        public MessageFrom Join(string userId)
+        var joinedUser = new MessageFrom
         {
-            if (!Users.TryGetValue(userId, out var displayName))
-            {
-                displayName = "(unknown)";
-            }
+            Id = userId,
+            DisplayName = displayName
+        };
+
+        _userJoined.OnNext(joinedUser);
+        return joinedUser;
+    }
 
-            var joinedUser = new MessageFrom
+    public IObservable<Message> Messages(string user) =>
+        Observable.Create<Message>(observer =>
+        {
+            Debug.WriteLine($"creating messages stream for user '{user}' on thread {Thread.CurrentThread.ManagedThreadId}");
+            return new CompositeDisposable
             {
-                Id = userId,
-                DisplayName = displayName
+                _messageStream.Select(message =>
+                    {
+                        message.Sub = user;
+                        return message;
+                    })
+                    .Subscribe(observer),
+                Disposable.Create(() => Debug.WriteLine($"disposing messages stream for user '{user}' on thread {Thread.CurrentThread.ManagedThreadId}"))
             };
+        });
 
-            _userJoined.OnNext(joinedUser);
-            return joinedUser;
-        }
+    public void AddError(Exception exception) => _messageStream.OnError(exception);
 
-        public IObservable<Message> Messages(string user) =>
-            Observable.Create<Message>(observer =>
-            {
-                Debug.WriteLine($"creating messages stream for user '{user}' on thread {Thread.CurrentThread.ManagedThreadId}");
-                return new CompositeDisposable
-                {
-                    _messageStream.Select(message =>
-                        {
-                            message.Sub = user;
-                            return message;
-                        })
-                        .Subscribe(observer),
-                    Disposable.Create(() => Debug.WriteLine($"disposing messages stream for user '{user}' on thread {Thread.CurrentThread.ManagedThreadId}"))
-                };
-            });
-
-        public void AddError(Exception exception) => _messageStream.OnError(exception);
-
-        public IObservable<MessageFrom> UserJoined() => _userJoined.AsObservable();
-    }
+    public IObservable<MessageFrom> UserJoined() => _userJoined.AsObservable();
+}
 
-    public class User
-    {
-        public string Id { get; set; }
-        public string Name { get; set; }
-    }
+public class User
+{
+    public string Id { get; set; }
+    public string Name { get; set; }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
index e344caee..aaf77218 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/Message.cs
@@ -1,13 +1,12 @@
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class Message
 {
-    public class Message
-    {
-        public MessageFrom From { get; set; }
+    public MessageFrom From { get; set; }
 
-        public string Sub { get; set; }
+    public string Sub { get; set; }
 
-        public string Content { get; set; }
+    public string Content { get; set; }
 
-        public DateTime SentAt { get; set; }
-    }
+    public DateTime SentAt { get; set; }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
index 203f979b..637d5198 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFrom.cs
@@ -1,9 +1,8 @@
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class MessageFrom
 {
-    public class MessageFrom
-    {
-        public string Id { get; set; }
+    public string Id { get; set; }
 
-        public string DisplayName { get; set; }
-    }
+    public string DisplayName { get; set; }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
index 045e473b..45cb68d7 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageFromType.cs
@@ -1,13 +1,12 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class MessageFromType : ObjectGraphType<MessageFrom>
 {
-    public class MessageFromType : ObjectGraphType<MessageFrom>
+    public MessageFromType()
     {
-        public MessageFromType()
-        {
-            Field(o => o.Id);
-            Field(o => o.DisplayName);
-        }
+        Field(o => o.Id);
+        Field(o => o.DisplayName);
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
index e72a0067..a1c8c837 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/MessageType.cs
@@ -1,21 +1,20 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class MessageType : ObjectGraphType<Message>
 {
-    public class MessageType : ObjectGraphType<Message>
+    public MessageType()
     {
-        public MessageType()
-        {
-            Field(o => o.Content);
-            Field(o => o.SentAt);
-            Field(o => o.Sub);
-            Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
-        }
+        Field(o => o.Content);
+        Field(o => o.SentAt);
+        Field(o => o.Sub);
+        Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
+    }
 
-        private MessageFrom ResolveFrom(IResolveFieldContext<Message> context)
-        {
-            var message = context.Source;
-            return message.From;
-        }
+    private MessageFrom ResolveFrom(IResolveFieldContext<Message> context)
+    {
+        var message = context.Source;
+        return message.From;
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
index 95d7d295..78a675dc 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ReceivedMessage.cs
@@ -1,11 +1,10 @@
-namespace GraphQL.Client.Tests.Common.Chat.Schema
+namespace GraphQL.Client.Tests.Common.Chat.Schema;
+
+public class ReceivedMessage
 {
-    public class ReceivedMessage
-    {
-        public string FromId { get; set; }
+    public string FromId { get; set; }
 
-        public string Content { get; set; }
+    public string Content { get; set; }
 
-        public DateTime SentAt { get; set; }
-    }
+    public DateTime SentAt { get; set; }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Common.cs b/tests/GraphQL.Client.Tests.Common/Common.cs
index 269ea257..83fa8929 100644
--- a/tests/GraphQL.Client.Tests.Common/Common.cs
+++ b/tests/GraphQL.Client.Tests.Common/Common.cs
@@ -3,52 +3,51 @@
 using GraphQL.Client.Tests.Common.StarWars.Types;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace GraphQL.Client.Tests.Common
+namespace GraphQL.Client.Tests.Common;
+
+public static class Common
 {
-    public static class Common
-    {
-        public const string STAR_WARS_ENDPOINT = "/graphql/starwars";
-        public const string CHAT_ENDPOINT = "/graphql/chat";
+    public const string STAR_WARS_ENDPOINT = "/graphql/starwars";
+    public const string CHAT_ENDPOINT = "/graphql/chat";
 
-        public static StarWarsSchema GetStarWarsSchema()
-        {
-            var services = new ServiceCollection();
-            services.AddStarWarsSchema();
-            return services.BuildServiceProvider().GetRequiredService<StarWarsSchema>();
-        }
+    public static StarWarsSchema GetStarWarsSchema()
+    {
+        var services = new ServiceCollection();
+        services.AddStarWarsSchema();
+        return services.BuildServiceProvider().GetRequiredService<StarWarsSchema>();
+    }
 
-        public static ChatSchema GetChatSchema()
-        {
-            var services = new ServiceCollection();
-            services.AddChatSchema();
-            return services.BuildServiceProvider().GetRequiredService<ChatSchema>();
-        }
+    public static ChatSchema GetChatSchema()
+    {
+        var services = new ServiceCollection();
+        services.AddChatSchema();
+        return services.BuildServiceProvider().GetRequiredService<ChatSchema>();
+    }
 
-        public static void AddStarWarsSchema(this IServiceCollection services)
-        {
-            services.AddSingleton<StarWarsData>();
-            services.AddSingleton<StarWarsQuery>();
-            services.AddSingleton<StarWarsMutation>();
-            services.AddSingleton<StarWarsSchema>();
-            services.AddTransient<CharacterInterface>();
-            services.AddTransient<DroidType>();
-            services.AddTransient<EpisodeEnum>();
-            services.AddTransient<HumanType>();
-            services.AddTransient<HumanInputType>();
-        }
+    public static void AddStarWarsSchema(this IServiceCollection services)
+    {
+        services.AddSingleton<StarWarsData>();
+        services.AddSingleton<StarWarsQuery>();
+        services.AddSingleton<StarWarsMutation>();
+        services.AddSingleton<StarWarsSchema>();
+        services.AddTransient<CharacterInterface>();
+        services.AddTransient<DroidType>();
+        services.AddTransient<EpisodeEnum>();
+        services.AddTransient<HumanType>();
+        services.AddTransient<HumanInputType>();
+    }
 
-        public static void AddChatSchema(this IServiceCollection services)
-        {
-            var chat = new Chat.Schema.Chat();
-            services.AddSingleton(chat);
-            services.AddSingleton<IChat>(chat);
-            services.AddSingleton<ChatSchema>();
-            services.AddSingleton<ChatQuery>();
-            services.AddSingleton<ChatMutation>();
-            services.AddSingleton<ChatSubscriptions>();
-            services.AddSingleton<MessageType>();
-            services.AddSingleton<MessageInputType>();
-            services.AddSingleton<MessageFromType>();
-        }
+    public static void AddChatSchema(this IServiceCollection services)
+    {
+        var chat = new Chat.Schema.Chat();
+        services.AddSingleton(chat);
+        services.AddSingleton<IChat>(chat);
+        services.AddSingleton<ChatSchema>();
+        services.AddSingleton<ChatQuery>();
+        services.AddSingleton<ChatMutation>();
+        services.AddSingleton<ChatSubscriptions>();
+        services.AddSingleton<MessageType>();
+        services.AddSingleton<MessageInputType>();
+        services.AddSingleton<MessageFromType>();
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
index dca19832..465a31a1 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/AvailableJsonSerializers.cs
@@ -1,22 +1,21 @@
 using System.Collections;
 using GraphQL.Client.Abstractions;
 
-namespace GraphQL.Client.Tests.Common.Helpers
+namespace GraphQL.Client.Tests.Common.Helpers;
+
+public class AvailableJsonSerializers<TSerializerInterface> : IEnumerable<object[]> where TSerializerInterface : IGraphQLJsonSerializer
 {
-    public class AvailableJsonSerializers<TSerializerInterface> : IEnumerable<object[]> where TSerializerInterface : IGraphQLJsonSerializer
+    public IEnumerator<object[]> GetEnumerator()
     {
-        public IEnumerator<object[]> GetEnumerator()
-        {
-            // try to find one in the assembly and assign that
-            var type = typeof(TSerializerInterface);
-            return AppDomain.CurrentDomain
-                .GetAssemblies()
-                .SelectMany(s => s.GetTypes())
-                .Where(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract)
-                .Select(serializerType => new object[] { Activator.CreateInstance(serializerType) })
-                .GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        // try to find one in the assembly and assign that
+        var type = typeof(TSerializerInterface);
+        return AppDomain.CurrentDomain
+            .GetAssemblies()
+            .SelectMany(s => s.GetTypes())
+            .Where(p => type.IsAssignableFrom(p) && !p.IsInterface && !p.IsAbstract)
+            .Select(serializerType => new object[] { Activator.CreateInstance(serializerType) })
+            .GetEnumerator();
     }
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index 3603041c..eaf2e10c 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -3,90 +3,89 @@
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 
-namespace GraphQL.Client.Tests.Common.Helpers
+namespace GraphQL.Client.Tests.Common.Helpers;
+
+public class CallbackMonitor<T>
 {
-    public class CallbackMonitor<T>
-    {
-        private readonly ManualResetEventSlim _callbackInvoked = new ManualResetEventSlim();
+    private readonly ManualResetEventSlim _callbackInvoked = new ManualResetEventSlim();
 
-        /// <summary>
-        /// The timeout for <see cref="CallbackAssertions{T}.HaveBeenInvokedWithPayload(TimeSpan, string, object[])"/>. Defaults to 1 second.
-        /// </summary>
-        public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+    /// <summary>
+    /// The timeout for <see cref="CallbackAssertions{T}.HaveBeenInvokedWithPayload(TimeSpan, string, object[])"/>. Defaults to 1 second.
+    /// </summary>
+    public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
 
-        /// <summary>
-        /// Indicates that an update has been received since the last <see cref="Reset"/>
-        /// </summary>
-        public bool CallbackInvoked => _callbackInvoked.IsSet;
+    /// <summary>
+    /// Indicates that an update has been received since the last <see cref="Reset"/>
+    /// </summary>
+    public bool CallbackInvoked => _callbackInvoked.IsSet;
 
-        /// <summary>
-        /// The last payload which was received.
-        /// </summary>
-        public T LastPayload { get; private set; }
+    /// <summary>
+    /// The last payload which was received.
+    /// </summary>
+    public T LastPayload { get; private set; }
 
-        public void Invoke(T param)
-        {
-            LastPayload = param;
-            Debug.WriteLine($"CallbackMonitor invoke handler thread id: {Thread.CurrentThread.ManagedThreadId}");
-            _callbackInvoked.Set();
-        }
+    public void Invoke(T param)
+    {
+        LastPayload = param;
+        Debug.WriteLine($"CallbackMonitor invoke handler thread id: {Thread.CurrentThread.ManagedThreadId}");
+        _callbackInvoked.Set();
+    }
 
-        /// <summary>
-        /// Resets the tester class. Should be called before triggering the potential update
-        /// </summary>
-        public void Reset()
-        {
-            LastPayload = default;
-            _callbackInvoked.Reset();
-        }
+    /// <summary>
+    /// Resets the tester class. Should be called before triggering the potential update
+    /// </summary>
+    public void Reset()
+    {
+        LastPayload = default;
+        _callbackInvoked.Reset();
+    }
 
-        public CallbackAssertions<T> Should() => new CallbackAssertions<T>(this);
+    public CallbackAssertions<T> Should() => new CallbackAssertions<T>(this);
 
-        public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>>
-        {
-            public CallbackAssertions(CallbackMonitor<TPayload> tester): base(tester)
-            { }
+    public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>>
+    {
+        public CallbackAssertions(CallbackMonitor<TPayload> tester): base(tester)
+        { }
 
-            protected override string Identifier => "callback";
+        protected override string Identifier => "callback";
 
-            public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(TimeSpan timeout,
-                string because = "", params object[] becauseArgs)
-            {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .Given(() =>
-                    {
-                        Debug.WriteLine($"HaveBeenInvokedWithPayload thread id: {Thread.CurrentThread.ManagedThreadId}");
-                        return Subject._callbackInvoked.Wait(timeout);
-                    })
-                    .ForCondition(isSet => isSet)
-                    .FailWith("Expected {context:callback} to be invoked{reason}, but did not receive a call within {0}", timeout);
+        public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
+                .Given(() =>
+                {
+                    Debug.WriteLine($"HaveBeenInvokedWithPayload thread id: {Thread.CurrentThread.ManagedThreadId}");
+                    return Subject._callbackInvoked.Wait(timeout);
+                })
+                .ForCondition(isSet => isSet)
+                .FailWith("Expected {context:callback} to be invoked{reason}, but did not receive a call within {0}", timeout);
 
-                Subject._callbackInvoked.Reset();
-                return new AndWhichConstraint<CallbackAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
-            }
-            public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(string because = "", params object[] becauseArgs)
-                => HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
+            Subject._callbackInvoked.Reset();
+            return new AndWhichConstraint<CallbackAssertions<TPayload>, TPayload>(this, Subject.LastPayload);
+        }
+        public AndWhichConstraint<CallbackAssertions<TPayload>, TPayload> HaveBeenInvokedWithPayload(string because = "", params object[] becauseArgs)
+            => HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
 
-            public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(TimeSpan timeout, string because = "", params object[] becauseArgs)
-                => HaveBeenInvokedWithPayload(timeout, because, becauseArgs);
-            public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(string because = "", params object[] becauseArgs)
-                => HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
+        public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(TimeSpan timeout, string because = "", params object[] becauseArgs)
+            => HaveBeenInvokedWithPayload(timeout, because, becauseArgs);
+        public AndConstraint<CallbackAssertions<TPayload>> HaveBeenInvoked(string because = "", params object[] becauseArgs)
+            => HaveBeenInvokedWithPayload(Subject.Timeout, because, becauseArgs);
 
-            public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(TimeSpan timeout,
-                string because = "", params object[] becauseArgs)
-            {
-                Execute.Assertion
-                    .BecauseOf(because, becauseArgs)
-                    .Given(() => Subject._callbackInvoked.Wait(timeout))
-                    .ForCondition(isSet => !isSet)
-                    .FailWith("Expected {context:callback} to not be invoked{reason}, but did receive a call: {0}", Subject.LastPayload);
+        public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(TimeSpan timeout,
+            string because = "", params object[] becauseArgs)
+        {
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
+                .Given(() => Subject._callbackInvoked.Wait(timeout))
+                .ForCondition(isSet => !isSet)
+                .FailWith("Expected {context:callback} to not be invoked{reason}, but did receive a call: {0}", Subject.LastPayload);
 
-                Subject._callbackInvoked.Reset();
-                return new AndConstraint<CallbackAssertions<TPayload>>(this);
-            }
-            public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(string because = "", params object[] becauseArgs)
-                => NotHaveBeenInvoked(TimeSpan.FromMilliseconds(100), because, becauseArgs);
+            Subject._callbackInvoked.Reset();
+            return new AndConstraint<CallbackAssertions<TPayload>>(this);
         }
+        public AndConstraint<CallbackAssertions<TPayload>> NotHaveBeenInvoked(string because = "", params object[] becauseArgs)
+            => NotHaveBeenInvoked(TimeSpan.FromMilliseconds(100), because, becauseArgs);
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
index 6d957c38..c49849ed 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
@@ -1,52 +1,51 @@
-namespace GraphQL.Client.Tests.Common.Helpers
-{
-    public class ConcurrentTaskWrapper
-    {
-        public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) => new ConcurrentTaskWrapper<TResult>(createTask);
+namespace GraphQL.Client.Tests.Common.Helpers;
 
-        private readonly Func<Task> _createTask;
-        private Task _internalTask = null;
-
-        public ConcurrentTaskWrapper(Func<Task> createTask)
-        {
-            _createTask = createTask;
-        }
+public class ConcurrentTaskWrapper
+{
+    public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) => new ConcurrentTaskWrapper<TResult>(createTask);
 
-        public Task Invoke()
-        {
-            if (_internalTask != null)
-                return _internalTask;
+    private readonly Func<Task> _createTask;
+    private Task _internalTask = null;
 
-            return _internalTask = _createTask();
-        }
+    public ConcurrentTaskWrapper(Func<Task> createTask)
+    {
+        _createTask = createTask;
     }
 
-    public class ConcurrentTaskWrapper<TResult>
+    public Task Invoke()
     {
-        private readonly Func<Task<TResult>> _createTask;
-        private Task<TResult> _internalTask = null;
+        if (_internalTask != null)
+            return _internalTask;
 
-        public ConcurrentTaskWrapper(Func<Task<TResult>> createTask)
-        {
-            _createTask = createTask;
-        }
+        return _internalTask = _createTask();
+    }
+}
 
-        public Task<TResult> Invoke()
-        {
-            if (_internalTask != null)
-                return _internalTask;
+public class ConcurrentTaskWrapper<TResult>
+{
+    private readonly Func<Task<TResult>> _createTask;
+    private Task<TResult> _internalTask = null;
 
-            return _internalTask = _createTask();
-        }
+    public ConcurrentTaskWrapper(Func<Task<TResult>> createTask)
+    {
+        _createTask = createTask;
+    }
 
-        public void Start()
-        {
-            if (_internalTask == null)
-                _internalTask = _createTask();
-        }
+    public Task<TResult> Invoke()
+    {
+        if (_internalTask != null)
+            return _internalTask;
 
-        public Func<Task<TResult>> Invoking() => Invoke;
+        return _internalTask = _createTask();
+    }
 
-        public void Clear() => _internalTask = null;
+    public void Start()
+    {
+        if (_internalTask == null)
+            _internalTask = _createTask();
     }
+
+    public Func<Task<TResult>> Invoking() => Invoke;
+
+    public void Clear() => _internalTask = null;
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
index 428d4cca..d51afe07 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/MiscellaneousExtensions.cs
@@ -1,24 +1,23 @@
 using GraphQL.Client.Http;
 
-namespace GraphQL.Client.Tests.Common.Helpers
+namespace GraphQL.Client.Tests.Common.Helpers;
+
+public static class MiscellaneousExtensions
 {
-    public static class MiscellaneousExtensions
-    {
-        public static string RemoveWhitespace(this string input) =>
-            new string(input.ToCharArray()
-                .Where(c => !char.IsWhiteSpace(c))
-                .ToArray());
+    public static string RemoveWhitespace(this string input) =>
+        new string(input.ToCharArray()
+            .Where(c => !char.IsWhiteSpace(c))
+            .ToArray());
 
-        public static CallbackMonitor<GraphQLHttpClient> ConfigureMonitorForOnWebsocketConnected(
-            this GraphQLHttpClient client)
+    public static CallbackMonitor<GraphQLHttpClient> ConfigureMonitorForOnWebsocketConnected(
+        this GraphQLHttpClient client)
+    {
+        var tester = new CallbackMonitor<GraphQLHttpClient>();
+        client.Options.OnWebsocketConnected = c =>
         {
-            var tester = new CallbackMonitor<GraphQLHttpClient>();
-            client.Options.OnWebsocketConnected = c =>
-            {
-                tester.Invoke(c);
-                return Task.CompletedTask;
-            };
-            return tester;
-        }
+            tester.Invoke(c);
+            return Task.CompletedTask;
+        };
+        return tester;
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs b/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
index c55eed75..dda8d6a0 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/NetworkHelpers.cs
@@ -1,17 +1,16 @@
 using System.Net;
 using System.Net.Sockets;
 
-namespace GraphQL.Client.Tests.Common.Helpers
+namespace GraphQL.Client.Tests.Common.Helpers;
+
+public static class NetworkHelpers
 {
-    public static class NetworkHelpers
+    public static int GetFreeTcpPortNumber()
     {
-        public static int GetFreeTcpPortNumber()
-        {
-            var l = new TcpListener(IPAddress.Loopback, 0);
-            l.Start();
-            var port = ((IPEndPoint)l.LocalEndpoint).Port;
-            l.Stop();
-            return port;
-        }
+        var l = new TcpListener(IPAddress.Loopback, 0);
+        l.Start();
+        var port = ((IPEndPoint)l.LocalEndpoint).Port;
+        l.Stop();
+        return port;
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
index ff3a12da..2aac17a6 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Extensions/ResolveFieldContextExtensions.cs
@@ -2,61 +2,60 @@
 using GraphQL.Client.Tests.Common.StarWars.Types;
 using GraphQL.Types.Relay.DataObjects;
 
-namespace GraphQL.Client.Tests.Common.StarWars.Extensions
+namespace GraphQL.Client.Tests.Common.StarWars.Extensions;
+
+public static class ResolveFieldContextExtensions
 {
-    public static class ResolveFieldContextExtensions
+    public static Connection<U> GetPagedResults<T, U>(this IResolveConnectionContext<T> context, StarWarsData data, List<string> ids) where U : StarWarsCharacter
     {
-        public static Connection<U> GetPagedResults<T, U>(this IResolveConnectionContext<T> context, StarWarsData data, List<string> ids) where U : StarWarsCharacter
-        {
-            List<string> idList;
-            List<U> list;
-            string cursor;
-            string endCursor;
-            var pageSize = context.PageSize ?? 20;
+        List<string> idList;
+        List<U> list;
+        string cursor;
+        string endCursor;
+        var pageSize = context.PageSize ?? 20;
 
-            if (context.IsUnidirectional || context.After != null || context.Before == null)
+        if (context.IsUnidirectional || context.After != null || context.Before == null)
+        {
+            if (context.After != null)
+            {
+                idList = ids
+                    .SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.After))
+                    .Take(context.First ?? pageSize).ToList();
+            }
+            else
+            {
+                idList = ids
+                    .Take(context.First ?? pageSize).ToList();
+            }
+        }
+        else
+        {
+            if (context.Before != null)
             {
-                if (context.After != null)
-                {
-                    idList = ids
-                        .SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.After))
-                        .Take(context.First ?? pageSize).ToList();
-                }
-                else
-                {
-                    idList = ids
-                        .Take(context.First ?? pageSize).ToList();
-                }
+                idList = ids.Reverse<string>()
+                    .SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.Before))
+                    .Take(context.Last ?? pageSize).ToList();
             }
             else
             {
-                if (context.Before != null)
-                {
-                    idList = ids.Reverse<string>()
-                        .SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.Before))
-                        .Take(context.Last ?? pageSize).ToList();
-                }
-                else
-                {
-                    idList = ids.Reverse<string>()
-                        .Take(context.Last ?? pageSize).ToList();
-                }
+                idList = ids.Reverse<string>()
+                    .Take(context.Last ?? pageSize).ToList();
             }
+        }
 
-            list = data.GetCharactersAsync(idList).Result as List<U> ?? throw new InvalidOperationException($"GetCharactersAsync method should return list of '{typeof(U).Name}' items.");
-            cursor = list.Count > 0 ? list.Last().Cursor : null;
-            endCursor = ids.Count > 0 ? Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(ids.Last())) : null;
+        list = data.GetCharactersAsync(idList).Result as List<U> ?? throw new InvalidOperationException($"GetCharactersAsync method should return list of '{typeof(U).Name}' items.");
+        cursor = list.Count > 0 ? list.Last().Cursor : null;
+        endCursor = ids.Count > 0 ? Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(ids.Last())) : null;
 
-            return new Connection<U>
+        return new Connection<U>
+        {
+            Edges = list.Select(x => new Edge<U> { Cursor = x.Cursor, Node = x }).ToList(),
+            TotalCount = list.Count,
+            PageInfo = new PageInfo
             {
-                Edges = list.Select(x => new Edge<U> { Cursor = x.Cursor, Node = x }).ToList(),
-                TotalCount = list.Count,
-                PageInfo = new PageInfo
-                {
-                    EndCursor = endCursor,
-                    HasNextPage = endCursor == null ? false : cursor != endCursor,
-                }
-            };
-        }
+                EndCursor = endCursor,
+                HasNextPage = endCursor == null ? false : cursor != endCursor,
+            }
+        };
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
index c0d3595b..3c32d1f0 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsData.cs
@@ -1,87 +1,86 @@
 using GraphQL.Client.Tests.Common.StarWars.Types;
 
-namespace GraphQL.Client.Tests.Common.StarWars
+namespace GraphQL.Client.Tests.Common.StarWars;
+
+public class StarWarsData
 {
-    public class StarWarsData
-    {
-        private readonly List<StarWarsCharacter> _characters = new List<StarWarsCharacter>();
+    private readonly List<StarWarsCharacter> _characters = new List<StarWarsCharacter>();
 
-        public StarWarsData()
+    public StarWarsData()
+    {
+        _characters.Add(new Human
         {
-            _characters.Add(new Human
-            {
-                Id = "1",
-                Name = "Luke",
-                Friends = new List<string> { "3", "4" },
-                AppearsIn = new[] { 4, 5, 6 },
-                HomePlanet = "Tatooine",
-                Cursor = "MQ=="
-            });
-            _characters.Add(new Human
-            {
-                Id = "2",
-                Name = "Vader",
-                AppearsIn = new[] { 4, 5, 6 },
-                HomePlanet = "Tatooine",
-                Cursor = "Mg=="
-            });
-
-            _characters.Add(new Droid
-            {
-                Id = "3",
-                Name = "R2-D2",
-                Friends = new List<string> { "1", "4" },
-                AppearsIn = new[] { 4, 5, 6 },
-                PrimaryFunction = "Astromech",
-                Cursor = "Mw=="
-            });
-            _characters.Add(new Droid
-            {
-                Id = "4",
-                Name = "C-3PO",
-                AppearsIn = new[] { 4, 5, 6 },
-                PrimaryFunction = "Protocol",
-                Cursor = "NA=="
-            });
-        }
-
-        public IEnumerable<StarWarsCharacter> GetFriends(StarWarsCharacter character)
+            Id = "1",
+            Name = "Luke",
+            Friends = new List<string> { "3", "4" },
+            AppearsIn = new[] { 4, 5, 6 },
+            HomePlanet = "Tatooine",
+            Cursor = "MQ=="
+        });
+        _characters.Add(new Human
         {
-            if (character == null)
-            {
-                return null;
-            }
+            Id = "2",
+            Name = "Vader",
+            AppearsIn = new[] { 4, 5, 6 },
+            HomePlanet = "Tatooine",
+            Cursor = "Mg=="
+        });
 
-            var friends = new List<StarWarsCharacter>();
-            var lookup = character.Friends;
-            if (lookup != null)
-            {
-                foreach (var c in _characters.Where(h => lookup.Contains(h.Id)))
-                    friends.Add(c);
-            }
-            return friends;
-        }
-
-        public StarWarsCharacter AddCharacter(StarWarsCharacter character)
+        _characters.Add(new Droid
         {
-            character.Id = _characters.Count.ToString();
-            _characters.Add(character);
-            return character;
-        }
-
-        public Task<Human> GetHumanByIdAsync(string id)
+            Id = "3",
+            Name = "R2-D2",
+            Friends = new List<string> { "1", "4" },
+            AppearsIn = new[] { 4, 5, 6 },
+            PrimaryFunction = "Astromech",
+            Cursor = "Mw=="
+        });
+        _characters.Add(new Droid
         {
-            return Task.FromResult(_characters.FirstOrDefault(h => h.Id == id && h is Human) as Human);
-        }
+            Id = "4",
+            Name = "C-3PO",
+            AppearsIn = new[] { 4, 5, 6 },
+            PrimaryFunction = "Protocol",
+            Cursor = "NA=="
+        });
+    }
 
-        public Task<Droid> GetDroidByIdAsync(string id)
+    public IEnumerable<StarWarsCharacter> GetFriends(StarWarsCharacter character)
+    {
+        if (character == null)
         {
-            return Task.FromResult(_characters.FirstOrDefault(h => h.Id == id && h is Droid) as Droid);
+            return null;
         }
 
-        public Task<List<StarWarsCharacter>> GetCharactersAsync(List<string> guids)
+        var friends = new List<StarWarsCharacter>();
+        var lookup = character.Friends;
+        if (lookup != null)
         {
-            return Task.FromResult(_characters.Where(c => guids.Contains(c.Id)).ToList());
+            foreach (var c in _characters.Where(h => lookup.Contains(h.Id)))
+                friends.Add(c);
         }
+        return friends;
+    }
+
+    public StarWarsCharacter AddCharacter(StarWarsCharacter character)
+    {
+        character.Id = _characters.Count.ToString();
+        _characters.Add(character);
+        return character;
+    }
+
+    public Task<Human> GetHumanByIdAsync(string id)
+    {
+        return Task.FromResult(_characters.FirstOrDefault(h => h.Id == id && h is Human) as Human);
+    }
+
+    public Task<Droid> GetDroidByIdAsync(string id)
+    {
+        return Task.FromResult(_characters.FirstOrDefault(h => h.Id == id && h is Droid) as Droid);
+    }
+
+    public Task<List<StarWarsCharacter>> GetCharactersAsync(List<string> guids)
+    {
+        return Task.FromResult(_characters.Where(c => guids.Contains(c.Id)).ToList());
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
index 130ee1a9..161b25dd 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
@@ -1,36 +1,35 @@
 using GraphQL.Client.Tests.Common.StarWars.Types;
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.StarWars
+namespace GraphQL.Client.Tests.Common.StarWars;
+
+/// <summary> Mutation graph type for StarWars schema. </summary>
+/// <example>
+/// This is an example JSON request for a mutation
+/// {
+///   "query": "mutation ($human:HumanInput!){ createHuman(human: $human) { id name } }",
+///   "variables": {
+///     "human": {
+///       "name": "Boba Fett"
+///     }
+///   }
+/// }
+/// </example>
+public class StarWarsMutation : ObjectGraphType<object>
 {
-    /// <summary> Mutation graph type for StarWars schema. </summary>
-    /// <example>
-    /// This is an example JSON request for a mutation
-    /// {
-    ///   "query": "mutation ($human:HumanInput!){ createHuman(human: $human) { id name } }",
-    ///   "variables": {
-    ///     "human": {
-    ///       "name": "Boba Fett"
-    ///     }
-    ///   }
-    /// }
-    /// </example>
-    public class StarWarsMutation : ObjectGraphType<object>
+    public StarWarsMutation(StarWarsData data)
     {
-        public StarWarsMutation(StarWarsData data)
-        {
-            Name = "Mutation";
+        Name = "Mutation";
 
-            Field<HumanType>(
-                "createHuman",
-                arguments: new QueryArguments(
-                    new QueryArgument<NonNullGraphType<HumanInputType>> { Name = "human" }
-                ),
-                resolve: context =>
-                {
-                    var human = context.GetArgument<Human>("human");
-                    return data.AddCharacter(human);
-                });
-        }
+        Field<HumanType>(
+            "createHuman",
+            arguments: new QueryArguments(
+                new QueryArgument<NonNullGraphType<HumanInputType>> { Name = "human" }
+            ),
+            resolve: context =>
+            {
+                var human = context.GetArgument<Human>("human");
+                return data.AddCharacter(human);
+            });
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
index 38b29e6f..a3fb05e9 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
@@ -1,32 +1,31 @@
 using GraphQL.Client.Tests.Common.StarWars.Types;
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.StarWars
+namespace GraphQL.Client.Tests.Common.StarWars;
+
+public class StarWarsQuery : ObjectGraphType<object>
 {
-    public class StarWarsQuery : ObjectGraphType<object>
+    public StarWarsQuery(StarWarsData data)
     {
-        public StarWarsQuery(StarWarsData data)
-        {
-            Name = "Query";
+        Name = "Query";
 
-            FieldAsync<CharacterInterface>("hero", resolve: async context => await data.GetDroidByIdAsync("3"));
-            FieldAsync<HumanType>(
-                "human",
-                arguments: new QueryArguments(
-                    new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the human" }
-                ),
-                resolve: async context => await data.GetHumanByIdAsync(context.GetArgument<string>("id"))
-            );
+        FieldAsync<CharacterInterface>("hero", resolve: async context => await data.GetDroidByIdAsync("3"));
+        FieldAsync<HumanType>(
+            "human",
+            arguments: new QueryArguments(
+                new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the human" }
+            ),
+            resolve: async context => await data.GetHumanByIdAsync(context.GetArgument<string>("id"))
+        );
 
-            Func<IResolveFieldContext, string, Task<Droid>> func = (context, id) => data.GetDroidByIdAsync(id);
+        Func<IResolveFieldContext, string, Task<Droid>> func = (context, id) => data.GetDroidByIdAsync(id);
 
-            FieldDelegate<DroidType>(
-                "droid",
-                arguments: new QueryArguments(
-                    new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the droid" }
-                ),
-                resolve: func
-            );
-        }
+        FieldDelegate<DroidType>(
+            "droid",
+            arguments: new QueryArguments(
+                new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the droid" }
+            ),
+            resolve: func
+        );
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
index 3756f471..e2220220 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsSchema.cs
@@ -1,17 +1,16 @@
 using GraphQL.Types;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace GraphQL.Client.Tests.Common.StarWars
+namespace GraphQL.Client.Tests.Common.StarWars;
+
+public class StarWarsSchema : Schema
 {
-    public class StarWarsSchema : Schema
+    public StarWarsSchema(IServiceProvider serviceProvider)
+        : base(serviceProvider)
     {
-        public StarWarsSchema(IServiceProvider serviceProvider)
-            : base(serviceProvider)
-        {
-            Query = serviceProvider.GetRequiredService<StarWarsQuery>();
-            Mutation = serviceProvider.GetRequiredService<StarWarsMutation>();
+        Query = serviceProvider.GetRequiredService<StarWarsQuery>();
+        Mutation = serviceProvider.GetRequiredService<StarWarsMutation>();
 
-            Description = "Example StarWars universe schema";
-        }
+        Description = "Example StarWars universe schema";
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs b/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
index 25376b87..4efd812e 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/TestData/StarWarsHumans.cs
@@ -1,18 +1,17 @@
 using System.Collections;
 
-namespace GraphQL.Client.Tests.Common.StarWars.TestData
+namespace GraphQL.Client.Tests.Common.StarWars.TestData;
+
+/// <summary>
+/// Test data object
+/// </summary>
+public class StarWarsHumans : IEnumerable<object[]>
 {
-    /// <summary>
-    /// Test data object
-    /// </summary>
-    public class StarWarsHumans : IEnumerable<object[]>
+    public IEnumerator<object[]> GetEnumerator()
     {
-        public IEnumerator<object[]> GetEnumerator()
-        {
-            yield return new object[] { 1, "Luke" };
-            yield return new object[] { 2, "Vader" };
-        }
-
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        yield return new object[] { 1, "Luke" };
+        yield return new object[] { 2, "Vader" };
     }
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
index e45db3d4..1e3809dc 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
@@ -1,20 +1,19 @@
 using GraphQL.Types;
 using GraphQL.Types.Relay;
 
-namespace GraphQL.Client.Tests.Common.StarWars.Types
+namespace GraphQL.Client.Tests.Common.StarWars.Types;
+
+public class CharacterInterface : InterfaceGraphType<StarWarsCharacter>
 {
-    public class CharacterInterface : InterfaceGraphType<StarWarsCharacter>
+    public CharacterInterface()
     {
-        public CharacterInterface()
-        {
-            Name = "Character";
+        Name = "Character";
 
-            Field<NonNullGraphType<StringGraphType>>("id", "The id of the character.", resolve: context => context.Source.Id);
-            Field<StringGraphType>("name", "The name of the character.", resolve: context => context.Source.Name);
+        Field<NonNullGraphType<StringGraphType>>("id", "The id of the character.", resolve: context => context.Source.Id);
+        Field<StringGraphType>("name", "The name of the character.", resolve: context => context.Source.Name);
 
-            Field<ListGraphType<CharacterInterface>>("friends");
-            Field<ConnectionType<CharacterInterface, EdgeType<CharacterInterface>>>("friendsConnection");
-            Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
-        }
+        Field<ListGraphType<CharacterInterface>>("friends");
+        Field<ConnectionType<CharacterInterface, EdgeType<CharacterInterface>>>("friendsConnection");
+        Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
index 8d8fc867..cc9e33c3 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
@@ -1,30 +1,29 @@
 using GraphQL.Client.Tests.Common.StarWars.Extensions;
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.StarWars.Types
+namespace GraphQL.Client.Tests.Common.StarWars.Types;
+
+public class DroidType : ObjectGraphType<Droid>
 {
-    public class DroidType : ObjectGraphType<Droid>
+    public DroidType(StarWarsData data)
     {
-        public DroidType(StarWarsData data)
-        {
-            Name = "Droid";
-            Description = "A mechanical creature in the Star Wars universe.";
+        Name = "Droid";
+        Description = "A mechanical creature in the Star Wars universe.";
 
-            Field<NonNullGraphType<StringGraphType>>("id", "The id of the droid.", resolve: context => context.Source.Id);
-            Field<StringGraphType>("name", "The name of the droid.", resolve: context => context.Source.Name);
+        Field<NonNullGraphType<StringGraphType>>("id", "The id of the droid.", resolve: context => context.Source.Id);
+        Field<StringGraphType>("name", "The name of the droid.", resolve: context => context.Source.Name);
 
-            Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
+        Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
 
-            Connection<CharacterInterface>()
-                .Name("friendsConnection")
-                .Description("A list of a character's friends.")
-                .Bidirectional()
-                .Resolve(context => context.GetPagedResults<Droid, StarWarsCharacter>(data, context.Source.Friends));
+        Connection<CharacterInterface>()
+            .Name("friendsConnection")
+            .Description("A list of a character's friends.")
+            .Bidirectional()
+            .Resolve(context => context.GetPagedResults<Droid, StarWarsCharacter>(data, context.Source.Friends));
 
-            Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
-            Field<StringGraphType>("primaryFunction", "The primary function of the droid.", resolve: context => context.Source.PrimaryFunction);
+        Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
+        Field<StringGraphType>("primaryFunction", "The primary function of the droid.", resolve: context => context.Source.PrimaryFunction);
 
-            Interface<CharacterInterface>();
-        }
+        Interface<CharacterInterface>();
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
index 4b9fb577..7fbc855f 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/EpisodeEnum.cs
@@ -1,23 +1,22 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.StarWars.Types
+namespace GraphQL.Client.Tests.Common.StarWars.Types;
+
+public class EpisodeEnum : EnumerationGraphType
 {
-    public class EpisodeEnum : EnumerationGraphType
+    public EpisodeEnum()
     {
-        public EpisodeEnum()
-        {
-            Name = "Episode";
-            Description = "One of the films in the Star Wars Trilogy.";
-            Add("NEWHOPE", 4, "Released in 1977.");
-            Add("EMPIRE", 5, "Released in 1980.");
-            Add("JEDI", 6, "Released in 1983.");
-        }
+        Name = "Episode";
+        Description = "One of the films in the Star Wars Trilogy.";
+        Add("NEWHOPE", 4, "Released in 1977.");
+        Add("EMPIRE", 5, "Released in 1980.");
+        Add("JEDI", 6, "Released in 1983.");
     }
+}
 
-    public enum Episodes
-    {
-        NEWHOPE = 4,
-        EMPIRE = 5,
-        JEDI = 6
-    }
+public enum Episodes
+{
+    NEWHOPE = 4,
+    EMPIRE = 5,
+    JEDI = 6
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs
index c44c381c..0402876e 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanInputType.cs
@@ -1,14 +1,13 @@
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.StarWars.Types
+namespace GraphQL.Client.Tests.Common.StarWars.Types;
+
+public class HumanInputType : InputObjectGraphType
 {
-    public class HumanInputType : InputObjectGraphType
+    public HumanInputType()
     {
-        public HumanInputType()
-        {
-            Name = "HumanInput";
-            Field<NonNullGraphType<StringGraphType>>("name");
-            Field<StringGraphType>("homePlanet");
-        }
+        Name = "HumanInput";
+        Field<NonNullGraphType<StringGraphType>>("name");
+        Field<StringGraphType>("homePlanet");
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
index 93da8165..552aabdd 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
@@ -1,30 +1,29 @@
 using GraphQL.Client.Tests.Common.StarWars.Extensions;
 using GraphQL.Types;
 
-namespace GraphQL.Client.Tests.Common.StarWars.Types
+namespace GraphQL.Client.Tests.Common.StarWars.Types;
+
+public class HumanType : ObjectGraphType<Human>
 {
-    public class HumanType : ObjectGraphType<Human>
+    public HumanType(StarWarsData data)
     {
-        public HumanType(StarWarsData data)
-        {
-            Name = "Human";
+        Name = "Human";
 
-            Field<NonNullGraphType<StringGraphType>>("id", "The id of the human.", resolve: context => context.Source.Id);
-            Field<StringGraphType>("name", "The name of the human.", resolve: context => context.Source.Name);
+        Field<NonNullGraphType<StringGraphType>>("id", "The id of the human.", resolve: context => context.Source.Id);
+        Field<StringGraphType>("name", "The name of the human.", resolve: context => context.Source.Name);
 
-            Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
+        Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
 
-            Connection<CharacterInterface>()
-                .Name("friendsConnection")
-                .Description("A list of a character's friends.")
-                .Bidirectional()
-                .Resolve(context => context.GetPagedResults<Human, StarWarsCharacter>(data, context.Source.Friends));
+        Connection<CharacterInterface>()
+            .Name("friendsConnection")
+            .Description("A list of a character's friends.")
+            .Bidirectional()
+            .Resolve(context => context.GetPagedResults<Human, StarWarsCharacter>(data, context.Source.Friends));
 
-            Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
+        Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
 
-            Field<StringGraphType>("homePlanet", "The home planet of the human.", resolve: context => context.Source.HomePlanet);
+        Field<StringGraphType>("homePlanet", "The home planet of the human.", resolve: context => context.Source.HomePlanet);
 
-            Interface<CharacterInterface>();
-        }
+        Interface<CharacterInterface>();
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
index 6c646e0b..fb2688f3 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/StarWarsCharacter.cs
@@ -1,21 +1,20 @@
-namespace GraphQL.Client.Tests.Common.StarWars.Types
+namespace GraphQL.Client.Tests.Common.StarWars.Types;
+
+public abstract class StarWarsCharacter
 {
-    public abstract class StarWarsCharacter
-    {
-        public string Id { get; set; }
-        public string Name { get; set; }
-        public List<string> Friends { get; set; }
-        public int[] AppearsIn { get; set; }
-        public string Cursor { get; set; }
-    }
+    public string Id { get; set; }
+    public string Name { get; set; }
+    public List<string> Friends { get; set; }
+    public int[] AppearsIn { get; set; }
+    public string Cursor { get; set; }
+}
 
-    public class Human : StarWarsCharacter
-    {
-        public string HomePlanet { get; set; }
-    }
+public class Human : StarWarsCharacter
+{
+    public string HomePlanet { get; set; }
+}
 
-    public class Droid : StarWarsCharacter
-    {
-        public string PrimaryFunction { get; set; }
-    }
+public class Droid : StarWarsCharacter
+{
+    public string PrimaryFunction { get; set; }
 }
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index 59dc0733..b0154c2a 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -5,59 +5,58 @@
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Helpers;
 
-namespace GraphQL.Integration.Tests.Helpers
+namespace GraphQL.Integration.Tests.Helpers;
+
+public abstract class IntegrationServerTestFixture
 {
-    public abstract class IntegrationServerTestFixture
+    public int Port { get; private set; }
+
+    public IWebHost Server { get; private set; }
+
+    public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
+
+    public IntegrationServerTestFixture()
     {
-        public int Port { get; private set; }
-
-        public IWebHost Server { get; private set; }
-
-        public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
-
-        public IntegrationServerTestFixture()
-        {
-            Port = NetworkHelpers.GetFreeTcpPortNumber();
-        }
-
-        public async Task CreateServer()
-        {
-            if (Server != null)
-                return;
-            Server = await WebHostHelpers.CreateServer(Port);
-        }
-
-        public async Task ShutdownServer()
-        {
-            if (Server == null)
-                return;
-
-            await Server.StopAsync();
-            Server.Dispose();
-            Server = null;
-        }
-
-        public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
-
-        public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
-
-        private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false)
-        {
-            if (Serializer == null)
-                throw new InvalidOperationException("JSON serializer not configured");
-            return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer);
-        }
+        Port = NetworkHelpers.GetFreeTcpPortNumber();
     }
 
-    public class NewtonsoftIntegrationServerTestFixture : IntegrationServerTestFixture
+    public async Task CreateServer()
     {
-        public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new NewtonsoftJsonSerializer();
+        if (Server != null)
+            return;
+        Server = await WebHostHelpers.CreateServer(Port);
+    }
+
+    public async Task ShutdownServer()
+    {
+        if (Server == null)
+            return;
+
+        await Server.StopAsync();
+        Server.Dispose();
+        Server = null;
     }
 
-    public class SystemTextJsonIntegrationServerTestFixture : IntegrationServerTestFixture
+    public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
+        => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
+
+    public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
+        => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
+
+    private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false)
     {
-        public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
+        if (Serializer == null)
+            throw new InvalidOperationException("JSON serializer not configured");
+        return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer);
     }
 }
+
+public class NewtonsoftIntegrationServerTestFixture : IntegrationServerTestFixture
+{
+    public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new NewtonsoftJsonSerializer();
+}
+
+public class SystemTextJsonIntegrationServerTestFixture : IntegrationServerTestFixture
+{
+    public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
+}
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index fb3ba46b..ac90c08b 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -5,62 +5,61 @@
 using GraphQL.Client.Tests.Common.Helpers;
 using IntegrationTestServer;
 
-namespace GraphQL.Integration.Tests.Helpers
+namespace GraphQL.Integration.Tests.Helpers;
+
+public static class WebHostHelpers
 {
-    public static class WebHostHelpers
+    public static async Task<IWebHost> CreateServer(int port)
     {
-        public static async Task<IWebHost> CreateServer(int port)
-        {
-            var configBuilder = new ConfigurationBuilder();
-            configBuilder.AddInMemoryCollection();
-            var config = configBuilder.Build();
-            config["server.urls"] = $"http://localhost:{port}";
-
-            var host = new WebHostBuilder()
-                .ConfigureLogging((ctx, logging) => logging.AddDebug())
-                .UseConfiguration(config)
-                .UseKestrel()
-                .UseStartup<Startup>()
-                .Build();
+        var configBuilder = new ConfigurationBuilder();
+        configBuilder.AddInMemoryCollection();
+        var config = configBuilder.Build();
+        config["server.urls"] = $"http://localhost:{port}";
 
-            var tcs = new TaskCompletionSource<bool>();
-            host.Services.GetService<IHostApplicationLifetime>().ApplicationStarted.Register(() => tcs.TrySetResult(true));
-            await host.StartAsync();
-            await tcs.Task;
-            return host;
-        }
+        var host = new WebHostBuilder()
+            .ConfigureLogging((ctx, logging) => logging.AddDebug())
+            .UseConfiguration(config)
+            .UseKestrel()
+            .UseStartup<Startup>()
+            .Build();
 
-        public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
-            => new GraphQLHttpClient(new GraphQLHttpClientOptions
-            {
-                EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
-                UseWebSocketForQueriesAndMutations = requestsViaWebsocket
-            },
-                serializer ?? new NewtonsoftJsonSerializer());
+        var tcs = new TaskCompletionSource<bool>();
+        host.Services.GetService<IHostApplicationLifetime>().ApplicationStarted.Register(() => tcs.TrySetResult(true));
+        await host.StartAsync();
+        await tcs.Task;
+        return host;
     }
 
-    public class TestServerSetup : IDisposable
-    {
-        public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer)
+    public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
+        => new GraphQLHttpClient(new GraphQLHttpClientOptions
         {
-            Serializer = serializer;
-            Port = NetworkHelpers.GetFreeTcpPortNumber();
-        }
+            EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
+            UseWebSocketForQueriesAndMutations = requestsViaWebsocket
+        },
+            serializer ?? new NewtonsoftJsonSerializer());
+}
 
-        public int Port { get; }
+public class TestServerSetup : IDisposable
+{
+    public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer)
+    {
+        Serializer = serializer;
+        Port = NetworkHelpers.GetFreeTcpPortNumber();
+    }
 
-        public IWebHost Server { get; set; }
+    public int Port { get; }
 
-        public IGraphQLWebsocketJsonSerializer Serializer { get; set; }
+    public IWebHost Server { get; set; }
 
-        public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
+    public IGraphQLWebsocketJsonSerializer Serializer { get; set; }
 
-        public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-            => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
+    public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
+        => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
 
-        private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) => WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
+    public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
+        => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
 
-        public void Dispose() => Server?.Dispose();
-    }
+    private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) => WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
+
+    public void Dispose() => Server?.Dispose();
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index e489046a..600ca463 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -8,99 +8,99 @@
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.QueryAndMutationTests
+namespace GraphQL.Integration.Tests.QueryAndMutationTests;
+
+public abstract class Base : IAsyncLifetime
 {
-    public abstract class Base : IAsyncLifetime
+    protected IntegrationServerTestFixture Fixture;
+    protected GraphQLHttpClient StarWarsClient;
+    protected GraphQLHttpClient ChatClient;
+
+    protected Base(IntegrationServerTestFixture fixture)
     {
-        protected IntegrationServerTestFixture Fixture;
-        protected GraphQLHttpClient StarWarsClient;
-        protected GraphQLHttpClient ChatClient;
+        Fixture = fixture;
+    }
 
-        protected Base(IntegrationServerTestFixture fixture)
-        {
-            Fixture = fixture;
-        }
+    public async Task InitializeAsync()
+    {
+        await Fixture.CreateServer();
+        StarWarsClient = Fixture.GetStarWarsClient();
+        ChatClient = Fixture.GetChatClient();
+    }
 
-        public async Task InitializeAsync()
-        {
-            await Fixture.CreateServer();
-            StarWarsClient = Fixture.GetStarWarsClient();
-            ChatClient = Fixture.GetChatClient();
-        }
+    public Task DisposeAsync()
+    {
+        ChatClient?.Dispose();
+        StarWarsClient?.Dispose();
+        return Task.CompletedTask;
+    }
 
-        public Task DisposeAsync()
-        {
-            ChatClient?.Dispose();
-            StarWarsClient?.Dispose();
-            return Task.CompletedTask;
-        }
-
-        [Theory]
-        [ClassData(typeof(StarWarsHumans))]
-        public async void QueryTheory(int id, string name)
-        {
-            var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
-            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+    [Theory]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void QueryTheory(int id, string name)
+    {
+        var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
-            Assert.Null(response.Errors);
-            Assert.Equal(name, response.Data.Human.Name);
-        }
+        Assert.Null(response.Errors);
+        Assert.Equal(name, response.Data.Human.Name);
+    }
 
-        [Theory]
-        [ClassData(typeof(StarWarsHumans))]
-        public async void QueryAsHttpResponseTheory(int id, string name)
-        {
-            var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
-            var responseType = new { Human = new { Name = string.Empty } };
-            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => responseType);
+    [Theory]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void QueryAsHttpResponseTheory(int id, string name)
+    {
+        var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+        var responseType = new { Human = new { Name = string.Empty } };
+        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => responseType);
 
-            FluentActions.Invoking(() => response.AsGraphQLHttpResponse()).Should()
-                .NotThrow("because the returned object is a GraphQLHttpResponse");
+        FluentActions.Invoking(() => response.AsGraphQLHttpResponse()).Should()
+            .NotThrow("because the returned object is a GraphQLHttpResponse");
 
-            var httpResponse = response.AsGraphQLHttpResponse();
+        var httpResponse = response.AsGraphQLHttpResponse();
 
-            httpResponse.Errors.Should().BeNull();
-            httpResponse.Data.Human.Name.Should().Be(name);
+        httpResponse.Errors.Should().BeNull();
+        httpResponse.Data.Human.Name.Should().Be(name);
 
-            httpResponse.StatusCode.Should().Be(HttpStatusCode.OK);
-            httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));
-        }
+        httpResponse.StatusCode.Should().Be(HttpStatusCode.OK);
+        httpResponse.ResponseHeaders.Date.Should().BeCloseTo(DateTimeOffset.Now, TimeSpan.FromMinutes(1));
+    }
 
-        [Theory(Skip = "System.Json.Net deserializes 'dynamic' as JsonElement.")]
-        [ClassData(typeof(StarWarsHumans))]
-        public async void QueryWithDynamicReturnTypeTheory(int id, string name)
-        {
-            var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
+    [Theory(Skip = "System.Json.Net deserializes 'dynamic' as JsonElement.")]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void QueryWithDynamicReturnTypeTheory(int id, string name)
+    {
+        var graphQLRequest = new GraphQLRequest($"{{ human(id: \"{id}\") {{ name }} }}");
 
-            var response = await StarWarsClient.SendQueryAsync<dynamic>(graphQLRequest);
+        var response = await StarWarsClient.SendQueryAsync<dynamic>(graphQLRequest);
 
-            Assert.Null(response.Errors);
-            Assert.Equal(name, response.Data.human.name.ToString());
-        }
+        Assert.Null(response.Errors);
+        Assert.Equal(name, response.Data.human.name.ToString());
+    }
 
-        [Theory]
-        [ClassData(typeof(StarWarsHumans))]
-        public async void QueryWitVarsTheory(int id, string name)
-        {
-            var graphQLRequest = new GraphQLRequest(@"
+    [Theory]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void QueryWitVarsTheory(int id, string name)
+    {
+        var graphQLRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
 					}
 				}",
-                new { id = id.ToString() });
+            new { id = id.ToString() });
 
-            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
-            Assert.Null(response.Errors);
-            Assert.Equal(name, response.Data.Human.Name);
-        }
+        Assert.Null(response.Errors);
+        Assert.Equal(name, response.Data.Human.Name);
+    }
 
-        [Theory]
-        [ClassData(typeof(StarWarsHumans))]
-        public async void QueryWitVarsAndOperationNameTheory(int id, string name)
-        {
-            var graphQLRequest = new GraphQLRequest(@"
+    [Theory]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void QueryWitVarsAndOperationNameTheory(int id, string name)
+    {
+        var graphQLRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
@@ -112,19 +112,19 @@ query Droid($id: String!) {
 				    name
 				  }
 				}",
-                new { id = id.ToString() },
-                "Human");
+            new { id = id.ToString() },
+            "Human");
 
-            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 
-            Assert.Null(response.Errors);
-            Assert.Equal(name, response.Data.Human.Name);
-        }
+        Assert.Null(response.Errors);
+        Assert.Equal(name, response.Data.Human.Name);
+    }
 
-        [Fact]
-        public async void SendMutationFact()
-        {
-            var mutationRequest = new GraphQLRequest(@"
+    [Fact]
+    public async void SendMutationFact()
+    {
+        var mutationRequest = new GraphQLRequest(@"
 				mutation CreateHuman($human: HumanInput!) {
 				  createHuman(human: $human) {
 				    id
@@ -132,90 +132,89 @@ mutation CreateHuman($human: HumanInput!) {
 				    homePlanet
 				  }
 				}",
-                new { human = new { name = "Han Solo", homePlanet = "Corellia" } });
+            new { human = new { name = "Han Solo", homePlanet = "Corellia" } });
 
-            var queryRequest = new GraphQLRequest(@"
+        var queryRequest = new GraphQLRequest(@"
 				query Human($id: String!){
 					human(id: $id) {
 						name
 					}
 				}");
 
-            var mutationResponse = await StarWarsClient.SendMutationAsync(mutationRequest, () => new
-            {
-                createHuman = new
-                {
-                    Id = "",
-                    Name = "",
-                    HomePlanet = ""
-                }
-            });
-
-            Assert.Null(mutationResponse.Errors);
-            Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
-            Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
-
-            queryRequest.Variables = new { id = mutationResponse.Data.createHuman.Id };
-            var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } });
-
-            Assert.Null(queryResponse.Errors);
-            Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
-        }
-
-        [Fact]
-        public async void PreprocessHttpRequestMessageIsCalled()
+        var mutationResponse = await StarWarsClient.SendMutationAsync(mutationRequest, () => new
         {
-            var callbackTester = new CallbackMonitor<HttpRequestMessage>();
-            var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
+            createHuman = new
             {
+                Id = "",
+                Name = "",
+                HomePlanet = ""
+            }
+        });
+
+        Assert.Null(mutationResponse.Errors);
+        Assert.Equal("Han Solo", mutationResponse.Data.createHuman.Name);
+        Assert.Equal("Corellia", mutationResponse.Data.createHuman.HomePlanet);
+
+        queryRequest.Variables = new { id = mutationResponse.Data.createHuman.Id };
+        var queryResponse = await StarWarsClient.SendQueryAsync(queryRequest, () => new { Human = new { Name = string.Empty } });
+
+        Assert.Null(queryResponse.Errors);
+        Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
+    }
+
+    [Fact]
+    public async void PreprocessHttpRequestMessageIsCalled()
+    {
+        var callbackTester = new CallbackMonitor<HttpRequestMessage>();
+        var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
+        {
 #pragma warning disable CS0618 // Type or member is obsolete
-                PreprocessHttpRequestMessage = callbackTester.Invoke
+            PreprocessHttpRequestMessage = callbackTester.Invoke
 #pragma warning restore CS0618 // Type or member is obsolete
-            };
+        };
 
-            var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
-            var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
-            callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
-            Assert.Null(response.Errors);
-            Assert.Equal("Luke", response.Data.Human.Name);
-        }
+        var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
+        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+        callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
+        Assert.Null(response.Errors);
+        Assert.Equal("Luke", response.Data.Human.Name);
+    }
 
-        [Fact]
-        public async Task PostRequestCanBeCancelled()
-        {
-            var graphQLRequest = new GraphQLRequest(@"
+    [Fact]
+    public async Task PostRequestCanBeCancelled()
+    {
+        var graphQLRequest = new GraphQLRequest(@"
 				query Long {
 					longRunning
 				}");
 
-            var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
-            var cts = new CancellationTokenSource();
-
-            var request =
-                ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
-
-            // Test regular request
-            // start request
-            request.Start();
-            // wait until the query has reached the server
-            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-            // unblock the query
-            chatQuery.LongRunningQueryBlocker.Set();
-            // check execution time
-            request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
-
-            // reset stuff
-            chatQuery.LongRunningQueryBlocker.Reset();
-            request.Clear();
-
-            // cancellation test
-            request.Start();
-            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-            cts.Cancel();
-            await request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled");
-
-            // let the server finish its query
-            chatQuery.LongRunningQueryBlocker.Set();
-        }
+        var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
+        var cts = new CancellationTokenSource();
+
+        var request =
+            ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
+
+        // Test regular request
+        // start request
+        request.Start();
+        // wait until the query has reached the server
+        chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+        // unblock the query
+        chatQuery.LongRunningQueryBlocker.Set();
+        // check execution time
+        request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+
+        // reset stuff
+        chatQuery.LongRunningQueryBlocker.Reset();
+        request.Clear();
+
+        // cancellation test
+        request.Start();
+        chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+        cts.Cancel();
+        await request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled");
+
+        // let the server finish its query
+        chatQuery.LongRunningQueryBlocker.Set();
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
index 7ffcdc11..768970e4 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
@@ -1,12 +1,11 @@
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.QueryAndMutationTests
+namespace GraphQL.Integration.Tests.QueryAndMutationTests;
+
+public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
 {
-    public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
+    public Newtonsoft(NewtonsoftIntegrationServerTestFixture fixture) : base(fixture)
     {
-        public Newtonsoft(NewtonsoftIntegrationServerTestFixture fixture) : base(fixture)
-        {
-        }
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
index e129cfed..9985692c 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
@@ -1,12 +1,11 @@
 using GraphQL.Integration.Tests.Helpers;
 using Xunit;
 
-namespace GraphQL.Integration.Tests.QueryAndMutationTests
+namespace GraphQL.Integration.Tests.QueryAndMutationTests;
+
+public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
 {
-    public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
+    public SystemTextJson(SystemTextJsonIntegrationServerTestFixture fixture) : base(fixture)
     {
-        public SystemTextJson(SystemTextJsonIntegrationServerTestFixture fixture) : base(fixture)
-        {
-        }
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
index 4daba07c..d218b5d8 100644
--- a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
+++ b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
@@ -2,45 +2,44 @@
 using GraphQL.Client.Http;
 using Xunit;
 
-namespace GraphQL.Integration.Tests
+namespace GraphQL.Integration.Tests;
+
+public class UriExtensionTests
 {
-    public class UriExtensionTests
+    [Theory]
+    [InlineData("http://thats-not-a-websocket-url.net", false)]
+    [InlineData("https://thats-not-a-websocket-url.net", false)]
+    [InlineData("ftp://thats-not-a-websocket-url.net", false)]
+    [InlineData("ws://that-is-a-websocket-url.net", true)]
+    [InlineData("wss://that-is-a-websocket-url.net", true)]
+    [InlineData("WS://that-is-a-websocket-url.net", true)]
+    [InlineData("WSS://that-is-a-websocket-url.net", true)]
+    public void HasWebSocketSchemaTest(string url, bool result)
     {
-        [Theory]
-        [InlineData("http://thats-not-a-websocket-url.net", false)]
-        [InlineData("https://thats-not-a-websocket-url.net", false)]
-        [InlineData("ftp://thats-not-a-websocket-url.net", false)]
-        [InlineData("ws://that-is-a-websocket-url.net", true)]
-        [InlineData("wss://that-is-a-websocket-url.net", true)]
-        [InlineData("WS://that-is-a-websocket-url.net", true)]
-        [InlineData("WSS://that-is-a-websocket-url.net", true)]
-        public void HasWebSocketSchemaTest(string url, bool result)
+        new Uri(url).HasWebSocketScheme().Should().Be(result);
+    }
+
+    [Theory]
+    [InlineData("http://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
+    [InlineData("https://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
+    [InlineData("HTTP://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
+    [InlineData("HTTPS://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
+    [InlineData("ws://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
+    [InlineData("wss://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
+    [InlineData("https://this-url-can-be-converted.net/and/all/elements/?are#preserved", true, "wss://this-url-can-be-converted.net/and/all/elements/?are#preserved")]
+    [InlineData("ftp://this-url-cannot-be-converted.net", false, null)]
+    // AppSync example
+    [InlineData("wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=", true, "wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=")]
+    public void GetWebSocketUriTest(string input, bool canConvert, string result)
+    {
+        var inputUri = new Uri(input);
+        if (canConvert)
         {
-            new Uri(url).HasWebSocketScheme().Should().Be(result);
+            inputUri.GetWebSocketUri().Should().BeEquivalentTo(new Uri(result));
         }
-
-        [Theory]
-        [InlineData("http://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
-        [InlineData("https://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
-        [InlineData("HTTP://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
-        [InlineData("HTTPS://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
-        [InlineData("ws://this-url-can-be-converted.net", true, "ws://this-url-can-be-converted.net")]
-        [InlineData("wss://this-url-can-be-converted.net", true, "wss://this-url-can-be-converted.net")]
-        [InlineData("https://this-url-can-be-converted.net/and/all/elements/?are#preserved", true, "wss://this-url-can-be-converted.net/and/all/elements/?are#preserved")]
-        [InlineData("ftp://this-url-cannot-be-converted.net", false, null)]
-        // AppSync example
-        [InlineData("wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=", true, "wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=")]
-        public void GetWebSocketUriTest(string input, bool canConvert, string result)
+        else
         {
-            var inputUri = new Uri(input);
-            if (canConvert)
-            {
-                inputUri.GetWebSocketUri().Should().BeEquivalentTo(new Uri(result));
-            }
-            else
-            {
-                inputUri.Invoking(uri => uri.GetWebSocketUri()).Should().Throw<NotSupportedException>();
-            }
+            inputUri.Invoking(uri => uri.GetWebSocketUri()).Should().Throw<NotSupportedException>();
         }
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index a63ed980..35938f34 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -15,471 +15,470 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GraphQL.Integration.Tests.WebsocketTests
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public abstract class Base : IAsyncLifetime
 {
-    public abstract class Base : IAsyncLifetime
+    protected readonly ITestOutputHelper Output;
+    protected readonly IntegrationServerTestFixture Fixture;
+    protected GraphQLHttpClient ChatClient;
+
+    protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture)
     {
-        protected readonly ITestOutputHelper Output;
-        protected readonly IntegrationServerTestFixture Fixture;
-        protected GraphQLHttpClient ChatClient;
+        Output = output;
+        Fixture = fixture;
+    }
 
-        protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture)
-        {
-            Output = output;
-            Fixture = fixture;
-        }
+    protected static ReceivedMessage InitialMessage = new ReceivedMessage
+    {
+        Content = "initial message",
+        SentAt = DateTime.Now,
+        FromId = "1"
+    };
 
-        protected static ReceivedMessage InitialMessage = new ReceivedMessage
-        {
-            Content = "initial message",
-            SentAt = DateTime.Now,
-            FromId = "1"
-        };
+    public async Task InitializeAsync()
+    {
+        await Fixture.CreateServer();
+        // make sure the buffer always contains the same message
+        Fixture.Server.Services.GetService<Chat>().AddMessage(InitialMessage);
 
-        public async Task InitializeAsync()
+        if (ChatClient == null)
         {
-            await Fixture.CreateServer();
-            // make sure the buffer always contains the same message
-            Fixture.Server.Services.GetService<Chat>().AddMessage(InitialMessage);
-
-            if (ChatClient == null)
-            {
-                // then create the chat client
-                ChatClient = Fixture.GetChatClient(true);
-            }
+            // then create the chat client
+            ChatClient = Fixture.GetChatClient(true);
         }
+    }
 
-        public Task DisposeAsync()
-        {
-            ChatClient?.Dispose();
-            return Task.CompletedTask;
-        }
+    public Task DisposeAsync()
+    {
+        ChatClient?.Dispose();
+        return Task.CompletedTask;
+    }
 
-        [Fact]
-        public async void CanSendRequestViaWebsocket()
-        {
-            await ChatClient.InitializeWebsocketConnection();
-            const string message = "some random testing message";
-            var response = await ChatClient.AddMessageAsync(message);
-            response.Errors.Should().BeNullOrEmpty();
-            response.Data.AddMessage.Content.Should().Be(message);
-        }
+    [Fact]
+    public async void CanSendRequestViaWebsocket()
+    {
+        await ChatClient.InitializeWebsocketConnection();
+        const string message = "some random testing message";
+        var response = await ChatClient.AddMessageAsync(message);
+        response.Errors.Should().BeNullOrEmpty();
+        response.Data.AddMessage.Content.Should().Be(message);
+    }
 
-        [Fact]
-        public async void CanUseWebSocketScheme()
-        {
-            ChatClient.Options.EndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
-            await ChatClient.InitializeWebsocketConnection();
-            const string message = "some random testing message";
-            var response = await ChatClient.AddMessageAsync(message);
-            response.Errors.Should().BeNullOrEmpty();
-            response.Data.AddMessage.Content.Should().Be(message);
-        }
-        
-        [Fact]
-        public async void CanUseDedicatedWebSocketEndpoint()
-        {
-            ChatClient.Options.WebSocketEndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
-            ChatClient.Options.EndPoint = new Uri("http://bad-endpoint.test");
-            ChatClient.Options.UseWebSocketForQueriesAndMutations = true;
-            await ChatClient.InitializeWebsocketConnection();
-            const string message = "some random testing message";
-            var response = await ChatClient.AddMessageAsync(message);
-            response.Errors.Should().BeNullOrEmpty();
-            response.Data.AddMessage.Content.Should().Be(message);
-        }
-        
-        [Fact]
-        public async void CanUseDedicatedWebSocketEndpointWithoutHttpEndpoint()
-        {
-            ChatClient.Options.WebSocketEndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
-            ChatClient.Options.EndPoint = null;
-            ChatClient.Options.UseWebSocketForQueriesAndMutations = false;
-            await ChatClient.InitializeWebsocketConnection();
-            const string message = "some random testing message";
-            var response = await ChatClient.AddMessageAsync(message);
-            response.Data.AddMessage.Content.Should().Be(message);
-        }
+    [Fact]
+    public async void CanUseWebSocketScheme()
+    {
+        ChatClient.Options.EndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
+        await ChatClient.InitializeWebsocketConnection();
+        const string message = "some random testing message";
+        var response = await ChatClient.AddMessageAsync(message);
+        response.Errors.Should().BeNullOrEmpty();
+        response.Data.AddMessage.Content.Should().Be(message);
+    }
+    
+    [Fact]
+    public async void CanUseDedicatedWebSocketEndpoint()
+    {
+        ChatClient.Options.WebSocketEndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
+        ChatClient.Options.EndPoint = new Uri("http://bad-endpoint.test");
+        ChatClient.Options.UseWebSocketForQueriesAndMutations = true;
+        await ChatClient.InitializeWebsocketConnection();
+        const string message = "some random testing message";
+        var response = await ChatClient.AddMessageAsync(message);
+        response.Errors.Should().BeNullOrEmpty();
+        response.Data.AddMessage.Content.Should().Be(message);
+    }
+    
+    [Fact]
+    public async void CanUseDedicatedWebSocketEndpointWithoutHttpEndpoint()
+    {
+        ChatClient.Options.WebSocketEndPoint = ChatClient.Options.EndPoint.GetWebSocketUri();
+        ChatClient.Options.EndPoint = null;
+        ChatClient.Options.UseWebSocketForQueriesAndMutations = false;
+        await ChatClient.InitializeWebsocketConnection();
+        const string message = "some random testing message";
+        var response = await ChatClient.AddMessageAsync(message);
+        response.Data.AddMessage.Content.Should().Be(message);
+    }
 
-        [Fact]
-        public async void WebsocketRequestCanBeCancelled()
-        {
-            var graphQLRequest = new GraphQLRequest(@"
+    [Fact]
+    public async void WebsocketRequestCanBeCancelled()
+    {
+        var graphQLRequest = new GraphQLRequest(@"
 				query Long {
 					longRunning
 				}");
 
-            var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
-            var cts = new CancellationTokenSource();
-
-            await ChatClient.InitializeWebsocketConnection();
-            var request =
-                ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
-
-            // Test regular request
-            // start request
-            request.Start();
-            // wait until the query has reached the server
-            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-            // unblock the query
-            chatQuery.LongRunningQueryBlocker.Set();
-            // check execution time
-            request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
-
-            // reset stuff
-            chatQuery.LongRunningQueryBlocker.Reset();
-            request.Clear();
-
-            // cancellation test
-            request.Start();
-            chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
-            cts.Cancel();
-            await request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled");
-
-            // let the server finish its query
-            chatQuery.LongRunningQueryBlocker.Set();
-        }
+        var chatQuery = Fixture.Server.Services.GetService<ChatQuery>();
+        var cts = new CancellationTokenSource();
+
+        await ChatClient.InitializeWebsocketConnection();
+        var request =
+            ConcurrentTaskWrapper.New(() => ChatClient.SendQueryAsync(graphQLRequest, () => new { longRunning = string.Empty }, cts.Token));
+
+        // Test regular request
+        // start request
+        request.Start();
+        // wait until the query has reached the server
+        chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+        // unblock the query
+        chatQuery.LongRunningQueryBlocker.Set();
+        // check execution time
+        request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+
+        // reset stuff
+        chatQuery.LongRunningQueryBlocker.Reset();
+        request.Clear();
+
+        // cancellation test
+        request.Start();
+        chatQuery.WaitingOnQueryBlocker.Wait(1000).Should().BeTrue("because the request should have reached the server by then");
+        cts.Cancel();
+        await request.Invoking().Should().ThrowAsync<TaskCanceledException>("because the request was cancelled");
+
+        // let the server finish its query
+        chatQuery.LongRunningQueryBlocker.Set();
+    }
 
-        [Fact]
-        public async void CanHandleRequestErrorViaWebsocket()
-        {
-            await ChatClient.InitializeWebsocketConnection();
-            var response = await ChatClient.SendQueryAsync<object>("this query is formatted quite badly");
-            response.Errors.Should().ContainSingle("because the query is invalid");
-        }
+    [Fact]
+    public async void CanHandleRequestErrorViaWebsocket()
+    {
+        await ChatClient.InitializeWebsocketConnection();
+        var response = await ChatClient.SendQueryAsync<object>("this query is formatted quite badly");
+        response.Errors.Should().ContainSingle("because the query is invalid");
+    }
 
-        private const string SUBSCRIPTION_QUERY = @"
+    private const string SUBSCRIPTION_QUERY = @"
 			subscription {
 			  messageAdded{
 			    content
 			  }
 			}";
 
-        private readonly GraphQLRequest _subscriptionRequest = new GraphQLRequest(SUBSCRIPTION_QUERY);
+    private readonly GraphQLRequest _subscriptionRequest = new GraphQLRequest(SUBSCRIPTION_QUERY);
 
 
-        [Fact]
-        public async void CanCreateObservableSubscription()
-        {
-            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-            await ChatClient.InitializeWebsocketConnection();
-            callbackMonitor.Should().HaveBeenInvokedWithPayload();
+    [Fact]
+    public async void CanCreateObservableSubscription()
+    {
+        var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+        await ChatClient.InitializeWebsocketConnection();
+        callbackMonitor.Should().HaveBeenInvokedWithPayload();
+
+        Debug.WriteLine("creating subscription stream");
+        var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
+
+        Debug.WriteLine("subscribing...");
+        using var observer = observable.Observe();
+        await observer.Should().PushAsync(1);
+        observer.RecordedMessages.Last().Errors.Should().BeNullOrEmpty();
+        observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
+        const string message1 = "Hello World";
+        var response = await ChatClient.AddMessageAsync(message1);
+        response.Errors.Should().BeNullOrEmpty();
+        response.Data.AddMessage.Content.Should().Be(message1);
+        await observer.Should().PushAsync(2);
+        observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
+
+        const string message2 = "lorem ipsum dolor si amet";
+        response = await ChatClient.AddMessageAsync(message2);
+        response.Data.AddMessage.Content.Should().Be(message2);
+        await observer.Should().PushAsync(3);
+        observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
+
+        // disposing the client should throw a TaskCanceledException on the subscription
+        ChatClient.Dispose();
+        await observer.Should().CompleteAsync();
+    }
 
-            Debug.WriteLine("creating subscription stream");
-            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
+    public class MessageAddedSubscriptionResult
+    {
+        public MessageAddedContent MessageAdded { get; set; }
 
-            Debug.WriteLine("subscribing...");
-            using var observer = observable.Observe();
-            await observer.Should().PushAsync(1);
-            observer.RecordedMessages.Last().Errors.Should().BeNullOrEmpty();
-            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+        public class MessageAddedContent
+        {
+            public string Content { get; set; }
+        }
+    }
 
-            const string message1 = "Hello World";
-            var response = await ChatClient.AddMessageAsync(message1);
-            response.Errors.Should().BeNullOrEmpty();
-            response.Data.AddMessage.Content.Should().Be(message1);
-            await observer.Should().PushAsync(2);
-            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
+    [Fact]
+    public async void CanReconnectWithSameObservable()
+    {
+        var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+
+        Debug.WriteLine("creating subscription stream");
+        var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
+
+        Debug.WriteLine("subscribing...");
+        var observer = observable.Observe();
+        callbackMonitor.Should().HaveBeenInvokedWithPayload();
+        await ChatClient.InitializeWebsocketConnection();
+        Debug.WriteLine("websocket connection initialized");
+        await observer.Should().PushAsync(1);
+        observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+
+        const string message1 = "Hello World";
+        Debug.WriteLine($"adding message {message1}");
+        var response = await ChatClient.AddMessageAsync(message1);
+        response.Data.AddMessage.Content.Should().Be(message1);
+        await observer.Should().PushAsync(2);
+        observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
+
+        const string message2 = "How are you?";
+        response = await ChatClient.AddMessageAsync(message2);
+        response.Data.AddMessage.Content.Should().Be(message2);
+        await observer.Should().PushAsync(3);
+        observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
+
+        Debug.WriteLine("disposing subscription...");
+        observer.Dispose(); // does not close the websocket connection
+
+        Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
+        var observer2 = observable.Observe();
+        Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
+        await observer2.Should().PushAsync(1);
+        observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
+
+        const string message3 = "lorem ipsum dolor si amet";
+        response = await ChatClient.AddMessageAsync(message3);
+        response.Data.AddMessage.Content.Should().Be(message3);
+        await observer2.Should().PushAsync(2);
+        observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message3);
+
+        // disposing the client should complete the subscription
+        ChatClient.Dispose();
+        await observer2.Should().CompleteAsync();
+        observer2.Dispose();
+    }
 
-            const string message2 = "lorem ipsum dolor si amet";
-            response = await ChatClient.AddMessageAsync(message2);
-            response.Data.AddMessage.Content.Should().Be(message2);
-            await observer.Should().PushAsync(3);
-            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
+    private const string SUBSCRIPTION_QUERY2 = @"
+			subscription {
+			  userJoined{
+				displayName
+				id
+			  }
+			}";
 
-            // disposing the client should throw a TaskCanceledException on the subscription
-            ChatClient.Dispose();
-            await observer.Should().CompleteAsync();
-        }
+    public class UserJoinedSubscriptionResult
+    {
+        public UserJoinedContent UserJoined { get; set; }
 
-        public class MessageAddedSubscriptionResult
+        public class UserJoinedContent
         {
-            public MessageAddedContent MessageAdded { get; set; }
+            public string DisplayName { get; set; }
 
-            public class MessageAddedContent
-            {
-                public string Content { get; set; }
-            }
+            public string Id { get; set; }
         }
 
-        [Fact]
-        public async void CanReconnectWithSameObservable()
-        {
-            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+    }
 
-            Debug.WriteLine("creating subscription stream");
-            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest);
+    private readonly GraphQLRequest _subscriptionRequest2 = new GraphQLRequest(SUBSCRIPTION_QUERY2);
 
-            Debug.WriteLine("subscribing...");
-            var observer = observable.Observe();
-            callbackMonitor.Should().HaveBeenInvokedWithPayload();
-            await ChatClient.InitializeWebsocketConnection();
-            Debug.WriteLine("websocket connection initialized");
-            await observer.Should().PushAsync(1);
-            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+    [Fact]
+    public async void CanConnectTwoSubscriptionsSimultaneously()
+    {
+        var port = NetworkHelpers.GetFreeTcpPortNumber();
+        var callbackTester = new CallbackMonitor<Exception>();
+        var callbackTester2 = new CallbackMonitor<Exception>();
 
-            const string message1 = "Hello World";
-            Debug.WriteLine($"adding message {message1}");
-            var response = await ChatClient.AddMessageAsync(message1);
-            response.Data.AddMessage.Content.Should().Be(message1);
-            await observer.Should().PushAsync(2);
-            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
+        var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+        await ChatClient.InitializeWebsocketConnection();
+        callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
-            const string message2 = "How are you?";
-            response = await ChatClient.AddMessageAsync(message2);
-            response.Data.AddMessage.Content.Should().Be(message2);
-            await observer.Should().PushAsync(3);
-            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
+        Debug.WriteLine("creating subscription stream");
+        var observable1 = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, callbackTester.Invoke);
+        var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(_subscriptionRequest2, callbackTester2.Invoke);
 
-            Debug.WriteLine("disposing subscription...");
-            observer.Dispose(); // does not close the websocket connection
+        Debug.WriteLine("subscribing...");
+        var blocker = new ManualResetEventSlim(false);
+        FluentTestObserver<GraphQLResponse<MessageAddedSubscriptionResult>> messagesMonitor = null;
+        FluentTestObserver<GraphQLResponse<UserJoinedSubscriptionResult>> joinedMonitor = null;
 
-            Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
-            var observer2 = observable.Observe();
-            Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
-            await observer2.Should().PushAsync(1);
-            observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
+        var tasks = new List<Task>
+        {
+            Task.Run(() =>
+            {
+                blocker.Wait();
+                messagesMonitor = observable1.Observe();
+            }),
+            Task.Run(() =>
+            {
+                blocker.Wait();
+                joinedMonitor = observable2.Observe();
+            })
+        };
 
-            const string message3 = "lorem ipsum dolor si amet";
-            response = await ChatClient.AddMessageAsync(message3);
-            response.Data.AddMessage.Content.Should().Be(message3);
-            await observer2.Should().PushAsync(2);
-            observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message3);
+        blocker.Set();
+        await Task.WhenAll(tasks);
 
-            // disposing the client should complete the subscription
-            ChatClient.Dispose();
-            await observer2.Should().CompleteAsync();
-            observer2.Dispose();
-        }
+        await messagesMonitor.Should().PushAsync(1);
+        messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
-        private const string SUBSCRIPTION_QUERY2 = @"
-			subscription {
-			  userJoined{
-				displayName
-				id
-			  }
-			}";
+        const string message1 = "Hello World";
+        var response = await ChatClient.AddMessageAsync(message1);
+        response.Data.AddMessage.Content.Should().Be(message1);
+        await messagesMonitor.Should().PushAsync(2);
+        messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
+
+        joinedMonitor.Should().NotPush();
+        messagesMonitor.Clear();
+        joinedMonitor.Clear();
 
-        public class UserJoinedSubscriptionResult
+        var joinResponse = await ChatClient.JoinDeveloperUser();
+        joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+
+        var payload = await joinedMonitor.Should().PushAsync().GetLastMessageAsync();
+        using (new AssertionScope())
         {
-            public UserJoinedContent UserJoined { get; set; }
+            payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
+            payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+        }
 
-            public class UserJoinedContent
-            {
-                public string DisplayName { get; set; }
+        messagesMonitor.Should().NotPush();
+        messagesMonitor.Clear();
+        joinedMonitor.Clear();
 
-                public string Id { get; set; }
-            }
+        Debug.WriteLine("disposing subscription...");
+        joinedMonitor.Dispose();
 
-        }
+        const string message3 = "lorem ipsum dolor si amet";
+        response = await ChatClient.AddMessageAsync(message3);
+        response.Data.AddMessage.Content.Should().Be(message3);
+        var msg = await messagesMonitor.Should().PushAsync().GetLastMessageAsync();
+        msg.Data.MessageAdded.Content.Should().Be(message3);
 
-        private readonly GraphQLRequest _subscriptionRequest2 = new GraphQLRequest(SUBSCRIPTION_QUERY2);
+        // disposing the client should complete the subscription
+        ChatClient.Dispose();
+        await messagesMonitor.Should().CompleteAsync();
+    }
 
-        [Fact]
-        public async void CanConnectTwoSubscriptionsSimultaneously()
+
+    [Fact]
+    public async void CanHandleConnectionTimeout()
+    {
+        var errorMonitor = new CallbackMonitor<Exception>();
+        var reconnectBlocker = new ManualResetEventSlim(false);
+
+        var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+        // configure back-off strategy to allow it to be controlled from within the unit test
+        ChatClient.Options.BackOffStrategy = i =>
         {
-            var port = NetworkHelpers.GetFreeTcpPortNumber();
-            var callbackTester = new CallbackMonitor<Exception>();
-            var callbackTester2 = new CallbackMonitor<Exception>();
+            Debug.WriteLine("back-off strategy: waiting on reconnect blocker");
+            reconnectBlocker.Wait();
+            Debug.WriteLine("back-off strategy: reconnecting...");
+            return TimeSpan.Zero;
+        };
 
-            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-            await ChatClient.InitializeWebsocketConnection();
-            callbackMonitor.Should().HaveBeenInvokedWithPayload();
+        var websocketStates = new ConcurrentQueue<GraphQLWebsocketConnectionState>();
+
+        using (ChatClient.WebsocketConnectionState.Subscribe(websocketStates.Enqueue))
+        {
+            websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
 
+            Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
             Debug.WriteLine("creating subscription stream");
-            var observable1 = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, callbackTester.Invoke);
-            var observable2 = ChatClient.CreateSubscriptionStream<UserJoinedSubscriptionResult>(_subscriptionRequest2, callbackTester2.Invoke);
+            var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, errorMonitor.Invoke);
 
             Debug.WriteLine("subscribing...");
-            var blocker = new ManualResetEventSlim(false);
-            FluentTestObserver<GraphQLResponse<MessageAddedSubscriptionResult>> messagesMonitor = null;
-            FluentTestObserver<GraphQLResponse<UserJoinedSubscriptionResult>> joinedMonitor = null;
+            var observer = observable.Observe();
+            callbackMonitor.Should().HaveBeenInvokedWithPayload();
 
-            var tasks = new List<Task>
-            {
-                Task.Run(() =>
-                {
-                    blocker.Wait();
-                    messagesMonitor = observable1.Observe();
-                }),
-                Task.Run(() =>
-                {
-                    blocker.Wait();
-                    joinedMonitor = observable2.Observe();
-                })
-            };
-
-            blocker.Set();
-            await Task.WhenAll(tasks);
-
-            await messagesMonitor.Should().PushAsync(1);
-            messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
+            websocketStates.Should().ContainInOrder(
+                GraphQLWebsocketConnectionState.Disconnected,
+                GraphQLWebsocketConnectionState.Connecting,
+                GraphQLWebsocketConnectionState.Connected);
+            // clear the collection so the next tests on the collection work as expected
+            websocketStates.Clear();
+
+            await observer.Should().PushAsync(1);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
             const string message1 = "Hello World";
             var response = await ChatClient.AddMessageAsync(message1);
             response.Data.AddMessage.Content.Should().Be(message1);
-            await messagesMonitor.Should().PushAsync(2);
-            messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
-
-            joinedMonitor.Should().NotPush();
-            messagesMonitor.Clear();
-            joinedMonitor.Clear();
-
-            var joinResponse = await ChatClient.JoinDeveloperUser();
-            joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
+            await observer.Should().PushAsync(2);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
 
-            var payload = await joinedMonitor.Should().PushAsync().GetLastMessageAsync();
-            using (new AssertionScope())
-            {
-                payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
-                payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
-            }
+            Debug.WriteLine("stopping web host...");
+            await Fixture.ShutdownServer();
+            Debug.WriteLine("web host stopped");
 
-            messagesMonitor.Should().NotPush();
-            messagesMonitor.Clear();
-            joinedMonitor.Clear();
+            errorMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds())
+                .Which.Should().BeOfType<WebSocketException>();
+            websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
 
-            Debug.WriteLine("disposing subscription...");
-            joinedMonitor.Dispose();
+            Debug.WriteLine("restarting web host...");
+            await InitializeAsync();
+            Debug.WriteLine("web host started");
+            reconnectBlocker.Set();
+            callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
+            await observer.Should().PushAsync(3);
+            observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
 
-            const string message3 = "lorem ipsum dolor si amet";
-            response = await ChatClient.AddMessageAsync(message3);
-            response.Data.AddMessage.Content.Should().Be(message3);
-            var msg = await messagesMonitor.Should().PushAsync().GetLastMessageAsync();
-            msg.Data.MessageAdded.Content.Should().Be(message3);
+            websocketStates.Should().ContainInOrder(
+                GraphQLWebsocketConnectionState.Disconnected,
+                GraphQLWebsocketConnectionState.Connecting,
+                GraphQLWebsocketConnectionState.Connected);
 
             // disposing the client should complete the subscription
             ChatClient.Dispose();
-            await messagesMonitor.Should().CompleteAsync();
-        }
-
-
-        [Fact]
-        public async void CanHandleConnectionTimeout()
-        {
-            var errorMonitor = new CallbackMonitor<Exception>();
-            var reconnectBlocker = new ManualResetEventSlim(false);
-
-            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-            // configure back-off strategy to allow it to be controlled from within the unit test
-            ChatClient.Options.BackOffStrategy = i =>
-            {
-                Debug.WriteLine("back-off strategy: waiting on reconnect blocker");
-                reconnectBlocker.Wait();
-                Debug.WriteLine("back-off strategy: reconnecting...");
-                return TimeSpan.Zero;
-            };
-
-            var websocketStates = new ConcurrentQueue<GraphQLWebsocketConnectionState>();
-
-            using (ChatClient.WebsocketConnectionState.Subscribe(websocketStates.Enqueue))
-            {
-                websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
-
-                Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
-                Debug.WriteLine("creating subscription stream");
-                var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, errorMonitor.Invoke);
-
-                Debug.WriteLine("subscribing...");
-                var observer = observable.Observe();
-                callbackMonitor.Should().HaveBeenInvokedWithPayload();
-
-                websocketStates.Should().ContainInOrder(
-                    GraphQLWebsocketConnectionState.Disconnected,
-                    GraphQLWebsocketConnectionState.Connecting,
-                    GraphQLWebsocketConnectionState.Connected);
-                // clear the collection so the next tests on the collection work as expected
-                websocketStates.Clear();
-
-                await observer.Should().PushAsync(1);
-                observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
-
-                const string message1 = "Hello World";
-                var response = await ChatClient.AddMessageAsync(message1);
-                response.Data.AddMessage.Content.Should().Be(message1);
-                await observer.Should().PushAsync(2);
-                observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
-
-                Debug.WriteLine("stopping web host...");
-                await Fixture.ShutdownServer();
-                Debug.WriteLine("web host stopped");
-
-                errorMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds())
-                    .Which.Should().BeOfType<WebSocketException>();
-                websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
-
-                Debug.WriteLine("restarting web host...");
-                await InitializeAsync();
-                Debug.WriteLine("web host started");
-                reconnectBlocker.Set();
-                callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
-                await observer.Should().PushAsync(3);
-                observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
-
-                websocketStates.Should().ContainInOrder(
-                    GraphQLWebsocketConnectionState.Disconnected,
-                    GraphQLWebsocketConnectionState.Connecting,
-                    GraphQLWebsocketConnectionState.Connected);
-
-                // disposing the client should complete the subscription
-                ChatClient.Dispose();
-                await observer.Should().CompleteAsync(5.Seconds());
-            }
+            await observer.Should().CompleteAsync(5.Seconds());
         }
+    }
 
-        [Fact]
-        public async void CanHandleSubscriptionError()
-        {
-            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-            await ChatClient.InitializeWebsocketConnection();
-            callbackMonitor.Should().HaveBeenInvokedWithPayload();
-            Debug.WriteLine("creating subscription stream");
-            var observable = ChatClient.CreateSubscriptionStream<object>(
-                new GraphQLRequest(@"
+    [Fact]
+    public async void CanHandleSubscriptionError()
+    {
+        var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+        await ChatClient.InitializeWebsocketConnection();
+        callbackMonitor.Should().HaveBeenInvokedWithPayload();
+        Debug.WriteLine("creating subscription stream");
+        var observable = ChatClient.CreateSubscriptionStream<object>(
+            new GraphQLRequest(@"
 					subscription {
 					  failImmediately {
 					    content
 					  }
 					}")
-                );
+            );
 
-            Debug.WriteLine("subscribing...");
+        Debug.WriteLine("subscribing...");
 
-            using var observer = observable.Observe();
+        using var observer = observable.Observe();
 
-            await observer.Should().PushAsync();
-            observer.RecordedMessages.Last().Errors.Should().ContainSingle();
+        await observer.Should().PushAsync();
+        observer.RecordedMessages.Last().Errors.Should().ContainSingle();
 
-            await observer.Should().CompleteAsync();
-            ChatClient.Dispose();
-        }
+        await observer.Should().CompleteAsync();
+        ChatClient.Dispose();
+    }
 
-        [Fact]
-        public async void CanHandleQueryErrorInSubscription()
-        {
-            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
-            await ChatClient.InitializeWebsocketConnection();
-            callbackMonitor.Should().HaveBeenInvokedWithPayload();
-            Debug.WriteLine("creating subscription stream");
-            var observable = ChatClient.CreateSubscriptionStream<object>(
-                new GraphQLRequest(@"
+    [Fact]
+    public async void CanHandleQueryErrorInSubscription()
+    {
+        var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
+        await ChatClient.InitializeWebsocketConnection();
+        callbackMonitor.Should().HaveBeenInvokedWithPayload();
+        Debug.WriteLine("creating subscription stream");
+        var observable = ChatClient.CreateSubscriptionStream<object>(
+            new GraphQLRequest(@"
 					subscription {
 					  fieldDoesNotExist {
 					    content
 					  }
 					}")
-            );
+        );
 
-            Debug.WriteLine("subscribing...");
+        Debug.WriteLine("subscribing...");
 
-            using var observer = observable.Observe();
+        using var observer = observable.Observe();
 
-            await observer.Should().PushAsync();
-            observer.RecordedMessages.Last().Errors.Should().ContainSingle();
-
-            await observer.Should().CompleteAsync();
-            ChatClient.Dispose();
-        }
+        await observer.Should().PushAsync();
+        observer.RecordedMessages.Last().Errors.Should().ContainSingle();
 
+        await observer.Should().CompleteAsync();
+        ChatClient.Dispose();
     }
+
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
index d77ca14c..87c23ba6 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
@@ -2,12 +2,11 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GraphQL.Integration.Tests.WebsocketTests
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
 {
-    public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
+    public Newtonsoft(ITestOutputHelper output, NewtonsoftIntegrationServerTestFixture fixture) : base(output, fixture)
     {
-        public Newtonsoft(ITestOutputHelper output, NewtonsoftIntegrationServerTestFixture fixture) : base(output, fixture)
-        {
-        }
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
index ab4659a4..e3648bf4 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
@@ -2,12 +2,11 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace GraphQL.Integration.Tests.WebsocketTests
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
 {
-    public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
+    public SystemTextJson(ITestOutputHelper output, SystemTextJsonIntegrationServerTestFixture fixture) : base(output, fixture)
     {
-        public SystemTextJson(ITestOutputHelper output, SystemTextJsonIntegrationServerTestFixture fixture) : base(output, fixture)
-        {
-        }
     }
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
index 3d7fde8d..9f2248c6 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLLocationTest.cs
@@ -1,62 +1,61 @@
 using Xunit;
 
-namespace GraphQL.Primitives.Tests
+namespace GraphQL.Primitives.Tests;
+
+public class GraphQLLocationTest
 {
-    public class GraphQLLocationTest
+    [Fact]
+    public void ConstructorFact()
+    {
+        var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
+        Assert.Equal(1U, graphQLLocation.Column);
+        Assert.Equal(2U, graphQLLocation.Line);
+    }
+
+    [Fact]
+    public void Equality1Fact()
+    {
+        var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
+        Assert.Equal(graphQLLocation, graphQLLocation);
+    }
+
+    [Fact]
+    public void Equality2Fact()
+    {
+        var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+        var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
+        Assert.Equal(graphQLLocation1, graphQLLocation2);
+    }
+
+    [Fact]
+    public void EqualityOperatorFact()
+    {
+        var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+        var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
+        Assert.True(graphQLLocation1 == graphQLLocation2);
+    }
+
+    [Fact]
+    public void InEqualityFact()
+    {
+        var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+        var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
+        Assert.NotEqual(graphQLLocation1, graphQLLocation2);
+    }
+
+    [Fact]
+    public void InEqualityOperatorFact()
+    {
+        var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+        var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
+        Assert.True(graphQLLocation1 != graphQLLocation2);
+    }
+
+    [Fact]
+    public void GetHashCodeFact()
     {
-        [Fact]
-        public void ConstructorFact()
-        {
-            var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
-            Assert.Equal(1U, graphQLLocation.Column);
-            Assert.Equal(2U, graphQLLocation.Line);
-        }
-
-        [Fact]
-        public void Equality1Fact()
-        {
-            var graphQLLocation = new GraphQLLocation { Column = 1, Line = 2 };
-            Assert.Equal(graphQLLocation, graphQLLocation);
-        }
-
-        [Fact]
-        public void Equality2Fact()
-        {
-            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-            var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-            Assert.Equal(graphQLLocation1, graphQLLocation2);
-        }
-
-        [Fact]
-        public void EqualityOperatorFact()
-        {
-            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-            var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-            Assert.True(graphQLLocation1 == graphQLLocation2);
-        }
-
-        [Fact]
-        public void InEqualityFact()
-        {
-            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-            var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
-            Assert.NotEqual(graphQLLocation1, graphQLLocation2);
-        }
-
-        [Fact]
-        public void InEqualityOperatorFact()
-        {
-            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-            var graphQLLocation2 = new GraphQLLocation { Column = 2, Line = 1 };
-            Assert.True(graphQLLocation1 != graphQLLocation2);
-        }
-
-        [Fact]
-        public void GetHashCodeFact()
-        {
-            var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
-            var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
-            Assert.True(graphQLLocation1.GetHashCode() == graphQLLocation2.GetHashCode());
-        }
+        var graphQLLocation1 = new GraphQLLocation { Column = 1, Line = 2 };
+        var graphQLLocation2 = new GraphQLLocation { Column = 1, Line = 2 };
+        Assert.True(graphQLLocation1.GetHashCode() == graphQLLocation2.GetHashCode());
     }
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
index e5b41a15..b56e6376 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
@@ -1,183 +1,182 @@
 using Xunit;
 
-namespace GraphQL.Primitives.Tests
+namespace GraphQL.Primitives.Tests;
+
+public class GraphQLRequestTest
 {
-    public class GraphQLRequestTest
+    [Fact]
+    public void ConstructorFact()
     {
-        [Fact]
-        public void ConstructorFact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}");
-            Assert.NotNull(graphQLRequest.Query);
-            Assert.Null(graphQLRequest.OperationName);
-            Assert.Null(graphQLRequest.Variables);
-        }
-
-        [Fact]
-        public void ConstructorExtendedFact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            Assert.NotNull(graphQLRequest.Query);
-            Assert.NotNull(graphQLRequest.OperationName);
-            Assert.NotNull(graphQLRequest.Variables);
-        }
-
-        [Fact]
-        public void Equality1Fact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}");
-            Assert.Equal(graphQLRequest, graphQLRequest);
-        }
+        var graphQLRequest = new GraphQLRequest("{hero{name}}");
+        Assert.NotNull(graphQLRequest.Query);
+        Assert.Null(graphQLRequest.OperationName);
+        Assert.Null(graphQLRequest.Variables);
+    }
 
-        [Fact]
-        public void Equality2Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
-            Assert.Equal(graphQLRequest1, graphQLRequest2);
-        }
+    [Fact]
+    public void ConstructorExtendedFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        Assert.NotNull(graphQLRequest.Query);
+        Assert.NotNull(graphQLRequest.OperationName);
+        Assert.NotNull(graphQLRequest.Variables);
+    }
 
-        [Fact]
-        public void Equality3Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            Assert.Equal(graphQLRequest1, graphQLRequest2);
-        }
+    [Fact]
+    public void Equality1Fact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}");
+        Assert.Equal(graphQLRequest, graphQLRequest);
+    }
 
-        [Fact]
-        public void Equality4Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
-            Assert.NotEqual(graphQLRequest1, graphQLRequest2);
-        }
+    [Fact]
+    public void Equality2Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
+        Assert.Equal(graphQLRequest1, graphQLRequest2);
+    }
 
-        [Fact]
-        public void EqualityOperatorFact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            Assert.True(graphQLRequest1 == graphQLRequest2);
-        }
+    [Fact]
+    public void Equality3Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        Assert.Equal(graphQLRequest1, graphQLRequest2);
+    }
 
-        [Fact]
-        public void InEquality1Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
-            Assert.NotEqual(graphQLRequest1, graphQLRequest2);
-        }
+    [Fact]
+    public void Equality4Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+        Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+    }
 
-        [Fact]
-        public void InEquality2Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
-            Assert.NotEqual(graphQLRequest1, graphQLRequest2);
-        }
+    [Fact]
+    public void EqualityOperatorFact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        Assert.True(graphQLRequest1 == graphQLRequest2);
+    }
 
-        [Fact]
-        public void InEqualityOperatorFact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
-            Assert.True(graphQLRequest1 != graphQLRequest2);
-        }
+    [Fact]
+    public void InEquality1Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
+        Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+    }
 
-        [Fact]
-        public void GetHashCode1Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
-            Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
-        }
+    [Fact]
+    public void InEquality2Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+        Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+    }
 
-        [Fact]
-        public void GetHashCode2Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
-        }
+    [Fact]
+    public void InEqualityOperatorFact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
+        Assert.True(graphQLRequest1 != graphQLRequest2);
+    }
 
-        [Fact]
-        public void GetHashCode3Fact()
-        {
-            var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
-            Assert.True(graphQLRequest1.GetHashCode() != graphQLRequest2.GetHashCode());
-        }
+    [Fact]
+    public void GetHashCode1Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
+        Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
+    }
 
-        [Fact]
-        public void PropertyQueryGetFact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
-            Assert.Equal("{hero{name}}", graphQLRequest.Query);
-        }
+    [Fact]
+    public void GetHashCode2Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        Assert.True(graphQLRequest1.GetHashCode() == graphQLRequest2.GetHashCode());
+    }
 
-        [Fact]
-        public void PropertyQuerySetFact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName")
-            {
-                Query = "{hero{name2}}"
-            };
-            Assert.Equal("{hero{name2}}", graphQLRequest.Query);
-        }
+    [Fact]
+    public void GetHashCode3Fact()
+    {
+        var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+        var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
+        Assert.True(graphQLRequest1.GetHashCode() != graphQLRequest2.GetHashCode());
+    }
 
-        [Fact]
-        public void PropertyOperationNameGetFact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            Assert.Equal("operationName", graphQLRequest.OperationName);
-        }
+    [Fact]
+    public void PropertyQueryGetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
+        Assert.Equal("{hero{name}}", graphQLRequest.Query);
+    }
 
-        [Fact]
-        public void PropertyOperationNameNullGetFact()
+    [Fact]
+    public void PropertyQuerySetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName")
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}");
-            Assert.Null(graphQLRequest.OperationName);
-        }
+            Query = "{hero{name2}}"
+        };
+        Assert.Equal("{hero{name2}}", graphQLRequest.Query);
+    }
 
-        [Fact]
-        public void PropertyOperationNameSetFact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1")
-            {
-                OperationName = "operationName2"
-            };
-            Assert.Equal("operationName2", graphQLRequest.OperationName);
-        }
+    [Fact]
+    public void PropertyOperationNameGetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        Assert.Equal("operationName", graphQLRequest.OperationName);
+    }
 
-        [Fact]
-        public void PropertyVariableGetFact()
-        {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-            Assert.Equal(new { varName = "varValue" }, graphQLRequest.Variables);
-        }
+    [Fact]
+    public void PropertyOperationNameNullGetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}");
+        Assert.Null(graphQLRequest.OperationName);
+    }
 
-        [Fact]
-        public void PropertyVariableNullGetFact()
+    [Fact]
+    public void PropertyOperationNameSetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName1")
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}");
-            Assert.Null(graphQLRequest.Variables);
-        }
+            OperationName = "operationName2"
+        };
+        Assert.Equal("operationName2", graphQLRequest.OperationName);
+    }
+
+    [Fact]
+    public void PropertyVariableGetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
+        Assert.Equal(new { varName = "varValue" }, graphQLRequest.Variables);
+    }
+
+    [Fact]
+    public void PropertyVariableNullGetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}");
+        Assert.Null(graphQLRequest.Variables);
+    }
 
-        [Fact]
-        public void PropertyVariableSetFact()
+    [Fact]
+    public void PropertyVariableSetFact()
+    {
+        var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1")
         {
-            var graphQLRequest = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName1")
-            {
-                Variables = new
-                {
-                    varName = "varValue2"
-                }
-            };
-            Assert.Equal(new
+            Variables = new
             {
                 varName = "varValue2"
-            }, graphQLRequest.Variables);
-        }
+            }
+        };
+        Assert.Equal(new
+        {
+            varName = "varValue2"
+        }, graphQLRequest.Variables);
     }
 }
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
index ce062e05..6db1dcbf 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLResponseTest.cs
@@ -1,114 +1,113 @@
 using Xunit;
 
-namespace GraphQL.Primitives.Tests
+namespace GraphQL.Primitives.Tests;
+
+public class GraphQLResponseTest
 {
-    public class GraphQLResponseTest
+    [Fact]
+    public void Constructor1Fact()
     {
-        [Fact]
-        public void Constructor1Fact()
-        {
-            var graphQLResponse = new GraphQLResponse<object>();
-            Assert.Null(graphQLResponse.Data);
-            Assert.Null(graphQLResponse.Errors);
-        }
+        var graphQLResponse = new GraphQLResponse<object>();
+        Assert.Null(graphQLResponse.Data);
+        Assert.Null(graphQLResponse.Errors);
+    }
 
-        [Fact]
-        public void Constructor2Fact()
+    [Fact]
+    public void Constructor2Fact()
+    {
+        var graphQLResponse = new GraphQLResponse<object>
         {
-            var graphQLResponse = new GraphQLResponse<object>
-            {
-                Data = new { a = 1 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            Assert.NotNull(graphQLResponse.Data);
-            Assert.NotNull(graphQLResponse.Errors);
-        }
+            Data = new { a = 1 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        Assert.NotNull(graphQLResponse.Data);
+        Assert.NotNull(graphQLResponse.Errors);
+    }
 
-        [Fact]
-        public void Equality1Fact()
-        {
-            var graphQLResponse = new GraphQLResponse<object>();
-            Assert.Equal(graphQLResponse, graphQLResponse);
-        }
+    [Fact]
+    public void Equality1Fact()
+    {
+        var graphQLResponse = new GraphQLResponse<object>();
+        Assert.Equal(graphQLResponse, graphQLResponse);
+    }
 
-        [Fact]
-        public void Equality2Fact()
-        {
-            var graphQLResponse1 = new GraphQLResponse<object>();
-            var graphQLResponse2 = new GraphQLResponse<object>();
-            Assert.Equal(graphQLResponse1, graphQLResponse2);
-        }
+    [Fact]
+    public void Equality2Fact()
+    {
+        var graphQLResponse1 = new GraphQLResponse<object>();
+        var graphQLResponse2 = new GraphQLResponse<object>();
+        Assert.Equal(graphQLResponse1, graphQLResponse2);
+    }
 
-        [Fact]
-        public void Equality3Fact()
+    [Fact]
+    public void Equality3Fact()
+    {
+        var graphQLResponse1 = new GraphQLResponse<object>
         {
-            var graphQLResponse1 = new GraphQLResponse<object>
-            {
-                Data = new { a = 1 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            var graphQLResponse2 = new GraphQLResponse<object>
-            {
-                Data = new { a = 1 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            Assert.Equal(graphQLResponse1, graphQLResponse2);
-        }
-
-        [Fact]
-        public void EqualityOperatorFact()
+            Data = new { a = 1 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        var graphQLResponse2 = new GraphQLResponse<object>
         {
-            var graphQLResponse1 = new GraphQLResponse<object>();
-            var graphQLResponse2 = new GraphQLResponse<object>();
-            Assert.True(graphQLResponse1 == graphQLResponse2);
-        }
+            Data = new { a = 1 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        Assert.Equal(graphQLResponse1, graphQLResponse2);
+    }
+
+    [Fact]
+    public void EqualityOperatorFact()
+    {
+        var graphQLResponse1 = new GraphQLResponse<object>();
+        var graphQLResponse2 = new GraphQLResponse<object>();
+        Assert.True(graphQLResponse1 == graphQLResponse2);
+    }
 
-        [Fact]
-        public void InEqualityFact()
+    [Fact]
+    public void InEqualityFact()
+    {
+        var graphQLResponse1 = new GraphQLResponse<object>
+        {
+            Data = new { a = 1 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        var graphQLResponse2 = new GraphQLResponse<object>
         {
-            var graphQLResponse1 = new GraphQLResponse<object>
-            {
-                Data = new { a = 1 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            var graphQLResponse2 = new GraphQLResponse<object>
-            {
-                Data = new { a = 2 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            Assert.NotEqual(graphQLResponse1, graphQLResponse2);
-        }
+            Data = new { a = 2 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        Assert.NotEqual(graphQLResponse1, graphQLResponse2);
+    }
 
-        [Fact]
-        public void InEqualityOperatorFact()
+    [Fact]
+    public void InEqualityOperatorFact()
+    {
+        var graphQLResponse1 = new GraphQLResponse<object>
+        {
+            Data = new { a = 1 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        var graphQLResponse2 = new GraphQLResponse<object>
         {
-            var graphQLResponse1 = new GraphQLResponse<object>
-            {
-                Data = new { a = 1 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            var graphQLResponse2 = new GraphQLResponse<object>
-            {
-                Data = new { a = 2 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            Assert.True(graphQLResponse1 != graphQLResponse2);
-        }
+            Data = new { a = 2 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        Assert.True(graphQLResponse1 != graphQLResponse2);
+    }
 
-        [Fact]
-        public void GetHashCodeFact()
+    [Fact]
+    public void GetHashCodeFact()
+    {
+        var graphQLResponse1 = new GraphQLResponse<object>
+        {
+            Data = new { a = 1 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        var graphQLResponse2 = new GraphQLResponse<object>
         {
-            var graphQLResponse1 = new GraphQLResponse<object>
-            {
-                Data = new { a = 1 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            var graphQLResponse2 = new GraphQLResponse<object>
-            {
-                Data = new { a = 1 },
-                Errors = new[] { new GraphQLError { Message = "message" } }
-            };
-            Assert.True(graphQLResponse1.GetHashCode() == graphQLResponse2.GetHashCode());
-        }
+            Data = new { a = 1 },
+            Errors = new[] { new GraphQLError { Message = "message" } }
+        };
+        Assert.True(graphQLResponse1.GetHashCode() == graphQLResponse2.GetHashCode());
     }
 }
diff --git a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
index 74add0a1..2fb2bbc0 100644
--- a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
@@ -3,32 +3,31 @@
 using FluentAssertions;
 using Xunit;
 
-namespace GraphQL.Primitives.Tests
+namespace GraphQL.Primitives.Tests;
+
+public class JsonSerializationTests
 {
-    public class JsonSerializationTests
+    [Fact]
+    public void WebSocketResponseDeserialization()
     {
-        [Fact]
-        public void WebSocketResponseDeserialization()
-        {
-            var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff" };
-            var json = JsonSerializer.Serialize(testObject);
-            var deserialized = JsonSerializer.Deserialize<TestObject>(json);
-            deserialized.Id.Should().Be("test");
-            var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
-            var childObject = (JsonElement)dict["ChildObject"];
-            childObject.GetProperty("Id").GetString().Should().Be(testObject.ChildObject.Id);
-        }
+        var testObject = new ExtendedTestObject { Id = "test", OtherData = "this is some other stuff" };
+        var json = JsonSerializer.Serialize(testObject);
+        var deserialized = JsonSerializer.Deserialize<TestObject>(json);
+        deserialized.Id.Should().Be("test");
+        var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(json);
+        var childObject = (JsonElement)dict["ChildObject"];
+        childObject.GetProperty("Id").GetString().Should().Be(testObject.ChildObject.Id);
+    }
 
-        public class TestObject
-        {
-            public string Id { get; set; }
-        }
+    public class TestObject
+    {
+        public string Id { get; set; }
+    }
 
-        public class ExtendedTestObject : TestObject
-        {
-            public string OtherData { get; set; }
+    public class ExtendedTestObject : TestObject
+    {
+        public string OtherData { get; set; }
 
-            public TestObject ChildObject { get; set; } = new TestObject { Id = "1337" };
-        }
+        public TestObject ChildObject { get; set; } = new TestObject { Id = "1337" };
     }
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
index b262a6bd..7fcfc500 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Models/Repository.cs
@@ -1,30 +1,29 @@
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL.Models
+namespace GraphQL.Server.Test.GraphQL.Models;
+
+public class Repository
 {
-    public class Repository
-    {
-        public int DatabaseId { get; set; }
+    public int DatabaseId { get; set; }
 
-        public string? Id { get; set; }
+    public string? Id { get; set; }
 
-        public string? Name { get; set; }
+    public string? Name { get; set; }
 
-        public object? Owner { get; set; }
+    public object? Owner { get; set; }
 
-        public Uri? Url { get; set; }
-    }
+    public Uri? Url { get; set; }
+}
 
-    public class RepositoryGraphType : ObjectGraphType<Repository>
+public class RepositoryGraphType : ObjectGraphType<Repository>
+{
+    public RepositoryGraphType()
     {
-        public RepositoryGraphType()
-        {
-            Name = nameof(Repository);
-            Field(expression => expression.DatabaseId);
-            Field<NonNullGraphType<IdGraphType>>("id");
-            Field(expression => expression.Name);
-            //this.Field(expression => expression.Owner);
-            Field<NonNullGraphType<UriGraphType>>("url");
-        }
+        Name = nameof(Repository);
+        Field(expression => expression.DatabaseId);
+        Field<NonNullGraphType<IdGraphType>>("id");
+        Field(expression => expression.Name);
+        //this.Field(expression => expression.Owner);
+        Field<NonNullGraphType<UriGraphType>>("url");
     }
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/Storage.cs b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
index f157da14..cc8887e0 100644
--- a/tests/GraphQL.Server.Test/GraphQL/Storage.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/Storage.cs
@@ -1,18 +1,17 @@
 using GraphQL.Server.Test.GraphQL.Models;
 
-namespace GraphQL.Server.Test.GraphQL
+namespace GraphQL.Server.Test.GraphQL;
+
+public static class Storage
 {
-    public static class Storage
-    {
-        public static IQueryable<Repository> Repositories { get; } = new List<Repository>()
-            .Append(new Repository
-            {
-                DatabaseId = 113196300,
-                Id = "MDEwOlJlcG9zaXRvcnkxMTMxOTYzMDA=",
-                Name = "graphql-client",
-                Owner = null,
-                Url = new Uri("https://github.com/graphql-dotnet/graphql-client")
-            })
-            .AsQueryable();
-    }
+    public static IQueryable<Repository> Repositories { get; } = new List<Repository>()
+        .Append(new Repository
+        {
+            DatabaseId = 113196300,
+            Id = "MDEwOlJlcG9zaXRvcnkxMTMxOTYzMDA=",
+            Name = "graphql-client",
+            Owner = null,
+            Url = new Uri("https://github.com/graphql-dotnet/graphql-client")
+        })
+        .AsQueryable();
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
index dfd67981..ffae2332 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestMutation.cs
@@ -1,11 +1,10 @@
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL
+namespace GraphQL.Server.Test.GraphQL;
+
+public class TestMutation : ObjectGraphType
 {
-    public class TestMutation : ObjectGraphType
+    public TestMutation()
     {
-        public TestMutation()
-        {
-        }
     }
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index 4eb32723..31bbef6e 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -1,18 +1,17 @@
 using GraphQL.Server.Test.GraphQL.Models;
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL
+namespace GraphQL.Server.Test.GraphQL;
+
+public class TestQuery : ObjectGraphType
 {
-    public class TestQuery : ObjectGraphType
+    public TestQuery()
     {
-        public TestQuery()
+        Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context =>
         {
-            Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context =>
-            {
-                var owner = context.GetArgument<string>("owner");
-                var name = context.GetArgument<string>("name");
-                return Storage.Repositories.FirstOrDefault(predicate => predicate.Name == name);
-            });
-        }
+            var owner = context.GetArgument<string>("owner");
+            var name = context.GetArgument<string>("name");
+            return Storage.Repositories.FirstOrDefault(predicate => predicate.Name == name);
+        });
     }
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
index c589d388..feecf79e 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSchema.cs
@@ -1,14 +1,13 @@
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL
+namespace GraphQL.Server.Test.GraphQL;
+
+public class TestSchema : Schema
 {
-    public class TestSchema : Schema
+    public TestSchema()
     {
-        public TestSchema()
-        {
-            Query = new TestQuery();
-            //this.Mutation = new TestMutation();
-            //this.Subscription = new TestSubscription();
-        }
+        Query = new TestQuery();
+        //this.Mutation = new TestMutation();
+        //this.Subscription = new TestSubscription();
     }
 }
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
index 4fabf386..d8ebc5de 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestSubscription.cs
@@ -1,11 +1,10 @@
 using GraphQL.Types;
 
-namespace GraphQL.Server.Test.GraphQL
+namespace GraphQL.Server.Test.GraphQL;
+
+public class TestSubscription : ObjectGraphType
 {
-    public class TestSubscription : ObjectGraphType
+    public TestSubscription()
     {
-        public TestSubscription()
-        {
-        }
     }
 }
diff --git a/tests/GraphQL.Server.Test/Program.cs b/tests/GraphQL.Server.Test/Program.cs
index 98538f1f..f205fd5c 100644
--- a/tests/GraphQL.Server.Test/Program.cs
+++ b/tests/GraphQL.Server.Test/Program.cs
@@ -1,15 +1,14 @@
 using Microsoft.AspNetCore;
 
-namespace GraphQL.Server.Test
+namespace GraphQL.Server.Test;
+
+public static class Program
 {
-    public static class Program
-    {
-        public static async Task Main(string[] args) =>
-            await CreateHostBuilder(args).Build().RunAsync();
+    public static async Task Main(string[] args) =>
+        await CreateHostBuilder(args).Build().RunAsync();
 
-        public static IWebHostBuilder CreateHostBuilder(string[] args = null) =>
-            WebHost.CreateDefaultBuilder(args)
-                .UseKestrel(options => options.AllowSynchronousIO = true)
-                .UseStartup<Startup>();
-    }
+    public static IWebHostBuilder CreateHostBuilder(string[] args = null) =>
+        WebHost.CreateDefaultBuilder(args)
+            .UseKestrel(options => options.AllowSynchronousIO = true)
+            .UseStartup<Startup>();
 }
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index 2421cf70..25e1e9d5 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -2,33 +2,32 @@
 using GraphQL.Server.Test.GraphQL;
 using GraphQL.Server.Ui.GraphiQL;
 
-namespace GraphQL.Server.Test
+namespace GraphQL.Server.Test;
+
+public class Startup
 {
-    public class Startup
+    public void Configure(IApplicationBuilder app)
     {
-        public void Configure(IApplicationBuilder app)
+        var webHostEnvironment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
+        if (webHostEnvironment.IsDevelopment())
         {
-            var webHostEnvironment = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
-            if (webHostEnvironment.IsDevelopment())
-            {
-                app.UseDeveloperExceptionPage();
-            }
-            app.UseHttpsRedirection();
-
-            app.UseWebSockets();
-            app.UseGraphQLWebSockets<TestSchema>();
-            app.UseGraphQL<TestSchema>();
-            app.UseGraphQLGraphiQL(new GraphiQLOptions { });
+            app.UseDeveloperExceptionPage();
         }
+        app.UseHttpsRedirection();
 
-        public void ConfigureServices(IServiceCollection services)
-        {
-            services.AddGraphQL(builder => builder
-                .AddSchema<TestSchema>()
-                .AddApolloTracing(enableMetrics: true)
-                .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = true)
-                .AddWebSockets()
-            );
-        }
+        app.UseWebSockets();
+        app.UseGraphQLWebSockets<TestSchema>();
+        app.UseGraphQL<TestSchema>();
+        app.UseGraphQLGraphiQL(new GraphiQLOptions { });
+    }
+
+    public void ConfigureServices(IServiceCollection services)
+    {
+        services.AddGraphQL(builder => builder
+            .AddSchema<TestSchema>()
+            .AddApolloTracing(enableMetrics: true)
+            .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = true)
+            .AddWebSockets()
+        );
     }
 }
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
index ac56ea87..3220c40d 100644
--- a/tests/IntegrationTestServer/Program.cs
+++ b/tests/IntegrationTestServer/Program.cs
@@ -1,14 +1,13 @@
 using Microsoft.AspNetCore;
 
-namespace IntegrationTestServer
+namespace IntegrationTestServer;
+
+public static class Program
 {
-    public static class Program
-    {
-        public static void Main(string[] args) => CreateWebHostBuilder(args).Build().Run();
+    public static void Main(string[] args) => CreateWebHostBuilder(args).Build().Run();
 
-        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
-            WebHost.CreateDefaultBuilder(args)
-                .UseStartup<Startup>()
-                .ConfigureLogging((_, logging) => logging.SetMinimumLevel(LogLevel.Debug));
-    }
+    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+        WebHost.CreateDefaultBuilder(args)
+            .UseStartup<Startup>()
+            .ConfigureLogging((_, logging) => logging.SetMinimumLevel(LogLevel.Debug));
 }
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index c8441472..4876fdb3 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -10,67 +10,66 @@
 using GraphQL.Types;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 
-namespace IntegrationTestServer
+namespace IntegrationTestServer;
+
+public class Startup
 {
-    public class Startup
+    public Startup(IConfiguration configuration, IWebHostEnvironment environment)
     {
-        public Startup(IConfiguration configuration, IWebHostEnvironment environment)
-        {
-            Configuration = configuration;
-            Environment = environment;
-        }
+        Configuration = configuration;
+        Environment = environment;
+    }
 
-        public IConfiguration Configuration { get; }
+    public IConfiguration Configuration { get; }
 
-        public IWebHostEnvironment Environment { get; }
+    public IWebHostEnvironment Environment { get; }
 
-        // This method gets called by the runtime. Use this method to add services to the container.
-        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
-        public void ConfigureServices(IServiceCollection services)
-        {
-            services.Configure<KestrelServerOptions>(options => options.AllowSynchronousIO = true);
-            //
-            services.AddChatSchema();
-            services.AddStarWarsSchema();
-            services.AddGraphQL(builder => builder
-                .AddApolloTracing(enableMetrics: true)
-                .AddHttpMiddleware<ChatSchema>()
-                .AddHttpMiddleware<StarWarsSchema>()
-                .AddWebSocketsHttpMiddleware<ChatSchema>()
-                .AddWebSocketsHttpMiddleware<StarWarsSchema>()
-                .ConfigureExecutionOptions(opt => opt.UnhandledExceptionDelegate = ctx =>
-                {
-                    var logger = ctx.Context.RequestServices.GetRequiredService<ILogger<Startup>>();
-                    logger.LogError("{Error} occurred", ctx.OriginalException.Message);
-                    return System.Threading.Tasks.Task.CompletedTask;
-                })
-                .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = Environment.IsDevelopment())
-                .AddSystemTextJson()
-                .AddWebSockets()
-                .AddGraphTypes(typeof(ChatSchema).Assembly));
-        }
+    // This method gets called by the runtime. Use this method to add services to the container.
+    // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+    public void ConfigureServices(IServiceCollection services)
+    {
+        services.Configure<KestrelServerOptions>(options => options.AllowSynchronousIO = true);
+        //
+        services.AddChatSchema();
+        services.AddStarWarsSchema();
+        services.AddGraphQL(builder => builder
+            .AddApolloTracing(enableMetrics: true)
+            .AddHttpMiddleware<ChatSchema>()
+            .AddHttpMiddleware<StarWarsSchema>()
+            .AddWebSocketsHttpMiddleware<ChatSchema>()
+            .AddWebSocketsHttpMiddleware<StarWarsSchema>()
+            .ConfigureExecutionOptions(opt => opt.UnhandledExceptionDelegate = ctx =>
+            {
+                var logger = ctx.Context.RequestServices.GetRequiredService<ILogger<Startup>>();
+                logger.LogError("{Error} occurred", ctx.OriginalException.Message);
+                return System.Threading.Tasks.Task.CompletedTask;
+            })
+            .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = Environment.IsDevelopment())
+            .AddSystemTextJson()
+            .AddWebSockets()
+            .AddGraphTypes(typeof(ChatSchema).Assembly));
+    }
 
-        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
-        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+    {
+        if (env.IsDevelopment())
         {
-            if (env.IsDevelopment())
-            {
-                app.UseDeveloperExceptionPage();
-            }
+            app.UseDeveloperExceptionPage();
+        }
 
-            app.UseWebSockets();
+        app.UseWebSockets();
 
-            ConfigureGraphQLSchema<ChatSchema>(app, Common.CHAT_ENDPOINT);
-            ConfigureGraphQLSchema<StarWarsSchema>(app, Common.STAR_WARS_ENDPOINT);
+        ConfigureGraphQLSchema<ChatSchema>(app, Common.CHAT_ENDPOINT);
+        ConfigureGraphQLSchema<StarWarsSchema>(app, Common.STAR_WARS_ENDPOINT);
 
-            app.UseGraphQLGraphiQL(new GraphiQLOptions { GraphQLEndPoint = Common.STAR_WARS_ENDPOINT });
-            app.UseGraphQLAltair(new AltairOptions { GraphQLEndPoint = Common.CHAT_ENDPOINT });
-        }
+        app.UseGraphQLGraphiQL(new GraphiQLOptions { GraphQLEndPoint = Common.STAR_WARS_ENDPOINT });
+        app.UseGraphQLAltair(new AltairOptions { GraphQLEndPoint = Common.CHAT_ENDPOINT });
+    }
 
-        private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema : Schema
-        {
-            app.UseGraphQLWebSockets<TSchema>(endpoint);
-            app.UseGraphQL<TSchema>(endpoint);
-        }
+    private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema : Schema
+    {
+        app.UseGraphQLWebSockets<TSchema>(endpoint);
+        app.UseGraphQL<TSchema>(endpoint);
     }
 }

From b4c6c82892cab3c6521fb9b470f8e67448413ade Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 2 Aug 2022 00:06:39 +0300
Subject: [PATCH 389/455] Fix default behavior for 401/403 http response codes
 (#429)

* Fix default behavior for 401/403 http response codes

* Add Accept and Accept-Charset headers

* fix default user agent version

* add note
---
 src/GraphQL.Client/GraphQLHttpClientOptions.cs           | 6 +++++-
 src/GraphQL.Client/GraphQLHttpRequest.cs                 | 4 ++++
 .../QueryAndMutationTests/Base.cs                        | 9 +++++++--
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 12fad5e3..549760c2 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -52,8 +52,12 @@ public class GraphQLHttpClientOptions
 
     /// <summary>
     /// Delegate to determine if GraphQL response may be properly deserialized into <see cref="GraphQLResponse{T}"/>.
+    /// Note that compatible to the draft graphql-over-http spec GraphQL Server MAY return 4xx status codes (401/403, etc.)
+    /// with well-formed GraphQL response containing errors collection.
     /// </summary>
-    public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = r => r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest;
+    public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = r =>
+        // Why not application/json? See https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#processing-the-response
+        r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest || r.Content.Headers.ContentType.MediaType == "application/graphql+json";
 
     /// <summary>
     /// This callback is called after successfully establishing a websocket connection but before any regular request is made.
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index b0591e57..2da60705 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -1,3 +1,4 @@
+using System.Net.Http.Headers;
 using System.Runtime.Serialization;
 using System.Text;
 using GraphQL.Client.Abstractions;
@@ -38,6 +39,9 @@ public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions
         {
             Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
         };
+        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql+json"));
+        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+        message.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
 
 #pragma warning disable CS0618 // Type or member is obsolete
         PreprocessHttpRequestMessage(message);
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 600ca463..abcdc644 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -1,4 +1,5 @@
 using System.Net;
+using System.Net.Http.Headers;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http;
@@ -173,9 +174,13 @@ public async void PreprocessHttpRequestMessageIsCalled()
 #pragma warning restore CS0618 // Type or member is obsolete
         };
 
-        var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
+        var expectedHeaders = new HttpRequestMessage().Headers;
+        expectedHeaders.UserAgent.Add(new ProductInfoHeaderValue("GraphQL.Client", typeof(GraphQLHttpClient).Assembly.GetName().Version.ToString()));
+        expectedHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql+json"));
+        expectedHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+        expectedHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
         var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
-        callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
+        callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(expectedHeaders);
         Assert.Null(response.Errors);
         Assert.Equal("Luke", response.Data.Human.Name);
     }

From 8379f8f2fc66326a87a397cc2fee294ff42ece6a Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 2 Aug 2022 00:12:33 +0300
Subject: [PATCH 390/455] Fix ArgumentNullException from
 ClientWebSocketOptions.ClientCertificates (#431)

---
 src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 28b721eb..1afa6b98 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -399,7 +399,9 @@ public Task InitializeWebSocket()
             // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
             try
             {
-                _clientWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                var certs = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                if (certs != null) // ClientWebSocketOptions.ClientCertificates.set throws ArgumentNullException
+                    _clientWebSocket.Options.ClientCertificates = certs;
             }
             catch (NotImplementedException)
             {

From de502926b5db8cbd0f7f9119c9237b5ec573fb03 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 2 Aug 2022 11:00:02 +0200
Subject: [PATCH 391/455] Fix NullReferenceException from
 GraphQLHttpClientOptions.IsValidResponseToDeserialize (#433)

Avoid NullReferenceException when Headers.ContentType is null
---
 src/GraphQL.Client/GraphQLHttpClientOptions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 549760c2..22b5ddb2 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -57,7 +57,7 @@ public class GraphQLHttpClientOptions
     /// </summary>
     public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = r =>
         // Why not application/json? See https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#processing-the-response
-        r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest || r.Content.Headers.ContentType.MediaType == "application/graphql+json";
+        r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest || r.Content.Headers.ContentType?.MediaType == "application/graphql+json";
 
     /// <summary>
     /// This callback is called after successfully establishing a websocket connection but before any regular request is made.

From 62dd4e9011f0eec55a36e810159ad0b449874bf9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 3 Aug 2022 12:09:01 +0300
Subject: [PATCH 392/455] Bump xunit from 2.4.1 to 2.4.2 (#434)

Bumps [xunit](https://github.com/xunit/xunit) from 2.4.1 to 2.4.2.
- [Release notes](https://github.com/xunit/xunit/releases)
- [Commits](https://github.com/xunit/xunit/compare/2.4.1...2.4.2)

---
updated-dependencies:
- dependency-name: xunit
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 28e5e65c..10dc01bc 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -8,7 +8,7 @@
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.1.2">
       <PrivateAssets>all</PrivateAssets>

From 9c91069a19bf88819e2049e22596253aa46ccf5c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 10 Aug 2022 01:30:23 +0300
Subject: [PATCH 393/455] Bump Microsoft.AspNetCore.Mvc.Testing from 6.0.7 to
 6.0.8 (#436)

Bumps [Microsoft.AspNetCore.Mvc.Testing](https://github.com/dotnet/aspnetcore) from 6.0.7 to 6.0.8.
- [Release notes](https://github.com/dotnet/aspnetcore/releases)
- [Changelog](https://github.com/dotnet/aspnetcore/blob/main/docs/ReleasePlanning.md)
- [Commits](https://github.com/dotnet/aspnetcore/compare/v6.0.7...v6.0.8)

---
updated-dependencies:
- dependency-name: Microsoft.AspNetCore.Mvc.Testing
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 1377f01a..46a82161 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.7" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.8" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 

From 9da003ca3f61a13d99bd1adfe14e37f611af3728 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 11 Aug 2022 01:31:39 +0300
Subject: [PATCH 394/455] Bump Microsoft.NET.Test.Sdk from 17.2.0 to 17.3.0
 (#437)

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.2.0 to 17.3.0.
- [Release notes](https://github.com/microsoft/vstest/releases)
- [Commits](https://github.com/microsoft/vstest/compare/v17.2.0...v17.3.0)

---
updated-dependencies:
- dependency-name: Microsoft.NET.Test.Sdk
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 10dc01bc..d0969963 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.0" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.1.2">

From b8892de01e3dad7b44c4b3f5120b8fa2b89df945 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Mon, 22 Aug 2022 08:44:31 +0300
Subject: [PATCH 395/455] Migrate to GraphQL.NET v7 (#447)

---
 .../GraphQL.Client.LocalExecution.csproj      |  4 ++--
 .../GraphQLLocalExecutionClient.cs            |  2 +-
 src/GraphQL.Primitives/GraphQLError.cs        |  2 +-
 .../BaseSerializeNoCamelCaseTest.cs           |  1 -
 .../GraphQL.Client.Serializer.Tests.csproj    |  4 ++--
 .../NewtonsoftSerializerTest.cs               | 13 ++++++++++--
 .../SystemTextJsonSerializerTests.cs          | 13 ++++++++++--
 .../Chat/Schema/CapitalizedFieldsGraphType.cs |  3 +--
 .../Chat/Schema/ChatMutation.cs               | 16 ++++++--------
 .../Chat/Schema/ChatQuery.cs                  | 11 +++++-----
 .../Chat/Schema/ChatSubscriptions.cs          |  8 ++-----
 .../GraphQL.Client.Tests.Common.csproj        |  2 +-
 .../StarWars/StarWarsMutation.cs              |  9 +++-----
 .../StarWars/StarWarsQuery.cs                 | 21 +++++++------------
 .../StarWars/Types/CharacterInterface.cs      |  6 +++---
 .../StarWars/Types/DroidType.cs               | 10 ++++-----
 .../StarWars/Types/HumanType.cs               | 10 ++++-----
 .../Properties/launchSettings.json            | 16 +++++++-------
 .../GraphQL.Server.Test.csproj                |  7 +++----
 .../GraphQL.Server.Test/GraphQL/TestQuery.cs  |  5 ++++-
 tests/GraphQL.Server.Test/Startup.cs          |  8 +++----
 .../IntegrationTestServer.csproj              |  2 +-
 tests/IntegrationTestServer/Startup.cs        | 14 ++++---------
 23 files changed, 89 insertions(+), 98 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 6973829f..253f9283 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <Description>A GraphQL Client which executes the queries directly on a provided GraphQL schema using graphql-dotnet</Description>
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="5.0.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.0.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
index 15e4c3e3..0bd3a270 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
+++ b/src/GraphQL.Client.LocalExecution/GraphQLLocalExecutionClient.cs
@@ -9,7 +9,7 @@ public static class GraphQLLocalExecutionClient
 {
     public static GraphQLLocalExecutionClient<TSchema> New<TSchema>(TSchema schema, IGraphQLJsonSerializer clientSerializer, IGraphQLTextSerializer serverSerializer)
         where TSchema : ISchema
-        => new GraphQLLocalExecutionClient<TSchema>(schema, new DocumentExecuter(), clientSerializer, serverSerializer);
+        => new(schema, new DocumentExecuter(), clientSerializer, serverSerializer);
 }
 
 public class GraphQLLocalExecutionClient<TSchema> : IGraphQLClient where TSchema : ISchema
diff --git a/src/GraphQL.Primitives/GraphQLError.cs b/src/GraphQL.Primitives/GraphQLError.cs
index 29a94250..9732c4b6 100644
--- a/src/GraphQL.Primitives/GraphQLError.cs
+++ b/src/GraphQL.Primitives/GraphQLError.cs
@@ -27,7 +27,7 @@ public class GraphQLError : IEquatable<GraphQLError?>
 
     /// <summary>
     /// The extensions of the error
-    /// </summary> 
+    /// </summary>
     [DataMember(Name = "extensions")]
     public Map? Extensions { get; set; }
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index 9d97fea3..9dcabfd7 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -48,7 +48,6 @@ public void SerializeToBytesTest(string expectedJson, GraphQLWebSocketRequest re
     [Fact]
     public async void WorksWithoutCamelCaseNamingStrategy()
     {
-
         const string message = "some random testing message";
         var graphQLRequest = new GraphQLRequest(
             @"mutation($input: MessageInputType){
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 2e15b077..346b7790 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="5.3.3" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="5.3.3" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.0.0" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
index 42e392c4..a359e372 100644
--- a/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/NewtonsoftSerializerTest.cs
@@ -1,4 +1,5 @@
 using GraphQL.Client.Serializer.Newtonsoft;
+using GraphQL.Execution;
 using Newtonsoft.Json;
 
 namespace GraphQL.Client.Serializer.Tests;
@@ -6,11 +7,19 @@ namespace GraphQL.Client.Serializer.Tests;
 public class NewtonsoftSerializerTest : BaseSerializerTest
 {
     public NewtonsoftSerializerTest()
-        : base(new NewtonsoftJsonSerializer(), new NewtonsoftJson.GraphQLSerializer()) { }
+        : base(
+            new NewtonsoftJsonSerializer(),
+            new NewtonsoftJson.GraphQLSerializer(new ErrorInfoProvider(opt => opt.ExposeData = true)))
+    {
+    }
 }
 
 public class NewtonsoftSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
 {
     public NewtonsoftSerializeNoCamelCaseTest()
-        : base(new NewtonsoftJsonSerializer(new JsonSerializerSettings { Converters = { new ConstantCaseEnumConverter() } }), new NewtonsoftJson.GraphQLSerializer()) { }
+        : base(
+            new NewtonsoftJsonSerializer(new JsonSerializerSettings { Converters = { new ConstantCaseEnumConverter() } }),
+            new NewtonsoftJson.GraphQLSerializer(new ErrorInfoProvider(opt => opt.ExposeData = true)))
+    {
+    }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index bece29bd..38ebc2a1 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -1,17 +1,26 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using GraphQL.Client.Serializer.SystemTextJson;
+using GraphQL.Execution;
 
 namespace GraphQL.Client.Serializer.Tests;
 
 public class SystemTextJsonSerializerTests : BaseSerializerTest
 {
     public SystemTextJsonSerializerTests()
-        : base(new SystemTextJsonSerializer(), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
+        : base(
+            new SystemTextJsonSerializer(),
+            new GraphQL.SystemTextJson.GraphQLSerializer(new ErrorInfoProvider(opt => opt.ExposeData = true)))
+    {
+    }
 }
 
 public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTest
 {
     public SystemTextJsonSerializeNoCamelCaseTest()
-        : base(new SystemTextJsonSerializer(new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter()), new GraphQL.SystemTextJson.GraphQLSerializer()) { }
+        : base(
+            new SystemTextJsonSerializer(new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter()),
+            new GraphQL.SystemTextJson.GraphQLSerializer(new ErrorInfoProvider(opt => opt.ExposeData = true)))
+    {
+    }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
index a1f185fb..c10a77b6 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/CapitalizedFieldsGraphType.cs
@@ -8,8 +8,7 @@ public CapitalizedFieldsGraphType()
     {
         Name = "CapitalizedFields";
 
-        Field<StringGraphType>()
-            .Name("StringField")
+        Field<StringGraphType>("StringField")
             .Resolve(context => "hello world");
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
index 788eaaba..70a2a863 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatMutation.cs
@@ -6,22 +6,18 @@ public class ChatMutation : ObjectGraphType<object>
 {
     public ChatMutation(IChat chat)
     {
-        Field<MessageType>("addMessage",
-            arguments: new QueryArguments(
-                new QueryArgument<MessageInputType> { Name = "message" }
-            ),
-            resolve: context =>
+        Field<MessageType>("addMessage")
+            .Argument<MessageInputType>("message")
+            .Resolve(context =>
             {
                 var receivedMessage = context.GetArgument<ReceivedMessage>("message");
                 var message = chat.AddMessage(receivedMessage);
                 return message;
             });
 
-        Field<MessageFromType>("join",
-            arguments: new QueryArguments(
-                new QueryArgument<StringGraphType> { Name = "userId" }
-            ),
-            resolve: context =>
+        Field<MessageFromType>("join")
+            .Argument<StringGraphType>("userId")
+            .Resolve(context =>
             {
                 var userId = context.GetArgument<string>("userId");
                 var userJoined = chat.Join(userId);
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 854a4a75..61bf6055 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -4,7 +4,8 @@ namespace GraphQL.Client.Tests.Common.Chat.Schema;
 
 public class ChatQuery : ObjectGraphType
 {
-    public static readonly Dictionary<string, object> TestExtensions = new Dictionary<string, object> {
+    public static readonly Dictionary<string, object> TestExtensions = new()
+    {
         {"extension1", "hello world"},
         {"another extension", 4711},
         {"long", 19942590700}
@@ -19,18 +20,16 @@ public ChatQuery(IChat chat)
     {
         Name = "ChatQuery";
 
-        Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+        Field<ListGraphType<MessageType>>("messages").Resolve(context => chat.AllMessages.Take(100));
 
-        Field<StringGraphType>()
-            .Name("extensionsTest")
+        Field<StringGraphType>("extensionsTest")
             .Resolve(context =>
             {
                 context.Errors.Add(new ExecutionError("this error contains extension fields", TestExtensions));
                 return null;
             });
 
-        Field<StringGraphType>()
-            .Name("longRunning")
+        Field<StringGraphType>("longRunning")
             .Resolve(context =>
             {
                 WaitingOnQueryBlocker.Set();
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
index 3a4f62e1..0653205d 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatSubscriptions.cs
@@ -1,7 +1,5 @@
 using System.Reactive.Linq;
-using System.Security.Claims;
 using GraphQL.Resolvers;
-using GraphQL.Server.Transports.Subscriptions.Abstractions;
 using GraphQL.Types;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema;
@@ -60,8 +58,7 @@ public ChatSubscriptions(IChat chat)
 
     private IObservable<Message> SubscribeById(IResolveFieldContext context)
     {
-        var messageContext = (MessageHandlingContext)context.UserContext;
-        var user = messageContext.Get<ClaimsPrincipal>("user");
+        var user = context.User;
 
         var sub = "Anonymous";
         if (user != null)
@@ -82,8 +79,7 @@ private Message ResolveMessage(IResolveFieldContext context)
 
     private IObservable<Message> Subscribe(IResolveFieldContext context)
     {
-        var messageContext = (MessageHandlingContext)context.UserContext;
-        var user = messageContext.Get<ClaimsPrincipal>("user");
+        var user = context.User;
 
         var sub = "Anonymous";
         if (user != null)
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 1b285443..d91097a6 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.Abstractions" Version="6.0.0" />
+    <PackageReference Include="GraphQL" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
index 161b25dd..3d57d1fe 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsMutation.cs
@@ -21,12 +21,9 @@ public StarWarsMutation(StarWarsData data)
     {
         Name = "Mutation";
 
-        Field<HumanType>(
-            "createHuman",
-            arguments: new QueryArguments(
-                new QueryArgument<NonNullGraphType<HumanInputType>> { Name = "human" }
-            ),
-            resolve: context =>
+        Field<HumanType>("createHuman")
+            .Argument<NonNullGraphType<HumanInputType>>("human")
+            .Resolve(context =>
             {
                 var human = context.GetArgument<Human>("human");
                 return data.AddCharacter(human);
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
index a3fb05e9..1fb231b9 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/StarWarsQuery.cs
@@ -9,23 +9,16 @@ public StarWarsQuery(StarWarsData data)
     {
         Name = "Query";
 
-        FieldAsync<CharacterInterface>("hero", resolve: async context => await data.GetDroidByIdAsync("3"));
-        FieldAsync<HumanType>(
-            "human",
-            arguments: new QueryArguments(
-                new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the human" }
-            ),
-            resolve: async context => await data.GetHumanByIdAsync(context.GetArgument<string>("id"))
+        Field<CharacterInterface>("hero").ResolveAsync(async context => await data.GetDroidByIdAsync("3"));
+        Field<HumanType>("human")
+            .Argument<NonNullGraphType<StringGraphType>>("id", "id of the human")
+            .ResolveAsync(async context => await data.GetHumanByIdAsync(context.GetArgument<string>("id"))
         );
 
         Func<IResolveFieldContext, string, Task<Droid>> func = (context, id) => data.GetDroidByIdAsync(id);
 
-        FieldDelegate<DroidType>(
-            "droid",
-            arguments: new QueryArguments(
-                new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "id", Description = "id of the droid" }
-            ),
-            resolve: func
-        );
+        Field<DroidType>("droid")
+            .Argument<NonNullGraphType<StringGraphType>>("id", "id of the droid")
+            .ResolveDelegate(func);
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
index 1e3809dc..a25daec3 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
@@ -9,11 +9,11 @@ public CharacterInterface()
     {
         Name = "Character";
 
-        Field<NonNullGraphType<StringGraphType>>("id", "The id of the character.", resolve: context => context.Source.Id);
-        Field<StringGraphType>("name", "The name of the character.", resolve: context => context.Source.Name);
+        Field<NonNullGraphType<StringGraphType>>("id").Description("The id of the character.").Resolve(context => context.Source.Id);
+        Field<StringGraphType>("name").Description("The name of the character.").Resolve(context => context.Source.Name);
 
         Field<ListGraphType<CharacterInterface>>("friends");
         Field<ConnectionType<CharacterInterface, EdgeType<CharacterInterface>>>("friendsConnection");
-        Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
+        Field<ListGraphType<EpisodeEnum>>("appearsIn").Description("Which movie they appear in.");
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
index cc9e33c3..72680c43 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
@@ -10,10 +10,10 @@ public DroidType(StarWarsData data)
         Name = "Droid";
         Description = "A mechanical creature in the Star Wars universe.";
 
-        Field<NonNullGraphType<StringGraphType>>("id", "The id of the droid.", resolve: context => context.Source.Id);
-        Field<StringGraphType>("name", "The name of the droid.", resolve: context => context.Source.Name);
+        Field<NonNullGraphType<StringGraphType>>("id").Description("The id of the droid.").Resolve(context => context.Source.Id);
+        Field<StringGraphType>("name").Description("The name of the droid.").Resolve(context => context.Source.Name);
 
-        Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
+        Field<ListGraphType<CharacterInterface>>("friends").Resolve(context => data.GetFriends(context.Source));
 
         Connection<CharacterInterface>()
             .Name("friendsConnection")
@@ -21,8 +21,8 @@ public DroidType(StarWarsData data)
             .Bidirectional()
             .Resolve(context => context.GetPagedResults<Droid, StarWarsCharacter>(data, context.Source.Friends));
 
-        Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
-        Field<StringGraphType>("primaryFunction", "The primary function of the droid.", resolve: context => context.Source.PrimaryFunction);
+        Field<ListGraphType<EpisodeEnum>>("appearsIn").Description("Which movie they appear in.");
+        Field<StringGraphType>("primaryFunction").Description("The primary function of the droid.").Resolve(context => context.Source.PrimaryFunction);
 
         Interface<CharacterInterface>();
     }
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
index 552aabdd..a95e01d0 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
@@ -9,10 +9,10 @@ public HumanType(StarWarsData data)
     {
         Name = "Human";
 
-        Field<NonNullGraphType<StringGraphType>>("id", "The id of the human.", resolve: context => context.Source.Id);
-        Field<StringGraphType>("name", "The name of the human.", resolve: context => context.Source.Name);
+        Field<NonNullGraphType<StringGraphType>>("id").Description("The id of the human.").Resolve(context => context.Source.Id);
+        Field<StringGraphType>("name").Description("The name of the human.").Resolve(context => context.Source.Name);
 
-        Field<ListGraphType<CharacterInterface>>("friends", resolve: context => data.GetFriends(context.Source));
+        Field<ListGraphType<CharacterInterface>>("friends").Resolve(context => data.GetFriends(context.Source));
 
         Connection<CharacterInterface>()
             .Name("friendsConnection")
@@ -20,9 +20,9 @@ public HumanType(StarWarsData data)
             .Bidirectional()
             .Resolve(context => context.GetPagedResults<Human, StarWarsCharacter>(data, context.Source.Friends));
 
-        Field<ListGraphType<EpisodeEnum>>("appearsIn", "Which movie they appear in.");
+        Field<ListGraphType<EpisodeEnum>>("appearsIn").Description("Which movie they appear in.");
 
-        Field<StringGraphType>("homePlanet", "The home planet of the human.", resolve: context => context.Source.HomePlanet);
+        Field<StringGraphType>("homePlanet").Description("The home planet of the human.").Resolve(context => context.Source.HomePlanet);
 
         Interface<CharacterInterface>();
     }
diff --git a/tests/GraphQL.Integration.Tests/Properties/launchSettings.json b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
index f8fea71b..3340b96e 100644
--- a/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
+++ b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
@@ -1,12 +1,4 @@
 {
-  "iisSettings": {
-    "windowsAuthentication": false,
-    "anonymousAuthentication": true,
-    "iisExpress": {
-      "applicationUrl": "http://localhost:51432/",
-      "sslPort": 0
-    }
-  },
   "profiles": {
     "IIS Express": {
       "commandName": "IISExpress",
@@ -23,5 +15,13 @@
       },
       "applicationUrl": "http://localhost:51433/"
     }
+  },
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:55273/",
+      "sslPort": 44359
+    }
   }
 }
\ No newline at end of file
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index ac59ef1a..ba748f78 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,10 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="5.0.0" />
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="6.1.0" />
-    <PackageReference Include="GraphQL.Server.Transports.Subscriptions.WebSockets" Version="6.1.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="6.1.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.0.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.0.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.0.0" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
index 31bbef6e..4e225a23 100644
--- a/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
+++ b/tests/GraphQL.Server.Test/GraphQL/TestQuery.cs
@@ -7,7 +7,10 @@ public class TestQuery : ObjectGraphType
 {
     public TestQuery()
     {
-        Field<RepositoryGraphType>("repository", arguments: new QueryArguments(new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "owner" }, new QueryArgument<NonNullGraphType<StringGraphType>> { Name = "name" }), resolve: context =>
+        Field<RepositoryGraphType>("repository")
+            .Argument<NonNullGraphType<StringGraphType>>("owner")
+            .Argument<NonNullGraphType<StringGraphType>>("name")
+            .Resolve(context =>
         {
             var owner = context.GetArgument<string>("owner");
             var name = context.GetArgument<string>("name");
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index 25e1e9d5..4dd737c5 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -16,18 +16,16 @@ public void Configure(IApplicationBuilder app)
         app.UseHttpsRedirection();
 
         app.UseWebSockets();
-        app.UseGraphQLWebSockets<TestSchema>();
         app.UseGraphQL<TestSchema>();
-        app.UseGraphQLGraphiQL(new GraphiQLOptions { });
+        app.UseGraphQLGraphiQL();
     }
 
     public void ConfigureServices(IServiceCollection services)
     {
         services.AddGraphQL(builder => builder
             .AddSchema<TestSchema>()
-            .AddApolloTracing(enableMetrics: true)
-            .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = true)
-            .AddWebSockets()
+            .UseApolloTracing(enableMetrics: true)
+            .AddErrorInfoProvider(opt => opt.ExposeExceptionDetails = true)
         );
     }
 }
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 4bda2103..4bd1a79b 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.All" Version="6.1.0" />
+    <PackageReference Include="GraphQL.Server.All" Version="7.0.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
     <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
   </ItemGroup>
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 4876fdb3..65ba8a99 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -33,20 +33,15 @@ public void ConfigureServices(IServiceCollection services)
         services.AddChatSchema();
         services.AddStarWarsSchema();
         services.AddGraphQL(builder => builder
-            .AddApolloTracing(enableMetrics: true)
-            .AddHttpMiddleware<ChatSchema>()
-            .AddHttpMiddleware<StarWarsSchema>()
-            .AddWebSocketsHttpMiddleware<ChatSchema>()
-            .AddWebSocketsHttpMiddleware<StarWarsSchema>()
+            .UseApolloTracing(enableMetrics: true)
             .ConfigureExecutionOptions(opt => opt.UnhandledExceptionDelegate = ctx =>
             {
                 var logger = ctx.Context.RequestServices.GetRequiredService<ILogger<Startup>>();
                 logger.LogError("{Error} occurred", ctx.OriginalException.Message);
                 return System.Threading.Tasks.Task.CompletedTask;
             })
-            .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = Environment.IsDevelopment())
+            .AddErrorInfoProvider(opt => opt.ExposeExceptionDetails = Environment.IsDevelopment())
             .AddSystemTextJson()
-            .AddWebSockets()
             .AddGraphTypes(typeof(ChatSchema).Assembly));
     }
 
@@ -63,13 +58,12 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
         ConfigureGraphQLSchema<ChatSchema>(app, Common.CHAT_ENDPOINT);
         ConfigureGraphQLSchema<StarWarsSchema>(app, Common.STAR_WARS_ENDPOINT);
 
-        app.UseGraphQLGraphiQL(new GraphiQLOptions { GraphQLEndPoint = Common.STAR_WARS_ENDPOINT });
-        app.UseGraphQLAltair(new AltairOptions { GraphQLEndPoint = Common.CHAT_ENDPOINT });
+        app.UseGraphQLGraphiQL(options: new GraphiQLOptions { GraphQLEndPoint = Common.STAR_WARS_ENDPOINT });
+        app.UseGraphQLAltair(options: new AltairOptions { GraphQLEndPoint = Common.CHAT_ENDPOINT });
     }
 
     private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema : Schema
     {
-        app.UseGraphQLWebSockets<TSchema>(endpoint);
         app.UseGraphQL<TSchema>(endpoint);
     }
 }

From 444c0b9cf0b94db0ad913771e34e6437157ce9be Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 22 Aug 2022 10:30:54 +0300
Subject: [PATCH 396/455] Bump Microsoft.NETFramework.ReferenceAssemblies from
 1.0.2 to 1.0.3 (#448)

Bumps [Microsoft.NETFramework.ReferenceAssemblies](https://github.com/Microsoft/dotnet) from 1.0.2 to 1.0.3.
- [Release notes](https://github.com/Microsoft/dotnet/releases)
- [Commits](https://github.com/Microsoft/dotnet/commits)

---
updated-dependencies:
- dependency-name: Microsoft.NETFramework.ReferenceAssemblies
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 src/GraphQL.Client/GraphQL.Client.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 719c1a76..35dc2e16 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -14,7 +14,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.2" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="All" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 

From 99e1648bf34e62fa0459df0d652b6f1cb7980c56 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 4 Sep 2022 21:21:22 +0300
Subject: [PATCH 397/455] Bump Microsoft.NET.Test.Sdk from 17.3.0 to 17.3.1
 (#457)

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.3.0 to 17.3.1.
- [Release notes](https://github.com/microsoft/vstest/releases)
- [Commits](https://github.com/microsoft/vstest/compare/v17.3.0...v17.3.1)

---
updated-dependencies:
- dependency-name: Microsoft.NET.Test.Sdk
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index d0969963..60859ea2 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.1" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.1.2">

From 5cb94ca2edf6a799f1b55849dbc478ac38478dee Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Mon, 19 Sep 2022 17:16:09 +0300
Subject: [PATCH 398/455] Change media type to
 application/graphql-response+json (#459)

---
 src/GraphQL.Client/GraphQLHttpRequest.cs                      | 2 +-
 tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 2da60705..c68379c1 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -39,7 +39,7 @@ public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions
         {
             Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
         };
-        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql+json"));
+        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql-response+json"));
         message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
         message.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
 
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index abcdc644..bff54832 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -176,7 +176,7 @@ public async void PreprocessHttpRequestMessageIsCalled()
 
         var expectedHeaders = new HttpRequestMessage().Headers;
         expectedHeaders.UserAgent.Add(new ProductInfoHeaderValue("GraphQL.Client", typeof(GraphQLHttpClient).Assembly.GetName().Version.ToString()));
-        expectedHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql+json"));
+        expectedHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql-response+json"));
         expectedHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
         expectedHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
         var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });

From 6970825f79b9507a422df6b87b5709cb0eed2f09 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 19 Sep 2022 18:12:08 +0300
Subject: [PATCH 399/455] Bump GraphQL.Server.All from 7.0.0 to 7.1.1 (#461)

Bumps [GraphQL.Server.All](https://github.com/graphql-dotnet/server) from 7.0.0 to 7.1.1.
- [Release notes](https://github.com/graphql-dotnet/server/releases)
- [Commits](https://github.com/graphql-dotnet/server/compare/7.0.0...7.1.1)

---
updated-dependencies:
- dependency-name: GraphQL.Server.All
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/IntegrationTestServer/IntegrationTestServer.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 4bd1a79b..3098ce66 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.All" Version="7.0.0" />
+    <PackageReference Include="GraphQL.Server.All" Version="7.1.1" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
     <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
   </ItemGroup>

From b95fa5c5571cb512b0e160780277dd14bac9ea3f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Sep 2022 02:43:16 +0300
Subject: [PATCH 400/455] Bump GraphQL.NewtonsoftJson from 7.0.0 to 7.1.1
 (#470)

Bumps [GraphQL.NewtonsoftJson](https://github.com/graphql-dotnet/graphql-dotnet) from 7.0.0 to 7.1.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.0.0...7.1.1)

---
updated-dependencies:
- dependency-name: GraphQL.NewtonsoftJson
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 346b7790..c7ed5465 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.0.0" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.1.1" />
     <PackageReference Include="GraphQL.SystemTextJson" Version="7.0.0" />
   </ItemGroup>
 

From e36f1d8f1212dd31f10da5dc549f5096696796b2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Sep 2022 02:45:54 +0300
Subject: [PATCH 401/455] Bump GraphQL.SystemTextJson from 7.0.0 to 7.1.1
 (#469)

Bumps [GraphQL.SystemTextJson](https://github.com/graphql-dotnet/graphql-dotnet) from 7.0.0 to 7.1.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.0.0...7.1.1)

---
updated-dependencies:
- dependency-name: GraphQL.SystemTextJson
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index c7ed5465..a3ddb485 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.1.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.0.0" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.1.1" />
   </ItemGroup>
 
   <ItemGroup>

From ff71edae518fb4715ae4ebdd5fac4e101e1cec43 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Sep 2022 02:47:38 +0300
Subject: [PATCH 402/455] Bump GraphQL.Server.Ui.GraphiQL from 7.0.0 to 7.1.1
 (#472)

Bumps [GraphQL.Server.Ui.GraphiQL](https://github.com/graphql-dotnet/server) from 7.0.0 to 7.1.1.
- [Release notes](https://github.com/graphql-dotnet/server/releases)
- [Commits](https://github.com/graphql-dotnet/server/compare/7.0.0...7.1.1)

---
updated-dependencies:
- dependency-name: GraphQL.Server.Ui.GraphiQL
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index ba748f78..a14933c0 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -8,7 +8,7 @@
   <ItemGroup>
     <PackageReference Include="GraphQL.MicrosoftDI" Version="7.0.0" />
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.0.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.0.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.1.1" />
   </ItemGroup>
 
 </Project>

From 8046a9e2cbc972350ddb2c375ab69dc024c591e9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Sep 2022 02:47:59 +0300
Subject: [PATCH 403/455] Bump Microsoft.AspNetCore.Mvc.Testing from 6.0.8 to
 6.0.9 (#473)

Bumps [Microsoft.AspNetCore.Mvc.Testing](https://github.com/dotnet/aspnetcore) from 6.0.8 to 6.0.9.
- [Release notes](https://github.com/dotnet/aspnetcore/releases)
- [Changelog](https://github.com/dotnet/aspnetcore/blob/main/docs/ReleasePlanning.md)
- [Commits](https://github.com/dotnet/aspnetcore/compare/v6.0.8...v6.0.9)

---
updated-dependencies:
- dependency-name: Microsoft.AspNetCore.Mvc.Testing
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 46a82161..37e62240 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.8" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.9" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 

From 9693afde8e965fe9ff872f6fef0b8a2a57e8fc38 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Sep 2022 02:48:17 +0300
Subject: [PATCH 404/455] Bump GraphQL from 7.0.0 to 7.1.1 (#466)

Bumps [GraphQL](https://github.com/graphql-dotnet/graphql-dotnet) from 7.0.0 to 7.1.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.0.0...7.1.1)

---
updated-dependencies:
- dependency-name: GraphQL
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index d91097a6..de4ef937 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.0.0" />
+    <PackageReference Include="GraphQL" Version="7.1.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
   </ItemGroup>
 

From 8b970436a05c7670e5bb887128f19c7adb610fad Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 Sep 2022 02:55:46 +0300
Subject: [PATCH 405/455] Bump GraphQL.Server.Transports.AspNetCore from 7.0.0
 to 7.1.1 (#467)

* Bump GraphQL.Server.Transports.AspNetCore from 7.0.0 to 7.1.1

Bumps [GraphQL.Server.Transports.AspNetCore](https://github.com/graphql-dotnet/server) from 7.0.0 to 7.1.1.
- [Release notes](https://github.com/graphql-dotnet/server/releases)
- [Commits](https://github.com/graphql-dotnet/server/compare/7.0.0...7.1.1)

---
updated-dependencies:
- dependency-name: GraphQL.Server.Transports.AspNetCore
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Update tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Ivan Maximov <sungam3r@yandex.ru>
---
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index a14933c0..20b2fdb0 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,8 +6,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.0.0" />
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.0.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.1.1" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.1.1" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.1.1" />
   </ItemGroup>
 

From 7a2a621781bf46c3dacd471e801f4915481325a1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 5 Oct 2022 22:07:32 +0300
Subject: [PATCH 406/455] Bump actions/setup-dotnet from 2 to 3 (#476)

Bumps [actions/setup-dotnet](https://github.com/actions/setup-dotnet) from 2 to 3.
- [Release notes](https://github.com/actions/setup-dotnet/releases)
- [Commits](https://github.com/actions/setup-dotnet/compare/v2...v3)

---
updated-dependencies:
- dependency-name: actions/setup-dotnet
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/branches.yml | 2 +-
 .github/workflows/master.yml   | 2 +-
 .github/workflows/publish.yml  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 3807f0a0..c4e92d0d 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -22,7 +22,7 @@ jobs:
       with:
         fetch-depth: 0
     - name: Setup .NET Core SDK
-      uses: actions/setup-dotnet@v2
+      uses: actions/setup-dotnet@v3
       with:
         dotnet-version: | 
           6.0.x
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 31cc1f10..db8264ec 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -21,7 +21,7 @@ jobs:
       with:
         fetch-depth: 0
     - name: Setup .NET Core SDK
-      uses: actions/setup-dotnet@v2
+      uses: actions/setup-dotnet@v3
       with:
         dotnet-version: "6.0.x"
         source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index ddff922e..98a85b0c 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -25,7 +25,7 @@ jobs:
         echo github.ref: ${{ github.ref }}
         exit 1
     - name: Setup .NET Core SDK
-      uses: actions/setup-dotnet@v2
+      uses: actions/setup-dotnet@v3
       with:
         dotnet-version: "6.0.x"
         source-url: https://api.nuget.org/v3/index.json

From 126f120712d66522c6941e5c41e809a07d8ed814 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 5 Oct 2022 22:10:30 +0300
Subject: [PATCH 407/455] Bump Microsoft.NET.Test.Sdk from 17.3.1 to 17.3.2
 (#474)

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.3.1 to 17.3.2.
- [Release notes](https://github.com/microsoft/vstest/releases)
- [Commits](https://github.com/microsoft/vstest/compare/v17.3.1...v17.3.2)

---
updated-dependencies:
- dependency-name: Microsoft.NET.Test.Sdk
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 60859ea2..1e07f81c 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.1.2">

From 6cb1408346ce659c64612aa8fd567bccaa17e904 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 31 Oct 2022 21:53:29 +0300
Subject: [PATCH 408/455] Bump coverlet.collector from 3.1.2 to 3.2.0 (#482)

Bumps [coverlet.collector](https://github.com/coverlet-coverage/coverlet) from 3.1.2 to 3.2.0.
- [Release notes](https://github.com/coverlet-coverage/coverlet/releases)
- [Commits](https://github.com/coverlet-coverage/coverlet/commits/v3.2.0)

---
updated-dependencies:
- dependency-name: coverlet.collector
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 1e07f81c..26e1310b 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -10,7 +10,7 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
-    <PackageReference Include="coverlet.collector" Version="3.1.2">
+    <PackageReference Include="coverlet.collector" Version="3.2.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime;build;native;contentfiles;analyzers;buildtransitive</IncludeAssets>
     </PackageReference>

From a1d4e0bcc93001d5966922663a7e60777af27678 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 3 Nov 2022 10:55:49 +0300
Subject: [PATCH 409/455] Bump Microsoft.Extensions.DependencyInjection from
 6.0.0 to 6.0.1 (#478)

Bumps [Microsoft.Extensions.DependencyInjection](https://github.com/dotnet/runtime) from 6.0.0 to 6.0.1.
- [Release notes](https://github.com/dotnet/runtime/releases)
- [Commits](https://github.com/dotnet/runtime/compare/v6.0.0...v6.0.1)

---
updated-dependencies:
- dependency-name: Microsoft.Extensions.DependencyInjection
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index de4ef937..c8224fbf 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -8,7 +8,7 @@
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
     <PackageReference Include="GraphQL" Version="7.1.1" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.1" />
   </ItemGroup>
 
   <ItemGroup>

From a611eb590ca06cd4f0950793d6fd2349e4b80181 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 3 Nov 2022 10:56:08 +0300
Subject: [PATCH 410/455] Bump Microsoft.AspNetCore.Mvc.Testing from 6.0.9 to
 6.0.10 (#479)

Bumps [Microsoft.AspNetCore.Mvc.Testing](https://github.com/dotnet/aspnetcore) from 6.0.9 to 6.0.10.
- [Release notes](https://github.com/dotnet/aspnetcore/releases)
- [Changelog](https://github.com/dotnet/aspnetcore/blob/main/docs/ReleasePlanning.md)
- [Commits](https://github.com/dotnet/aspnetcore/compare/v6.0.9...v6.0.10)

---
updated-dependencies:
- dependency-name: Microsoft.AspNetCore.Mvc.Testing
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 37e62240..cb2e12d0 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.9" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.10" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 

From 1bbbb18bf657e4ae80a9af7a402f0b6dc5c287e9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 9 Nov 2022 03:20:08 +0300
Subject: [PATCH 411/455] Bump Microsoft.NET.Test.Sdk from 17.3.2 to 17.4.0
 (#488)

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.3.2 to 17.4.0.
- [Release notes](https://github.com/microsoft/vstest/releases)
- [Commits](https://github.com/microsoft/vstest/compare/v17.3.2...v17.4.0)

---
updated-dependencies:
- dependency-name: Microsoft.NET.Test.Sdk
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 26e1310b..6d3c5916 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.2.0">

From accbc050171e2b7f87b737ab7c81ecfddb38ef65 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 25 Nov 2022 18:51:26 +0300
Subject: [PATCH 412/455] Bump Newtonsoft.Json from 13.0.1 to 13.0.2 (#490)

Bumps [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json) from 13.0.1 to 13.0.2.
- [Release notes](https://github.com/JamesNK/Newtonsoft.Json/releases)
- [Commits](https://github.com/JamesNK/Newtonsoft.Json/compare/13.0.1...13.0.2)

---
updated-dependencies:
- dependency-name: Newtonsoft.Json
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Newtonsoft.csproj                 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index 65aef0d0..a3c9700a 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
   </ItemGroup>
 
   <ItemGroup>

From 3598bf1e4032ea06cf4fe5d42348d13db88765b8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Dec 2022 20:16:07 +0300
Subject: [PATCH 413/455] Bump GraphQL from 7.1.1 to 7.2.0 (#495)

Bumps [GraphQL](https://github.com/graphql-dotnet/graphql-dotnet) from 7.1.1 to 7.2.0.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.1.1...7.2.0)

---
updated-dependencies:
- dependency-name: GraphQL
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index c8224fbf..7f1ca7b5 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.1.1" />
+    <PackageReference Include="GraphQL" Version="7.2.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.1" />
   </ItemGroup>
 

From 0fa1326806ea930cfa5a5c3c80d87a08c776fa9f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Dec 2022 01:17:23 +0300
Subject: [PATCH 414/455] Bump GraphQL from 7.2.0 to 7.2.1 (#498)

Bumps [GraphQL](https://github.com/graphql-dotnet/graphql-dotnet) from 7.2.0 to 7.2.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.2.0...7.2.1)

---
updated-dependencies:
- dependency-name: GraphQL
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 7f1ca7b5..c907109f 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.2.0" />
+    <PackageReference Include="GraphQL" Version="7.2.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.1" />
   </ItemGroup>
 

From 8dc771b1abe9c3c6fa7bfd88255bb3342d735e42 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 9 Dec 2022 01:46:36 +0300
Subject: [PATCH 415/455] Bump Microsoft.Extensions.DependencyInjection from
 6.0.1 to 7.0.0 (#489)

Bumps [Microsoft.Extensions.DependencyInjection](https://github.com/dotnet/runtime) from 6.0.1 to 7.0.0.
- [Release notes](https://github.com/dotnet/runtime/releases)
- [Commits](https://github.com/dotnet/runtime/commits)

---
updated-dependencies:
- dependency-name: Microsoft.Extensions.DependencyInjection
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index c907109f..d2ec70dc 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -8,7 +8,7 @@
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
     <PackageReference Include="GraphQL" Version="7.2.1" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
   </ItemGroup>
 
   <ItemGroup>

From c1610d9d34550b447fe11b2d9dca806ba86d9e13 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Jan 2023 02:21:21 +0300
Subject: [PATCH 416/455] Bump GraphQL from 7.2.1 to 7.2.2 (#510)

Bumps [GraphQL](https://github.com/graphql-dotnet/graphql-dotnet) from 7.2.1 to 7.2.2.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.2.1...7.2.2)

---
updated-dependencies:
- dependency-name: GraphQL
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index d2ec70dc..0115cf36 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.2.1" />
+    <PackageReference Include="GraphQL" Version="7.2.2" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
   </ItemGroup>
 

From 659b1b65b992ca8434ad0e341576bf66379d76db Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Jan 2023 02:25:49 +0300
Subject: [PATCH 417/455] Bump GraphQL.SystemTextJson from 7.1.1 to 7.2.2
 (#511)

Bumps [GraphQL.SystemTextJson](https://github.com/graphql-dotnet/graphql-dotnet) from 7.1.1 to 7.2.2.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.1.1...7.2.2)

---
updated-dependencies:
- dependency-name: GraphQL.SystemTextJson
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index a3ddb485..b81837c9 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.1.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.1.1" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.2.2" />
   </ItemGroup>
 
   <ItemGroup>

From 1f96b7e6bcee9fdfb73b7e59e4f427e6ad986eeb Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sun, 2 Apr 2023 10:16:53 +0300
Subject: [PATCH 418/455] .NET 7 (#528)

---
 .github/workflows/branches.yml                              | 6 +++---
 .github/workflows/master.yml                                | 4 ++--
 .github/workflows/publish.yml                               | 4 ++--
 .../GraphQL.Client.Example/GraphQL.Client.Example.csproj    | 2 +-
 .../GraphQL.Client.Serializer.Tests.csproj                  | 2 +-
 .../GraphQL.Integration.Tests.csproj                        | 2 +-
 .../GraphQL.Primitives.Tests.csproj                         | 2 +-
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj        | 2 +-
 tests/IntegrationTestServer/IntegrationTestServer.csproj    | 2 +-
 9 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index c4e92d0d..494f1c75 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -21,11 +21,11 @@ jobs:
       uses: actions/checkout@v3
       with:
         fetch-depth: 0
-    - name: Setup .NET Core SDK
+    - name: Setup .NET SDK
       uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: | 
-          6.0.x
+        dotnet-version: |
+          7.0.x
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository including tags
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index db8264ec..3fc48c41 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -20,10 +20,10 @@ jobs:
       uses: actions/checkout@v3
       with:
         fetch-depth: 0
-    - name: Setup .NET Core SDK
+    - name: Setup .NET SDK
       uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: "6.0.x"
+        dotnet-version: "7.0.x"
         source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 98a85b0c..a7ebfb2e 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -24,10 +24,10 @@ jobs:
         echo Error! github.ref does not start with 'refs/tags'
         echo github.ref: ${{ github.ref }}
         exit 1
-    - name: Setup .NET Core SDK
+    - name: Setup .NET SDK
       uses: actions/setup-dotnet@v3
       with:
-        dotnet-version: "6.0.x"
+        dotnet-version: "7.0.x"
         source-url: https://api.nuget.org/v3/index.json
       env:
         NUGET_AUTH_TOKEN: ${{secrets.NUGET_API_KEY}}
diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index 046e466d..28c2c457 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6</TargetFramework>
+    <TargetFramework>net7</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index b81837c9..05d14939 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net6</TargetFramework>
+    <TargetFramework>net7</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index cb2e12d0..8dcc9e27 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net6</TargetFramework>
+    <TargetFramework>net7</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index ad5efd71..235c025a 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net6</TargetFramework>
+    <TargetFramework>net7</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 20b2fdb0..1d1d8ed3 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net6</TargetFramework>
+    <TargetFramework>net7</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 3098ce66..ac852617 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net6</TargetFramework>
+    <TargetFramework>net7</TargetFramework>
     <StartupObject>IntegrationTestServer.Program</StartupObject>
     <IsPackable>false</IsPackable>
   </PropertyGroup>

From 3967053fb13a51686d99dfe011fcd757084c0ed1 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sun, 2 Apr 2023 10:25:42 +0300
Subject: [PATCH 419/455] Update packages for tests (#529)

---
 Directory.Build.targets                                     | 6 +++---
 .../GraphQL.Client.Serializer.Tests.csproj                  | 4 ++--
 .../GraphQL.Client.Tests.Common.csproj                      | 2 +-
 .../GraphQL.Integration.Tests.csproj                        | 2 +-
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj        | 6 +++---
 tests/IntegrationTestServer/IntegrationTestServer.csproj    | 2 +-
 tests/tests.props                                           | 2 +-
 7 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Directory.Build.targets b/Directory.Build.targets
index af739e1d..a75e6500 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -30,9 +30,9 @@
   </PropertyGroup>
 
   <ItemGroup Condition="'$(IsPackable)' == 'true'">
-    <None Include="..\..\assets\logo.64x64.png" Pack="true" PackagePath="\" />
-    <None Include="..\..\README.md" Pack="true" PackagePath="\" />
-    <None Include="..\..\LICENSE.txt" Pack="true" PackagePath="\" />
+    <None Include="..\..\assets\logo.64x64.png" Pack="true" PackagePath="\" Visible="false" />
+    <None Include="..\..\README.md" Pack="true" PackagePath="\" Visible="false" />
+    <None Include="..\..\LICENSE.txt" Pack="true" PackagePath="\" Visible="false" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
     <PackageReference Update="GitVersionTask" Version="5.6.7">
       <PrivateAssets>all</PrivateAssets>
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 05d14939..baaf2c01 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.1.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.2.2" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.3.0" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.3.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 0115cf36..f8069a7b 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.2.2" />
+    <PackageReference Include="GraphQL" Version="7.3.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 8dcc9e27..2ede20bc 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.10" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="7.0.4" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 1d1d8ed3..901724ee 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.1.1" />
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.1.1" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.1.1" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.3.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.3.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.3.0" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index ac852617..d26b2adb 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.All" Version="7.1.1" />
+    <PackageReference Include="GraphQL.Server.All" Version="7.3.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
     <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
   </ItemGroup>
diff --git a/tests/tests.props b/tests/tests.props
index 6d3c5916..87ec1373 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.2.0">

From 4e0c885cf4db07d9bfd1f9c186f119d100a54668 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Apr 2023 21:36:43 +0300
Subject: [PATCH 420/455] Bump GraphQL from 7.3.0 to 7.3.1 (#535)

Bumps [GraphQL](https://github.com/graphql-dotnet/graphql-dotnet) from 7.3.0 to 7.3.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.3.0...7.3.1)

---
updated-dependencies:
- dependency-name: GraphQL
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index f8069a7b..9bfadf6b 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.3.0" />
+    <PackageReference Include="GraphQL" Version="7.3.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
   </ItemGroup>
 

From 3f79cd30a8bcecb208755aa7ccc20fb445b4eb2e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Apr 2023 21:37:26 +0300
Subject: [PATCH 421/455] Bump GraphQL.NewtonsoftJson from 7.3.0 to 7.3.1
 (#534)

Bumps [GraphQL.NewtonsoftJson](https://github.com/graphql-dotnet/graphql-dotnet) from 7.3.0 to 7.3.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.3.0...7.3.1)

---
updated-dependencies:
- dependency-name: GraphQL.NewtonsoftJson
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index baaf2c01..667638d3 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.3.0" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.3.1" />
     <PackageReference Include="GraphQL.SystemTextJson" Version="7.3.0" />
   </ItemGroup>
 

From ebc4b8205742d6c71cf92d1eae81d9aa48a83a62 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Apr 2023 21:39:49 +0300
Subject: [PATCH 422/455] Bump GraphQL.SystemTextJson from 7.3.0 to 7.3.1
 (#531)

Bumps [GraphQL.SystemTextJson](https://github.com/graphql-dotnet/graphql-dotnet) from 7.3.0 to 7.3.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.3.0...7.3.1)

---
updated-dependencies:
- dependency-name: GraphQL.SystemTextJson
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 667638d3..fac5bf23 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.3.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.3.0" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.3.1" />
   </ItemGroup>
 
   <ItemGroup>

From 06bf968ae7956fd4d58d79d3bb7abff1a4dd51e9 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Thu, 6 Apr 2023 18:13:18 +0300
Subject: [PATCH 423/455] Format repo with editorconfig (#530)

---
 .editorconfig                                 | 49 +++++++---
 .../PersonAndFilmsResponse.cs                 |  2 -
 examples/GraphQL.Client.Example/Program.cs    |  3 -
 .../Utilities/StringExtensions.cs             |  2 +-
 .../Utilities/StringUtils.cs                  |  2 +-
 .../NewtonsoftJsonSerializer.cs               |  4 +-
 .../ConstantCaseJsonNamingPolicy.cs           |  2 +-
 .../ErrorPathConverter.cs                     |  8 +-
 .../MapConverter.cs                           |  6 +-
 .../SystemTextJsonSerializer.cs               |  2 +-
 src/GraphQL.Client/GraphQLHttpClient.cs       | 28 +++---
 src/GraphQL.Client/GraphQLHttpRequest.cs      |  2 +-
 src/GraphQL.Client/GraphQLHttpResponse.cs     |  2 +-
 src/GraphQL.Client/UriExtensions.cs           |  4 +-
 .../Websocket/GraphQLHttpWebSocket.cs         | 91 ++++++++++---------
 .../GraphQLWebsocketConnectionException.cs    |  2 +-
 src/GraphQL.Primitives/GraphQLRequest.cs      |  2 +-
 .../BaseSerializeNoCamelCaseTest.cs           |  1 -
 .../BaseSerializerTest.cs                     |  5 -
 .../ConsistencyTests.cs                       |  7 +-
 .../SystemTextJsonSerializerTests.cs          |  2 +-
 .../TestData/DeserializeResponseTestData.cs   |  3 +-
 .../TestData/SerializeToBytesTestData.cs      |  1 -
 .../TestData/SerializeToStringTestData.cs     |  3 -
 .../Helpers/CallbackMonitor.cs                |  2 +-
 .../Helpers/ConcurrentTaskWrapper.cs          | 12 +--
 .../UriExtensionTests.cs                      |  2 +-
 .../WebsocketTests/Base.cs                    | 26 +++---
 .../JsonSerializationTests.cs                 |  1 -
 tests/GraphQL.Server.Test/Startup.cs          |  2 -
 tests/IntegrationTestServer/Startup.cs        | 16 +---
 31 files changed, 144 insertions(+), 150 deletions(-)

diff --git a/.editorconfig b/.editorconfig
index b3d87c9d..c05bd66d 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -4,16 +4,16 @@
 # https://docs.microsoft.com/en-us/visualstudio/ide/create-portable-custom-editor-options
 
 # .NET coding convention settings for EditorConfig
-# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2019
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference
 
 # Language conventions
-# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions
 
 # Formatting conventions
-# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions?view=vs-2019
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions
 
 # .NET naming conventions for EditorConfig
-# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions?view=vs-2019
+# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-naming-conventions
 
 # Top-most EditorConfig file
 root = true
@@ -26,6 +26,9 @@ indent_style = space
 indent_size = 2
 trim_trailing_whitespace = true
 
+[*.json]
+insert_final_newline = false
+
 [*.cs]
 indent_size = 4
 
@@ -91,8 +94,8 @@ csharp_style_var_elsewhere = true:suggestion
 
 # C# code style settings - Expression-bodied members
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#expression-bodied-members
-csharp_style_expression_bodied_methods = when_on_single_line:warning
-csharp_style_expression_bodied_constructors = false:suggestion
+csharp_style_expression_bodied_methods = when_on_single_line:suggestion
+csharp_style_expression_bodied_constructors = false:warning
 csharp_style_expression_bodied_operators = when_on_single_line:warning
 csharp_style_expression_bodied_properties = when_on_single_line:warning
 csharp_style_expression_bodied_indexers = when_on_single_line:warning
@@ -120,7 +123,7 @@ csharp_style_conditional_delegate_call = true:warning
 
 # C# code style settings - Code block preferences
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#code-block-preferences
-csharp_prefer_braces = false:suggestion
+csharp_prefer_braces = when_multiline:suggestion
 
 # C# code style - Unused value preferences
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#unused-value-preferences
@@ -129,8 +132,8 @@ csharp_style_unused_value_assignment_preference = discard_variable:suggestion
 
 # C# code style - Index and range preferences
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#index-and-range-preferences
-csharp_style_prefer_index_operator = true:warning
-csharp_style_prefer_range_operator = true:warning
+csharp_style_prefer_index_operator = true:suggestion
+csharp_style_prefer_range_operator = true:suggestion
 
 # C# code style - Miscellaneous preferences
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-language-conventions?view=vs-2019#miscellaneous-preferences
@@ -138,8 +141,8 @@ csharp_style_deconstructed_variable_declaration = true:suggestion
 csharp_style_pattern_local_over_anonymous_function = true:suggestion
 csharp_using_directive_placement = outside_namespace:warning
 csharp_prefer_static_local_function = true:suggestion
-csharp_prefer_simple_using_statement = false:suggestion
-csharp_style_prefer_switch_expression = true:suggestion
+csharp_prefer_simple_using_statement = true:warning
+csharp_style_prefer_switch_expression = true:warning
 
 # .NET formatting settings - Organize using directives
 # https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-formatting-conventions?view=vs-2019#organize-using-directives
@@ -260,3 +263,27 @@ dotnet_naming_rule.async_methods_end_in_async.severity = warning
 
 # ReSharper: Configure await
 configure_await_analysis_mode = library
+
+# Remove unnecessary import https://docs.microsoft.com/en-us/dotnet/fundamentals/code-analysis/style-rules/ide0005
+dotnet_diagnostic.IDE0005.severity = error
+
+# Enforce formatting https://docs.microsoft.com/en-us/dotnet/fundamentals/code-analysis/style-rules/formatting-rules#rule-id-ide0055-fix-formatting
+dotnet_diagnostic.IDE0055.severity = error
+
+# https://github.com/JosefPihrt/Roslynator/blob/master/docs/analyzers/RCS0060.md
+dotnet_diagnostic.RCS0060.severity = warning
+roslynator_blank_line_after_file_scoped_namespace_declaration = true
+
+# https://github.com/JosefPihrt/Roslynator/blob/main/docs/analyzers/RCS1080.md
+dotnet_diagnostic.RCS1080.severity = warning
+
+# ConfigureAwait https://github.com/JosefPihrt/Roslynator/blob/master/docs/analyzers/RCS1090.md
+dotnet_diagnostic.RCS1090.severity = warning
+roslynator_configure_await = true
+
+# https://github.com/JosefPihrt/Roslynator/blob/master/docs/analyzers/RCS1102.md
+# TODO: NullabilityInfo issue in Patching.cs in internal class SR
+dotnet_diagnostic.RCS1102.severity = suggestion
+
+# https://github.com/JosefPihrt/Roslynator/blob/master/docs/analyzers/RCS1194.md
+dotnet_diagnostic.RCS1194.severity = suggestion
diff --git a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
index 7dbd22b5..3a66edc7 100644
--- a/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
+++ b/examples/GraphQL.Client.Example/PersonAndFilmsResponse.cs
@@ -1,5 +1,3 @@
-using System.Collections.Generic;
-
 namespace GraphQL.Client.Example;
 
 public class PersonAndFilmsResponse
diff --git a/examples/GraphQL.Client.Example/Program.cs b/examples/GraphQL.Client.Example/Program.cs
index b1f4d2ac..83f8da0a 100644
--- a/examples/GraphQL.Client.Example/Program.cs
+++ b/examples/GraphQL.Client.Example/Program.cs
@@ -1,7 +1,4 @@
-using System;
-using System.Linq;
 using System.Text.Json;
-using System.Threading.Tasks;
 using GraphQL.Client.Http;
 using GraphQL.Client.Serializer.Newtonsoft;
 
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
index f751adb8..cc99a85e 100644
--- a/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringExtensions.cs
@@ -1,4 +1,4 @@
-namespace GraphQL.Client.Abstractions.Utilities;
+namespace GraphQL.Client.Abstractions.Utilities;
 
 /// <summary>
 /// Copied from https://github.com/jquense/StringUtils
diff --git a/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
index 27fbf992..87047f79 100644
--- a/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
+++ b/src/GraphQL.Client.Abstractions/Utilities/StringUtils.cs
@@ -1,4 +1,4 @@
-using System.Text.RegularExpressions;
+using System.Text.RegularExpressions;
 
 namespace GraphQL.Client.Abstractions.Utilities;
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 63cc6de3..0cfd14b1 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -8,7 +8,7 @@ namespace GraphQL.Client.Serializer.Newtonsoft;
 
 public class NewtonsoftJsonSerializer : IGraphQLWebsocketJsonSerializer
 {
-    public static JsonSerializerSettings DefaultJsonSerializerSettings => new JsonSerializerSettings
+    public static JsonSerializerSettings DefaultJsonSerializerSettings => new()
     {
         ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
         MissingMemberHandling = MissingMemberHandling.Ignore,
@@ -34,7 +34,7 @@ public NewtonsoftJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
 
     public byte[] SerializeToBytes(GraphQLWebSocketRequest request)
     {
-        var json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
+        string json = JsonConvert.SerializeObject(request, JsonSerializerSettings);
         return Encoding.UTF8.GetBytes(json);
     }
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
index 680503a6..acc7f9b1 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
@@ -3,7 +3,7 @@
 
 namespace GraphQL.Client.Serializer.SystemTextJson;
 
-public class ConstantCaseJsonNamingPolicy: JsonNamingPolicy
+public class ConstantCaseJsonNamingPolicy : JsonNamingPolicy
 {
     public override string ConvertName(string name) => name.ToConstantCase();
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
index e325dccb..b50a8591 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ErrorPathConverter.cs
@@ -7,13 +7,13 @@ public class ErrorPathConverter : JsonConverter<ErrorPath>
 {
 
     public override ErrorPath Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
-        new ErrorPath(ReadArray(ref reader));
+        new(ReadArray(ref reader));
 
     public override void Write(Utf8JsonWriter writer, ErrorPath value, JsonSerializerOptions options)
         => throw new NotImplementedException(
             "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
-    
-    private IEnumerable<object?> ReadArray(ref Utf8JsonReader reader)
+
+    private static IEnumerable<object?> ReadArray(ref Utf8JsonReader reader)
     {
         if (reader.TokenType != JsonTokenType.StartArray)
         {
@@ -33,7 +33,7 @@ public override void Write(Utf8JsonWriter writer, ErrorPath value, JsonSerialize
         return array;
     }
 
-    private object? ReadValue(ref Utf8JsonReader reader)
+    private static object? ReadValue(ref Utf8JsonReader reader)
         => reader.TokenType switch
         {
             JsonTokenType.None => null,
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
index 66d4aead..78eef361 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/MapConverter.cs
@@ -22,7 +22,7 @@ private static TDictionary ReadDictionary<TDictionary>(ref Utf8JsonReader reader
     {
         if (reader.TokenType != JsonTokenType.StartObject)
             throw new JsonException();
-        
+
         while (reader.Read())
         {
             if (reader.TokenType == JsonTokenType.EndObject)
@@ -60,7 +60,7 @@ private static List<object> ReadArray(ref Utf8JsonReader reader)
 
         return result;
     }
-    
+
     private static object? ReadValue(ref Utf8JsonReader reader)
         => reader.TokenType switch
         {
@@ -74,6 +74,4 @@ private static List<object> ReadArray(ref Utf8JsonReader reader)
             JsonTokenType.None => null,
             _ => throw new InvalidOperationException($"Unexpected value kind: {reader.TokenType}")
         };
-
-    
 }
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 4fa66c64..232fa421 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -10,7 +10,7 @@ public class SystemTextJsonSerializer : IGraphQLWebsocketJsonSerializer
     public static JsonSerializerOptions DefaultJsonSerializerOptions => new JsonSerializerOptions
     {
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
-        Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}
+        Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false) }
     }.SetupImmutableConverter();
 
     public JsonSerializerOptions Options { get; }
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index eda4b6f9..e42cd678 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -77,12 +77,9 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
     /// <inheritdoc />
     public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
     {
-        if (Options.UseWebSocketForQueriesAndMutations ||
-            !(Options.WebSocketEndPoint is null) && Options.EndPoint is null ||
-            Options.EndPoint.HasWebSocketScheme())
-            return await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken).ConfigureAwait(false);
-
-        return await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
+        return Options.UseWebSocketForQueriesAndMutations || Options.WebSocketEndPoint is not null && Options.EndPoint is null || Options.EndPoint.HasWebSocketScheme()
+            ? await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken).ConfigureAwait(false)
+            : await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
     }
 
     /// <inheritdoc />
@@ -132,22 +129,23 @@ private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TRespons
         // error handling
         string content = null;
         if (contentStream != null)
-            using (var sr = new StreamReader(contentStream))
-                content = await sr.ReadToEndAsync().ConfigureAwait(false);
+        {
+            using var sr = new StreamReader(contentStream);
+            content = await sr.ReadToEndAsync().ConfigureAwait(false);
+        }
 
         throw new GraphQLHttpRequestException(httpResponseMessage.StatusCode, httpResponseMessage.Headers, content);
     }
 
     private GraphQLHttpWebSocket CreateGraphQLHttpWebSocket()
     {
-        if(Options.WebSocketEndPoint is null && Options.EndPoint is null)
+        if (Options.WebSocketEndPoint is null && Options.EndPoint is null)
             throw new InvalidOperationException("no endpoint configured");
 
         var webSocketEndpoint = Options.WebSocketEndPoint ?? Options.EndPoint.GetWebSocketUri();
-        if (!webSocketEndpoint.HasWebSocketScheme())
-            throw new InvalidOperationException($"uri \"{webSocketEndpoint}\" is not a websocket endpoint");
-
-        return new GraphQLHttpWebSocket(webSocketEndpoint, this);
+        return webSocketEndpoint.HasWebSocketScheme()
+            ? new GraphQLHttpWebSocket(webSocketEndpoint, this)
+            : throw new InvalidOperationException($"uri \"{webSocketEndpoint}\" is not a websocket endpoint");
     }
 
     #endregion
@@ -178,9 +176,9 @@ protected virtual void Dispose(bool disposing)
         {
             Debug.WriteLine($"Disposing GraphQLHttpClient on endpoint {Options.EndPoint}");
             _cancellationTokenSource.Cancel();
-            if(_disposeHttpClient)
+            if (_disposeHttpClient)
                 HttpClient.Dispose();
-            if ( _lazyHttpWebSocket.IsValueCreated )
+            if (_lazyHttpWebSocket.IsValueCreated)
                 _lazyHttpWebSocket.Value.Dispose();
             _cancellationTokenSource.Dispose();
         }
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index c68379c1..925c060e 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -15,7 +15,7 @@ public GraphQLHttpRequest(string query, object? variables = null, string? operat
     {
     }
 
-    public GraphQLHttpRequest(GraphQLRequest other): base(other)
+    public GraphQLHttpRequest(GraphQLRequest other) : base(other)
     {
     }
 
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index cebada2e..cc676851 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -21,7 +21,7 @@ public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders resp
 
 public static class GraphQLResponseExtensions
 {
-    public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) => new GraphQLHttpResponse<T>(response, responseHeaders, statusCode);
+    public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) => new(response, responseHeaders, statusCode);
 
     /// <summary>
     /// Casts <paramref name="response"/> to <see cref="GraphQLHttpResponse{T}"/>. Throws if the cast fails.
diff --git a/src/GraphQL.Client/UriExtensions.cs b/src/GraphQL.Client/UriExtensions.cs
index 47f5841c..54e623b7 100644
--- a/src/GraphQL.Client/UriExtensions.cs
+++ b/src/GraphQL.Client/UriExtensions.cs
@@ -8,7 +8,7 @@ public static class UriExtensions
     /// <param name="uri"></param>
     /// <returns></returns>
     public static bool HasWebSocketScheme(this Uri? uri) =>
-        !(uri is null) &&
+        uri is not null &&
         (uri.Scheme.Equals("wss", StringComparison.OrdinalIgnoreCase) || uri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase));
 
     /// <summary>
@@ -33,6 +33,6 @@ public static Uri GetWebSocketUri(this Uri uri)
         else
             throw new NotSupportedException($"cannot infer websocket uri from uri scheme {uri.Scheme}");
 
-        return new UriBuilder(uri){Scheme = webSocketScheme}.Uri;
+        return new UriBuilder(uri) { Scheme = webSocketScheme }.Uri;
     }
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 1afa6b98..c85a92a3 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -18,12 +18,11 @@ internal class GraphQLHttpWebSocket : IDisposable
     private readonly Uri _webSocketUri;
     private readonly GraphQLHttpClient _client;
     private readonly ArraySegment<byte> _buffer;
-    private readonly CancellationTokenSource _internalCancellationTokenSource = new CancellationTokenSource();
+    private readonly CancellationTokenSource _internalCancellationTokenSource = new();
     private readonly CancellationToken _internalCancellationToken;
-    private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
-    private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
-    private readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject =
-        new BehaviorSubject<GraphQLWebsocketConnectionState>(GraphQLWebsocketConnectionState.Disconnected);
+    private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new();
+    private readonly Subject<Exception> _exceptionSubject = new();
+    private readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject = new(GraphQLWebsocketConnectionState.Disconnected);
     private readonly IDisposable _requestSubscription;
 
     private int _connectionAttempt = 0;
@@ -32,12 +31,12 @@ internal class GraphQLHttpWebSocket : IDisposable
     private GraphQLHttpClientOptions Options => _client.Options;
 
     private Task _initializeWebSocketTask = Task.CompletedTask;
-    private readonly object _initializeLock = new object();
+    private readonly object _initializeLock = new();
 
 #if NETFRAMEWORK
-		private WebSocket _clientWebSocket = null;
+    private WebSocket _clientWebSocket;
 #else
-    private ClientWebSocket _clientWebSocket = null;
+    private ClientWebSocket _clientWebSocket;
 #endif
 
     #endregion
@@ -93,7 +92,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
         Observable.Defer(() =>
                 Observable.Create<GraphQLResponse<TResponse>>(async observer =>
                 {
-                    Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
+                    Debug.WriteLine($"Create observable thread id: {Environment.CurrentManagedThreadId}");
                     var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
 
                     var startRequest = new GraphQLWebSocketRequest
@@ -123,7 +122,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                                     }
 
                                     // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-                                    Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+                                    Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Environment.CurrentManagedThreadId})");
                                     var typedResponse =
                                         _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
                                             response.MessageBytes);
@@ -207,7 +206,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                     {
                         // if the external handler is not set, propagate all exceptions except WebSocketExceptions
                         // this will ensure that the client tries to re-establish subscriptions on connection loss
-                        if (!(e is WebSocketException))
+                        if (e is not WebSocketException)
                             throw e;
                     }
                     else
@@ -218,10 +217,12 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
                     // throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
                     if (_internalCancellationToken.IsCancellationRequested)
+                    {
                         return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
+                    }
                     else
                     {
-                        Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
+                        Debug.WriteLine($"Catch handler thread id: {Environment.CurrentManagedThreadId}");
                         return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
                     }
                 }
@@ -239,12 +240,12 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                 // if the result contains an exception, throw it on the observable
                 if (t.Item2 != null)
                 {
-                    Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId} => {t.Item2}");
+                    Debug.WriteLine($"unwrap exception thread id: {Environment.CurrentManagedThreadId} => {t.Item2}");
                     return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
                 }
                 if (t.Item1 == null)
                 {
-                    Debug.WriteLine($"empty item thread id: {Thread.CurrentThread.ManagedThreadId}");
+                    Debug.WriteLine($"empty item thread id: {Environment.CurrentManagedThreadId}");
                     return Observable.Empty<GraphQLResponse<TResponse>>();
                 }
                 return Observable.Return(t.Item1);
@@ -342,7 +343,7 @@ private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest reque
 
     private async Task SendWebSocketMessageAsync(GraphQLWebSocketRequest request, CancellationToken cancellationToken = default)
     {
-        var requestBytes = _client.JsonSerializer.SerializeToBytes(request);
+        byte[] requestBytes = _client.JsonSerializer.SerializeToBytes(request);
         await _clientWebSocket.SendAsync(
             new ArraySegment<byte>(requestBytes),
             WebSocketMessageType.Text,
@@ -364,7 +365,9 @@ public Task InitializeWebSocket()
             if (_initializeWebSocketTask != null &&
                !_initializeWebSocketTask.IsFaulted &&
                !_initializeWebSocketTask.IsCompleted)
+            {
                 return _initializeWebSocketTask;
+            }
 
             // if the websocket is open, return a completed task
             if (_clientWebSocket != null && _clientWebSocket.State == WebSocketState.Open)
@@ -374,24 +377,27 @@ public Task InitializeWebSocket()
             _clientWebSocket?.Dispose();
 
 #if NETFRAMEWORK
-				// fix websocket not supported on win 7 using
-				// https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
-				_clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
-				switch (_clientWebSocket) {
-					case ClientWebSocket nativeWebSocket:
-						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
-						nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
-						nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+            // fix websocket not supported on win 7 using
+            // https://github.com/PingmanTools/System.Net.WebSockets.Client.Managed
+            _clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+            switch (_clientWebSocket)
+            {
+                case ClientWebSocket nativeWebSocket:
+                    nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+                    nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                    nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                     Options.ConfigureWebsocketOptions(nativeWebSocket.Options);
                     break;
-					case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
-						managedWebSocket.Options.AddSubProtocol("graphql-ws");
-						managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
-						managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
+
+                case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
+                    managedWebSocket.Options.AddSubProtocol("graphql-ws");
+                    managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
+                    managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                     break;
-					default:
-						throw new NotSupportedException($"unknown websocket type {_clientWebSocket.GetType().Name}");
-				}
+
+                default:
+                    throw new NotSupportedException($"unknown websocket type {_clientWebSocket.GetType().Name}");
+            }
 #else
             _clientWebSocket = new ClientWebSocket();
             _clientWebSocket.Options.AddSubProtocol("graphql-ws");
@@ -437,7 +443,7 @@ private async Task ConnectAsync(CancellationToken token)
         {
             await BackOff().ConfigureAwait(false);
             _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
-            Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
+            Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Environment.CurrentManagedThreadId})");
             await _clientWebSocket.ConnectAsync(_webSocketUri, token).ConfigureAwait(false);
             _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
             Debug.WriteLine($"connection established on websocket {_clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
@@ -491,14 +497,16 @@ private async Task ConnectAsync(CancellationToken token)
 
             // send connection init
             Debug.WriteLine($"sending connection init message");
-            await SendWebSocketMessageAsync(initRequest).ConfigureAwait(false);
+            await SendWebSocketMessageAsync(initRequest, CancellationToken.None).ConfigureAwait(false);
             var response = await ackTask.ConfigureAwait(false);
 
             if (response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
+            {
                 Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
+            }
             else
             {
-                var errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
+                string errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
                 Debug.WriteLine($"connection error received: {errorPayload}");
                 throw new GraphQLWebsocketConnectionException(errorPayload);
             }
@@ -542,15 +550,15 @@ private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
                 };
 
                 // add some debug output
-                var hashCode = subscription.GetHashCode();
+                int hashCode = subscription.GetHashCode();
                 subscription.Add(Disposable.Create(() => Debug.WriteLine($"incoming message subscription {hashCode} disposed")));
                 Debug.WriteLine($"new incoming message subscription {hashCode} created");
 
                 return subscription;
             });
 
-    private Task<WebsocketMessageWrapper> _receiveAsyncTask = null;
-    private readonly object _receiveTaskLocker = new object();
+    private Task<WebsocketMessageWrapper> _receiveAsyncTask;
+    private readonly object _receiveTaskLocker = new();
     /// <summary>
     /// wrapper method to pick up the existing request task if already running
     /// </summary>
@@ -563,7 +571,9 @@ private Task<WebsocketMessageWrapper> GetReceiveTask()
             if (_receiveAsyncTask == null ||
                 _receiveAsyncTask.IsFaulted ||
                 _receiveAsyncTask.IsCompleted)
+            {
                 _receiveAsyncTask = ReceiveWebsocketMessagesAsync();
+            }
         }
 
         return _receiveAsyncTask;
@@ -579,7 +589,7 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
 
         try
         {
-            Debug.WriteLine($"waiting for data on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+            Debug.WriteLine($"waiting for data on websocket {_clientWebSocket.GetHashCode()} (thread {Environment.CurrentManagedThreadId})...");
 
             using var ms = new MemoryStream();
             WebSocketReceiveResult webSocketReceiveResult = null;
@@ -599,7 +609,7 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
                 case WebSocketMessageType.Text:
                     var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
                     response.MessageBytes = ms.ToArray();
-                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
+                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Environment.CurrentManagedThreadId})...");
                     return response;
 
                 case WebSocketMessageType.Close:
@@ -653,8 +663,7 @@ public void Complete()
     {
         lock (_completedLocker)
         {
-            if (Completion == null)
-                Completion = CompleteAsync();
+            Completion ??= CompleteAsync();
         }
     }
 
@@ -664,7 +673,7 @@ public void Complete()
     /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
     public Task? Completion { get; private set; }
 
-    private readonly object _completedLocker = new object();
+    private readonly object _completedLocker = new();
     private async Task CompleteAsync()
     {
         Debug.WriteLine("disposing GraphQLHttpWebSocket...");
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
index ea4140fb..f9811b98 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
@@ -3,7 +3,7 @@
 namespace GraphQL.Client.Http.Websocket;
 
 [Serializable]
-public class GraphQLWebsocketConnectionException: Exception
+public class GraphQLWebsocketConnectionException : Exception
 {
     public GraphQLWebsocketConnectionException()
     {
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 7d9ee10c..59593d7b 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -56,7 +56,7 @@ public GraphQLRequest(string query, object? variables = null, string? operationN
         Extensions = extensions;
     }
 
-    public GraphQLRequest(GraphQLRequest other): base(other) { }
+    public GraphQLRequest(GraphQLRequest other) : base(other) { }
 
     /// <summary>
     /// Returns a value that indicates whether this instance is equal to a specified object
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
index 9dcabfd7..14d77d16 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializeNoCamelCaseTest.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Text;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 2021a792..ddb71471 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -1,10 +1,5 @@
-using System;
-using System.IO;
-using System.Linq;
 using System.Reflection;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using FluentAssertions;
 using FluentAssertions.Execution;
 using GraphQL.Client.Abstractions;
diff --git a/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
index 3bafce7c..200c0acf 100644
--- a/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using FluentAssertions;
 using FluentAssertions.Execution;
 using GraphQL.Client.Serializer.Newtonsoft;
@@ -29,7 +28,7 @@ public void MapConvertersShouldBehaveConsistent()
                   {""number"": 567.8}
                 ]
             }";
-        
+
         var newtonsoftSerializer = new NewtonsoftJsonSerializer();
         var systemTextJsonSerializer = new SystemTextJsonSerializer();
 
@@ -37,7 +36,7 @@ public void MapConvertersShouldBehaveConsistent()
         var systemTextJsonMap = System.Text.Json.JsonSerializer.Deserialize<Map>(json, systemTextJsonSerializer.Options);
 
 
-        using(new AssertionScope())
+        using (new AssertionScope())
         {
             CompareMaps(newtonsoftMap, systemTextJsonMap);
         }
@@ -52,7 +51,7 @@ private void CompareMaps(Dictionary<string, object> first, Dictionary<string, ob
         {
             second.Should().ContainKey(keyValuePair.Key);
             second[keyValuePair.Key].Should().BeOfType(keyValuePair.Value.GetType());
-            if(keyValuePair.Value is Dictionary<string, object> map)
+            if (keyValuePair.Value is Dictionary<string, object> map)
                 CompareMaps(map, (Dictionary<string, object>)second[keyValuePair.Key]);
             else
                 keyValuePair.Value.Should().BeEquivalentTo(second[keyValuePair.Key]);
diff --git a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
index 38ebc2a1..c94eed8a 100644
--- a/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/SystemTextJsonSerializerTests.cs
@@ -19,7 +19,7 @@ public class SystemTextJsonSerializeNoCamelCaseTest : BaseSerializeNoCamelCaseTe
 {
     public SystemTextJsonSerializeNoCamelCaseTest()
         : base(
-            new SystemTextJsonSerializer(new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false)}}.SetupImmutableConverter()),
+            new SystemTextJsonSerializer(new JsonSerializerOptions { Converters = { new JsonStringEnumConverter(new ConstantCaseJsonNamingPolicy(), false) } }.SetupImmutableConverter()),
             new GraphQL.SystemTextJson.GraphQLSerializer(new ErrorInfoProvider(opt => opt.ExposeData = true)))
     {
     }
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
index 6b388483..53388f1f 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/DeserializeResponseTestData.cs
@@ -1,5 +1,4 @@
 using System.Collections;
-using System.Collections.Generic;
 
 namespace GraphQL.Client.Serializer.Tests.TestData;
 
@@ -119,7 +118,7 @@ public IEnumerator<object[]> GetEnumerator()
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
     private GraphQLResponse<T> NewAnonymouslyTypedGraphQLResponse<T>(T data, GraphQLError[]? errors = null, Map? extensions = null)
-        => new GraphQLResponse<T> {Data = data, Errors = errors, Extensions = extensions};
+        => new GraphQLResponse<T> { Data = data, Errors = errors, Extensions = extensions };
 }
 
 public class Friend
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
index 977ea5af..85725616 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToBytesTestData.cs
@@ -1,5 +1,4 @@
 using System.Collections;
-using System.Collections.Generic;
 using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Serializer.Tests.TestData;
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index 395b9efc..e01c6335 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -1,7 +1,4 @@
-using System;
 using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
 
 namespace GraphQL.Client.Serializer.Tests.TestData;
 
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
index eaf2e10c..b6399a2f 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/CallbackMonitor.cs
@@ -44,7 +44,7 @@ public void Reset()
 
     public class CallbackAssertions<TPayload> : ReferenceTypeAssertions<CallbackMonitor<TPayload>, CallbackAssertions<TPayload>>
     {
-        public CallbackAssertions(CallbackMonitor<TPayload> tester): base(tester)
+        public CallbackAssertions(CallbackMonitor<TPayload> tester) : base(tester)
         { }
 
         protected override string Identifier => "callback";
diff --git a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
index c49849ed..fa78d4a7 100644
--- a/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
+++ b/tests/GraphQL.Client.Tests.Common/Helpers/ConcurrentTaskWrapper.cs
@@ -2,10 +2,10 @@ namespace GraphQL.Client.Tests.Common.Helpers;
 
 public class ConcurrentTaskWrapper
 {
-    public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) => new ConcurrentTaskWrapper<TResult>(createTask);
+    public static ConcurrentTaskWrapper<TResult> New<TResult>(Func<Task<TResult>> createTask) => new(createTask);
 
     private readonly Func<Task> _createTask;
-    private Task _internalTask = null;
+    private Task _internalTask;
 
     public ConcurrentTaskWrapper(Func<Task> createTask)
     {
@@ -24,7 +24,7 @@ public Task Invoke()
 public class ConcurrentTaskWrapper<TResult>
 {
     private readonly Func<Task<TResult>> _createTask;
-    private Task<TResult> _internalTask = null;
+    private Task<TResult> _internalTask;
 
     public ConcurrentTaskWrapper(Func<Task<TResult>> createTask)
     {
@@ -39,11 +39,7 @@ public Task<TResult> Invoke()
         return _internalTask = _createTask();
     }
 
-    public void Start()
-    {
-        if (_internalTask == null)
-            _internalTask = _createTask();
-    }
+    public void Start() => _internalTask ??= _createTask();
 
     public Func<Task<TResult>> Invoking() => Invoke;
 
diff --git a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
index d218b5d8..7e374578 100644
--- a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
+++ b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
@@ -1,4 +1,4 @@
-using FluentAssertions;
+using FluentAssertions;
 using GraphQL.Client.Http;
 using Xunit;
 
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 35938f34..8978bc35 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -29,7 +29,7 @@ protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture)
         Fixture = fixture;
     }
 
-    protected static ReceivedMessage InitialMessage = new ReceivedMessage
+    protected static ReceivedMessage InitialMessage = new()
     {
         Content = "initial message",
         SentAt = DateTime.Now,
@@ -42,11 +42,8 @@ public async Task InitializeAsync()
         // make sure the buffer always contains the same message
         Fixture.Server.Services.GetService<Chat>().AddMessage(InitialMessage);
 
-        if (ChatClient == null)
-        {
-            // then create the chat client
-            ChatClient = Fixture.GetChatClient(true);
-        }
+        // then create the chat client
+        ChatClient ??= Fixture.GetChatClient(true);
     }
 
     public Task DisposeAsync()
@@ -75,7 +72,7 @@ public async void CanUseWebSocketScheme()
         response.Errors.Should().BeNullOrEmpty();
         response.Data.AddMessage.Content.Should().Be(message);
     }
-    
+
     [Fact]
     public async void CanUseDedicatedWebSocketEndpoint()
     {
@@ -88,7 +85,7 @@ public async void CanUseDedicatedWebSocketEndpoint()
         response.Errors.Should().BeNullOrEmpty();
         response.Data.AddMessage.Content.Should().Be(message);
     }
-    
+
     [Fact]
     public async void CanUseDedicatedWebSocketEndpointWithoutHttpEndpoint()
     {
@@ -155,8 +152,7 @@ public async void CanHandleRequestErrorViaWebsocket()
 			  }
 			}";
 
-    private readonly GraphQLRequest _subscriptionRequest = new GraphQLRequest(SUBSCRIPTION_QUERY);
-
+    private readonly GraphQLRequest _subscriptionRequest = new(SUBSCRIPTION_QUERY);
 
     [Fact]
     public async void CanCreateObservableSubscription()
@@ -234,9 +230,9 @@ public async void CanReconnectWithSameObservable()
         Debug.WriteLine("disposing subscription...");
         observer.Dispose(); // does not close the websocket connection
 
-        Debug.WriteLine($"creating new subscription from thread {Thread.CurrentThread.ManagedThreadId} ...");
+        Debug.WriteLine($"creating new subscription from thread {Environment.CurrentManagedThreadId} ...");
         var observer2 = observable.Observe();
-        Debug.WriteLine($"waiting for payload on {Thread.CurrentThread.ManagedThreadId} ...");
+        Debug.WriteLine($"waiting for payload on {Environment.CurrentManagedThreadId} ...");
         await observer2.Should().PushAsync(1);
         observer2.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message2);
 
@@ -273,12 +269,12 @@ public class UserJoinedContent
 
     }
 
-    private readonly GraphQLRequest _subscriptionRequest2 = new GraphQLRequest(SUBSCRIPTION_QUERY2);
+    private readonly GraphQLRequest _subscriptionRequest2 = new(SUBSCRIPTION_QUERY2);
 
     [Fact]
     public async void CanConnectTwoSubscriptionsSimultaneously()
     {
-        var port = NetworkHelpers.GetFreeTcpPortNumber();
+        int port = NetworkHelpers.GetFreeTcpPortNumber();
         var callbackTester = new CallbackMonitor<Exception>();
         var callbackTester2 = new CallbackMonitor<Exception>();
 
@@ -376,7 +372,7 @@ public async void CanHandleConnectionTimeout()
         {
             websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
 
-            Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
+            Debug.WriteLine($"Test method thread id: {Environment.CurrentManagedThreadId}");
             Debug.WriteLine("creating subscription stream");
             var observable = ChatClient.CreateSubscriptionStream<MessageAddedSubscriptionResult>(_subscriptionRequest, errorMonitor.Invoke);
 
diff --git a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
index 2fb2bbc0..14917d58 100644
--- a/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
+++ b/tests/GraphQL.Primitives.Tests/JsonSerializationTests.cs
@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using System.Text.Json;
 using FluentAssertions;
 using Xunit;
diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index 4dd737c5..114ce5ff 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -1,6 +1,4 @@
-using GraphQL.MicrosoftDI;
 using GraphQL.Server.Test.GraphQL;
-using GraphQL.Server.Ui.GraphiQL;
 
 namespace GraphQL.Server.Test;
 
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 65ba8a99..d2b8d427 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -2,12 +2,8 @@
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Chat.Schema;
 using GraphQL.Client.Tests.Common.StarWars;
-using GraphQL.MicrosoftDI;
-using GraphQL.Server;
 using GraphQL.Server.Ui.Altair;
 using GraphQL.Server.Ui.GraphiQL;
-using GraphQL.SystemTextJson;
-using GraphQL.Types;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 
 namespace IntegrationTestServer;
@@ -38,7 +34,7 @@ public void ConfigureServices(IServiceCollection services)
             {
                 var logger = ctx.Context.RequestServices.GetRequiredService<ILogger<Startup>>();
                 logger.LogError("{Error} occurred", ctx.OriginalException.Message);
-                return System.Threading.Tasks.Task.CompletedTask;
+                return Task.CompletedTask;
             })
             .AddErrorInfoProvider(opt => opt.ExposeExceptionDetails = Environment.IsDevelopment())
             .AddSystemTextJson()
@@ -52,18 +48,12 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
         {
             app.UseDeveloperExceptionPage();
         }
-
         app.UseWebSockets();
 
-        ConfigureGraphQLSchema<ChatSchema>(app, Common.CHAT_ENDPOINT);
-        ConfigureGraphQLSchema<StarWarsSchema>(app, Common.STAR_WARS_ENDPOINT);
+        app.UseGraphQL<ChatSchema>(Common.CHAT_ENDPOINT);
+        app.UseGraphQL<StarWarsSchema>(Common.STAR_WARS_ENDPOINT);
 
         app.UseGraphQLGraphiQL(options: new GraphiQLOptions { GraphQLEndPoint = Common.STAR_WARS_ENDPOINT });
         app.UseGraphQLAltair(options: new AltairOptions { GraphQLEndPoint = Common.CHAT_ENDPOINT });
     }
-
-    private void ConfigureGraphQLSchema<TSchema>(IApplicationBuilder app, string endpoint) where TSchema : Schema
-    {
-        app.UseGraphQL<TSchema>(endpoint);
-    }
 }

From 4a3610d1f6a0f1b7505aad9de01e11ea0d7a8bba Mon Sep 17 00:00:00 2001
From: Ben Voss <ben.voss@me.com>
Date: Tue, 11 Apr 2023 09:06:35 +0100
Subject: [PATCH 424/455] Add an interface for websocket specific transport
 methods. (#537)

* Add an interface for websocket specific transport methods.

* Update src/GraphQL.Client/GraphQLHttpClient.cs

Removed unnecessary interface usage

Co-authored-by: Alexander Rose <alex@rose-a.de>

---------

Co-authored-by: Ben Voss <ben.voss@coremont.com>
Co-authored-by: Alexander Rose <alex@rose-a.de>
---
 .../IGraphQLClient.cs                         | 19 +++++++++++++++++++
 src/GraphQL.Client/GraphQLHttpClient.cs       |  2 +-
 2 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 src/GraphQL.Client.Abstractions.Websocket/IGraphQLClient.cs

diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLClient.cs
new file mode 100644
index 00000000..a8f90133
--- /dev/null
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLClient.cs
@@ -0,0 +1,19 @@
+namespace GraphQL.Client.Abstractions.Websocket;
+
+public interface IGraphQLWebSocketClient : IGraphQLClient
+{
+    /// <summary>
+    /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
+    /// </summary>
+    IObservable<Exception> WebSocketReceiveErrors { get; }
+
+    /// <summary>
+    /// Publishes the websocket connection state
+    /// </summary>
+    IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState { get; }
+
+    /// <summary>
+    /// Explicitly opens the websocket connection. Will be closed again on disposing the last subscription.
+    /// </summary>
+    Task InitializeWebsocketConnection();
+}
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index e42cd678..b17527b6 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -6,7 +6,7 @@
 
 namespace GraphQL.Client.Http;
 
-public class GraphQLHttpClient : IGraphQLClient, IDisposable
+public class GraphQLHttpClient : IGraphQLWebSocketClient, IDisposable
 {
     private readonly Lazy<GraphQLHttpWebSocket> _lazyHttpWebSocket;
     private GraphQLHttpWebSocket GraphQlHttpWebSocket => _lazyHttpWebSocket.Value;

From 8edb6fa0f49caf75f54463712082376b429385d7 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Tue, 11 Apr 2023 10:18:02 +0200
Subject: [PATCH 425/455] Fix filename of IGraphQLWebSocketClient interface
 (#538)

fix filename of IGraphQLWebSocketClient interface
---
 .../{IGraphQLClient.cs => IGraphQLWebSocketClient.cs}             | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/GraphQL.Client.Abstractions.Websocket/{IGraphQLClient.cs => IGraphQLWebSocketClient.cs} (100%)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLClient.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebSocketClient.cs
similarity index 100%
rename from src/GraphQL.Client.Abstractions.Websocket/IGraphQLClient.cs
rename to src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebSocketClient.cs

From 19cc8f9e8799baa713eea4173d1478a868af74c8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 12 Apr 2023 15:35:40 +0300
Subject: [PATCH 426/455] Bump Microsoft.AspNetCore.Mvc.Testing from 7.0.4 to
 7.0.5 (#540)

Bumps [Microsoft.AspNetCore.Mvc.Testing](https://github.com/dotnet/aspnetcore) from 7.0.4 to 7.0.5.
- [Release notes](https://github.com/dotnet/aspnetcore/releases)
- [Changelog](https://github.com/dotnet/aspnetcore/blob/main/docs/ReleasePlanning.md)
- [Commits](https://github.com/dotnet/aspnetcore/compare/v7.0.4...v7.0.5)

---
updated-dependencies:
- dependency-name: Microsoft.AspNetCore.Mvc.Testing
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 2ede20bc..d6f082fe 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="7.0.4" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="7.0.5" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
   </ItemGroup>
 

From 4430c20517e828b67572bfbed109e0c3b322e93e Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 13 Apr 2023 16:39:53 +0200
Subject: [PATCH 427/455] Support graphql-transport-ws websocket protocol
 (#539)

* Preparing code to add graphql-transport-ws protocol without breaking previous dependant code

* Added graphql-transport-ws subprotocol. Tested with Graphql Yoga server

* Renamed protocols (dropping the deprecated keyword). Split GraphQLHttpWebSocket into two classes (one per protocol) that inherit from BaseGraphQLHttpWebSocket

* fix formatting, do some refactoring

* create unit tests for graphql-transport-ws protocol

* catch json exceptions on empty close messages

* fix handling of regular requests and errors

* change IGraphQLWebsocketSerializer to support diffenent payload types +semver: breaking

* properly hook up ping pong

* implement sub protocol auto-negotiation

* implement and test ping/ping

* fix formatting error

---------

Co-authored-by: joao-avelino <joao.manuel.avelino@gmail.com>
---
 .../GraphQLWebSocketMessageType.cs            |  58 ++-
 .../IGraphQLWebSocketClient.cs                |  26 ++
 .../IGraphQLWebsocketJsonSerializer.cs        |   2 +-
 .../NewtonsoftJsonSerializer.cs               |   4 +-
 .../SystemTextJsonSerializer.cs               |   4 +-
 src/GraphQL.Client/GraphQLHttpClient.cs       |  33 +-
 .../GraphQLHttpClientOptions.cs               |   6 +
 .../Websocket/GraphQLHttpWebSocket.cs         | 413 +++++++-----------
 .../GraphQLTransportWSProtocolHandler.cs      | 321 ++++++++++++++
 .../Websocket/GraphQLWSProtocolHandler.cs     | 235 ++++++++++
 .../Websocket/IWebsocketProtocolHandler.cs    |  23 +
 .../Websocket/WebSocketProtocols.cs           |  20 +
 .../Helpers/IntegrationServerTestFixture.cs   |  28 +-
 .../Helpers/WebHostHelpers.cs                 |   6 +-
 .../QueryAndMutationTests/Newtonsoft.cs       |   4 +-
 .../QueryAndMutationTests/SystemTextJson.cs   |   4 +-
 .../WebsocketTests/Base.cs                    |   1 -
 .../WebsocketTests/Newtonsoft.cs              |  12 -
 .../NewtonsoftGraphQLTransportWs.cs           |  12 +
 .../WebsocketTests/NewtonsoftGraphQLWs.cs     |  12 +
 .../WebsocketTests/SystemTextJson.cs          |  12 -
 .../SystemTextJsonAutoNegotiate.cs            |  21 +
 .../SystemTextJsonGraphQLTransportWs.cs       |  35 ++
 .../WebsocketTests/SystemTextJsonGraphQLWs.cs |  40 ++
 24 files changed, 1031 insertions(+), 301 deletions(-)
 create mode 100644 src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
 create mode 100644 src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs
 create mode 100644 src/GraphQL.Client/Websocket/IWebsocketProtocolHandler.cs
 create mode 100644 src/GraphQL.Client/Websocket/WebSocketProtocols.cs
 delete mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLTransportWs.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLWs.cs
 delete mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
index 16125a71..a1628c6e 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
@@ -72,15 +72,67 @@ public static class GraphQLWebSocketMessageType
     public const string GQL_ERROR = "error"; // Server -> Client
 
     /// <summary>
-    ///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
-    ///     specific operation.
+    ///     Server -> Client: Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive
+    ///     for the specific operation.
+    ///     Client -> Server: "indicates that the client has stopped listening and wants to complete the subscription. No further
+    ///     events, relevant to the original subscription, should be sent through. Even if the client sent a Complete message for
+    ///     a single-result-operation before it resolved, the result should not be sent through once it does."
+    ///     Replaces the GQL_STOP in graphql-transport-ws
     ///     id: string : operation ID of the operation that completed
     /// </summary>
-    public const string GQL_COMPLETE = "complete"; // Server -> Client
+    public const string GQL_COMPLETE = "complete"; // Server -> Client and Client -> Server
 
     /// <summary>
     ///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
     ///     id: string : operation id
     /// </summary>
     public const string GQL_STOP = "stop"; // Client -> Server
+
+
+    // Additional types for graphql-transport-ws, as described in https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md
+
+    /// <summary>
+    ///     Bidirectional. "Useful for detecting failed connections, displaying latency metrics or other types of network probing.
+    ///     A Pong must be sent in response from the receiving party as soon as possible. The Ping message can be sent at any time
+    ///     within the established socket. The optional payload field can be used to transfer additional details about the ping."
+    ///     payload: Object: ping details
+    /// </summary>
+    public const string GQL_PING = "ping"; // Bidirectional
+
+    /// <summary>
+    ///     Bidirectional. "The response to the Ping message. Must be sent as soon as the Ping message is received.
+    ///     The Pong message can be sent at any time within the established socket. Furthermore, the Pong message
+    ///     may even be sent unsolicited as an unidirectional heartbeat. The optional payload field can be used to
+    ///     transfer additional details about the pong."
+    ///     payload: Object: pong details
+    /// </summary>
+    public const string GQL_PONG = "pong"; // Bidirectional
+
+    /// <summary>
+    ///     Client-> Server. "Requests an operation specified in the message payload. This message provides a unique
+    ///     ID field to connect published messages to the operation requested by this message. If there is already an
+    ///     active subscriber for an operation matching the provided ID, regardless of the operation type, the server
+    ///     must close the socket immediately with the event 4409: Subscriber for *unique-operation-id* already exists.
+    ///     The server needs only keep track of IDs for as long as the subscription is active. Once a client completes
+    ///     an operation, it is free to re-use that ID."
+    ///     id: string : operation id
+    ///     payload: Object:
+    ///         operationName : string : subscribe
+    ///         query : string : the subscription query
+    ///         variables : Dictionary(string, string) : a dictionary with variables and their values
+    ///         extensions : Dictionary(string, string) : a dictionary of extensions
+    /// </summary>
+    public const string GQL_SUBSCRIBE = "subscribe"; // Client -> Server
+
+
+    /// <summary>
+    ///     Server -> Client. "Operation execution result(s) from the source stream created by the binding Subscribe
+    ///     message. After all results have been emitted, the Complete message will follow indicating stream
+    ///     completion."
+    ///     id: string : operation id
+    ///     payload: Object: ExecutionResult
+    /// </summary>
+
+    public const string GQL_NEXT = "next"; // Server -> Client
+    
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebSocketClient.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebSocketClient.cs
index a8f90133..63c92362 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebSocketClient.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebSocketClient.cs
@@ -2,6 +2,11 @@ namespace GraphQL.Client.Abstractions.Websocket;
 
 public interface IGraphQLWebSocketClient : IGraphQLClient
 {
+    /// <summary>
+    /// The negotiated websocket sub-protocol. Will be <see langword="null"/> while no websocket connection is established.
+    /// </summary>
+    string? WebSocketSubProtocol { get; }
+
     /// <summary>
     /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
     /// </summary>
@@ -16,4 +21,25 @@ public interface IGraphQLWebSocketClient : IGraphQLClient
     /// Explicitly opens the websocket connection. Will be closed again on disposing the last subscription.
     /// </summary>
     Task InitializeWebsocketConnection();
+
+    /// <summary>
+    /// Publishes the payload of all received pong messages (which may be <see langword="null"/>). Subscribing initiates the websocket connection. <br/>
+    /// Ping/Pong is only supported when using the "graphql-transport-ws" websocket sub-protocol.
+    /// </summary>
+    /// <exception cref="NotSupportedException">the negotiated websocket sub-protocol does not support ping/pong</exception>
+    IObservable<object?> PongStream { get; }
+
+    /// <summary>
+    /// Sends a ping to the server. <br/>
+    /// Ping/Pong is only supported when using the "graphql-transport-ws" websocket sub-protocol.
+    /// </summary>
+    /// <exception cref="NotSupportedException">the negotiated websocket sub-protocol does not support ping/pong</exception>
+    Task SendPingAsync(object? payload);
+
+    /// <summary>
+    /// Sends a pong to the server. This can be used for keep-alive scenarios (the client will automatically respond to pings received from the server). <br/>
+    /// Ping/Pong is only supported when using the "graphql-transport-ws" websocket sub-protocol.
+    /// </summary>
+    /// <exception cref="NotSupportedException">the negotiated websocket sub-protocol does not support ping/pong</exception>
+    Task SendPongAsync(object? payload);
 }
diff --git a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
index f7c4a2bf..e171fe8a 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/IGraphQLWebsocketJsonSerializer.cs
@@ -10,5 +10,5 @@ public interface IGraphQLWebsocketJsonSerializer : IGraphQLJsonSerializer
 
     Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream);
 
-    GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
+    GraphQLWebSocketResponse<TResponse> DeserializeToWebsocketResponse<TResponse>(byte[] bytes);
 }
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
index 0cfd14b1..cc1d78bc 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/NewtonsoftJsonSerializer.cs
@@ -40,8 +40,8 @@ public byte[] SerializeToBytes(GraphQLWebSocketRequest request)
 
     public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
 
-    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
-        JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(Encoding.UTF8.GetString(bytes),
+    public GraphQLWebSocketResponse<TResponse> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
+        JsonConvert.DeserializeObject<GraphQLWebSocketResponse<TResponse>>(Encoding.UTF8.GetString(bytes),
             JsonSerializerSettings);
 
     public Task<GraphQLResponse<TResponse>> DeserializeFromUtf8StreamAsync<TResponse>(Stream stream, CancellationToken cancellationToken) => DeserializeFromUtf8Stream<GraphQLResponse<TResponse>>(stream);
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
index 232fa421..2488358d 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/SystemTextJsonSerializer.cs
@@ -42,7 +42,7 @@ private void ConfigureMandatorySerializerOptions()
 
     public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream) => JsonSerializer.DeserializeAsync<WebsocketMessageWrapper>(stream, Options).AsTask();
 
-    public GraphQLWebSocketResponse<GraphQLResponse<TResponse>> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
-        JsonSerializer.Deserialize<GraphQLWebSocketResponse<GraphQLResponse<TResponse>>>(new ReadOnlySpan<byte>(bytes),
+    public GraphQLWebSocketResponse<TResponse> DeserializeToWebsocketResponse<TResponse>(byte[] bytes) =>
+        JsonSerializer.Deserialize<GraphQLWebSocketResponse<TResponse>>(new ReadOnlySpan<byte>(bytes),
             Options);
 }
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index b17527b6..d634fe2e 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -30,16 +30,18 @@ public class GraphQLHttpClient : IGraphQLWebSocketClient, IDisposable
     /// </summary>
     public GraphQLHttpClientOptions Options { get; }
 
-    /// <summary>
-    /// Publishes all exceptions which occur inside the websocket receive stream (i.e. for logging purposes)
-    /// </summary>
+    /// <inheritdoc />
     public IObservable<Exception> WebSocketReceiveErrors => GraphQlHttpWebSocket.ReceiveErrors;
 
-    /// <summary>
-    /// the websocket connection state
-    /// </summary>
+    /// <inheritdoc />
+    public string? WebSocketSubProtocol => GraphQlHttpWebSocket.WebsocketProtocol;
+
+    /// <inheritdoc />
     public IObservable<GraphQLWebsocketConnectionState> WebsocketConnectionState => GraphQlHttpWebSocket.ConnectionState;
 
+    /// <inheritdoc />
+    public IObservable<object?> PongStream => GraphQlHttpWebSocket.GetPongStream();
+
     #region Constructors
 
     public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serializer)
@@ -78,7 +80,7 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
     public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
     {
         return Options.UseWebSocketForQueriesAndMutations || Options.WebSocketEndPoint is not null && Options.EndPoint is null || Options.EndPoint.HasWebSocketScheme()
-            ? await GraphQlHttpWebSocket.SendRequest<TResponse>(request, cancellationToken).ConfigureAwait(false)
+            ? await GraphQlHttpWebSocket.SendRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false)
             : await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
     }
 
@@ -103,12 +105,15 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
     #endregion
 
-    /// <summary>
-    /// Explicitly opens the websocket connection. Will be closed again on disposing the last subscription.
-    /// </summary>
-    /// <returns></returns>
+    /// <inheritdoc />
     public Task InitializeWebsocketConnection() => GraphQlHttpWebSocket.InitializeWebSocket();
 
+    /// <inheritdoc />
+    public Task SendPingAsync(object? payload) => GraphQlHttpWebSocket.SendPingAsync(payload);
+
+    /// <inheritdoc />
+    public Task SendPongAsync(object? payload) => GraphQlHttpWebSocket.SendPongAsync(payload);
+
     #region Private Methods
 
     private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
@@ -143,9 +148,9 @@ private GraphQLHttpWebSocket CreateGraphQLHttpWebSocket()
             throw new InvalidOperationException("no endpoint configured");
 
         var webSocketEndpoint = Options.WebSocketEndPoint ?? Options.EndPoint.GetWebSocketUri();
-        return webSocketEndpoint.HasWebSocketScheme()
-            ? new GraphQLHttpWebSocket(webSocketEndpoint, this)
-            : throw new InvalidOperationException($"uri \"{webSocketEndpoint}\" is not a websocket endpoint");
+        return !webSocketEndpoint.HasWebSocketScheme()
+            ? throw new InvalidOperationException($"uri \"{webSocketEndpoint}\" is not a websocket endpoint")
+            : new GraphQLHttpWebSocket(webSocketEndpoint, this);
     }
 
     #endregion
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 22b5ddb2..74de6441 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -1,6 +1,7 @@
 using System.Net;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
+using GraphQL.Client.Http.Websocket;
 
 namespace GraphQL.Client.Http;
 
@@ -19,6 +20,11 @@ public class GraphQLHttpClientOptions
     /// </summary>
     public Uri? WebSocketEndPoint { get; set; }
 
+    /// <summary>
+    /// The GraphQL websocket protocol to be used. Defaults to the older "graphql-ws" protocol to not break old code. 
+    /// </summary>
+    public string? WebSocketProtocol { get; set; } = WebSocketProtocols.AUTO_NEGOTIATE;
+
     /// <summary>
     /// The <see cref="System.Net.Http.HttpMessageHandler"/> that is going to be used
     /// </summary>
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index c85a92a3..32925567 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -5,38 +5,40 @@
 using System.Reactive.Linq;
 using System.Reactive.Subjects;
 using System.Reactive.Threading.Tasks;
-using System.Text;
 using GraphQL.Client.Abstractions.Websocket;
 
 namespace GraphQL.Client.Http.Websocket;
 
+
 internal class GraphQLHttpWebSocket : IDisposable
 {
 
     #region Private fields
 
-    private readonly Uri _webSocketUri;
-    private readonly GraphQLHttpClient _client;
+    protected readonly Uri _webSocketUri;
+    protected readonly GraphQLHttpClient _client;
     private readonly ArraySegment<byte> _buffer;
     private readonly CancellationTokenSource _internalCancellationTokenSource = new();
-    private readonly CancellationToken _internalCancellationToken;
+    protected readonly CancellationToken _internalCancellationToken;
     private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new();
-    private readonly Subject<Exception> _exceptionSubject = new();
-    private readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject = new(GraphQLWebsocketConnectionState.Disconnected);
+    protected readonly Subject<Exception> _exceptionSubject = new();
+    protected readonly BehaviorSubject<GraphQLWebsocketConnectionState> _stateSubject = new(GraphQLWebsocketConnectionState.Disconnected);
     private readonly IDisposable _requestSubscription;
 
-    private int _connectionAttempt = 0;
-    private IConnectableObservable<WebsocketMessageWrapper> _incomingMessages;
-    private IDisposable _incomingMessagesConnection;
-    private GraphQLHttpClientOptions Options => _client.Options;
+    protected int _connectionAttempt = 0;
+    protected IConnectableObservable<WebsocketMessageWrapper> _incomingMessages;
+    protected IDisposable _incomingMessagesConnection;
+    private IWebsocketProtocolHandler? _websocketProtocolHandler;
+    protected GraphQLHttpClientOptions Options => _client.Options;
 
     private Task _initializeWebSocketTask = Task.CompletedTask;
     private readonly object _initializeLock = new();
 
+
 #if NETFRAMEWORK
-    private WebSocket _clientWebSocket;
+    protected WebSocket? _clientWebSocket = null;
 #else
-    private ClientWebSocket _clientWebSocket;
+    protected ClientWebSocket? _clientWebSocket = null;
 #endif
 
     #endregion
@@ -63,6 +65,14 @@ internal class GraphQLHttpWebSocket : IDisposable
     /// </summary>
     public IObservable<WebsocketMessageWrapper> IncomingMessageStream { get; }
 
+    /// <summary>
+    /// The websocket protocol used for subscriptions or full-websocket connections
+    /// </summary>
+    public string? WebsocketProtocol => _websocketProtocolHandler?.WebsocketProtocol;
+
+
+    public IObservable<object?> Pongs => null;
+
     #endregion
 
     public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
@@ -77,10 +87,74 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
             .Select(request => Observable.FromAsync(() => SendWebSocketRequestAsync(request)))
             .Concat()
             .Subscribe();
+
     }
 
+    /// <summary>
+    /// Returns the pong message stream. Subscribing initiates the websocket connection if not already established.
+    /// </summary>
+    /// <returns></returns>
+    public IObservable<object?> GetPongStream() =>
+        Observable.Defer(async () =>
+            {
+                if (_websocketProtocolHandler is null)
+                {
+                    await InitializeWebSocket().ConfigureAwait(false);
+                }
+
+                return _websocketProtocolHandler.CreatePongObservable();
+            })
+            // complete sequence on OperationCanceledException, this is triggered by the cancellation token
+            .Catch<object?, OperationCanceledException>(exception =>
+                Observable.Empty<object?>());
+
     #region Send requests
 
+    /// <inheritdoc cref="IGraphQLWebSocketClient.SendPingAsync"/>
+    public async Task SendPingAsync(object? payload)
+    {
+        if (_websocketProtocolHandler is null)
+        {
+            await InitializeWebSocket().ConfigureAwait(false);
+        }
+
+        await _websocketProtocolHandler.SendPingAsync(payload);
+    }
+
+    /// <inheritdoc cref="IGraphQLWebSocketClient.SendPongAsync"/>
+    public async Task SendPongAsync(object? payload)
+    {
+        if (_websocketProtocolHandler is null)
+        {
+            await InitializeWebSocket().ConfigureAwait(false);
+        }
+
+        await _websocketProtocolHandler.SendPongAsync(payload);
+    }
+
+    /// <summary>
+    /// Send a regular GraphQL request (query, mutation) via websocket
+    /// </summary>
+    /// <typeparam name="TResponse">the response type</typeparam>
+    /// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
+    /// <param name="cancellationToken">the token to cancel the request</param>
+    /// <returns></returns>
+    public async Task<GraphQLResponse<TResponse>> SendRequestAsync<TResponse>(GraphQLRequest request,
+        CancellationToken cancellationToken = default)
+    {
+        if (_websocketProtocolHandler is null)
+        {
+            await InitializeWebSocket().ConfigureAwait(false);
+        }
+
+        return await _websocketProtocolHandler.CreateGraphQLRequestObservable<TResponse>(request)
+            // complete sequence on OperationCanceledException, this is triggered by the cancellation token
+            .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
+                Observable.Empty<GraphQLResponse<TResponse>>())
+            .FirstAsync()
+            .ToTask(cancellationToken);
+    }
+
     /// <summary>
     /// Create a new subscription stream
     /// </summary>
@@ -89,109 +163,14 @@ public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClient client)
     /// <param name="exceptionHandler">Optional: exception handler for handling exceptions within the receive pipeline</param>
     /// <returns>a <see cref="IObservable{TResponse}"/> which represents the subscription</returns>
     public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TResponse>(GraphQLRequest request, Action<Exception>? exceptionHandler = null) =>
-        Observable.Defer(() =>
-                Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+        Observable.Defer(async () =>
+            {
+                if (_websocketProtocolHandler is null)
                 {
-                    Debug.WriteLine($"Create observable thread id: {Environment.CurrentManagedThreadId}");
-                    var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
-
-                    var startRequest = new GraphQLWebSocketRequest
-                    {
-                        Id = Guid.NewGuid().ToString("N"),
-                        Type = GraphQLWebSocketMessageType.GQL_START,
-                        Payload = preprocessedRequest
-                    };
-                    var stopRequest = new GraphQLWebSocketRequest
-                    {
-                        Id = startRequest.Id,
-                        Type = GraphQLWebSocketMessageType.GQL_STOP
-                    };
-
-                    var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
-                        IncomingMessageStream
-                            // ignore null values and messages for other requests
-                            .Where(response => response != null && response.Id == startRequest.Id)
-                            .Subscribe(response =>
-                                {
-                                    // terminate the sequence when a 'complete' message is received
-                                    if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-                                    {
-                                        Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
-                                        o.OnCompleted();
-                                        return;
-                                    }
-
-                                    // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
-                                    Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Environment.CurrentManagedThreadId})");
-                                    var typedResponse =
-                                        _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-                                            response.MessageBytes);
-                                    Debug.WriteLine($"payload => {System.Text.Encoding.UTF8.GetString(response.MessageBytes)}");
-                                    o.OnNext(typedResponse.Payload);
-
-                                    // in case of a GraphQL error, terminate the sequence after the response has been posted
-                                    if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
-                                    {
-                                        Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
-                                        o.OnCompleted();
-                                    }
-                                },
-                                e =>
-                                {
-                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
-                                    o.OnError(e);
-                                },
-                                () =>
-                                {
-                                    Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
-                                    o.OnCompleted();
-                                })
-                    );
-
-                    try
-                    {
-                        // initialize websocket (completes immediately if socket is already open)
-                        await InitializeWebSocket().ConfigureAwait(false);
-                    }
-                    catch (Exception e)
-                    {
-                        // subscribe observer to failed observable
-                        return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-                    }
-
-                    var disposable = new CompositeDisposable(
-                        observable.Subscribe(observer),
-                        Disposable.Create(async () =>
-                        {
-                            Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{WebSocketState}'");
-                            // only try to send close request on open websocket
-                            if (WebSocketState != WebSocketState.Open)
-                                return;
-
-                            try
-                            {
-                                Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
-                                await QueueWebSocketRequest(stopRequest).ConfigureAwait(false);
-                            }
-                            // do not break on disposing
-                            catch (OperationCanceledException) { }
-                        })
-                    );
-
-                    Debug.WriteLine($"sending start message on subscription {startRequest.Id}");
-                    // send subscription request
-                    try
-                    {
-                        await QueueWebSocketRequest(startRequest).ConfigureAwait(false);
-                    }
-                    catch (Exception e)
-                    {
-                        Debug.WriteLine(e);
-                        throw;
-                    }
-
-                    return disposable;
-                }))
+                    await InitializeWebSocket().ConfigureAwait(false);
+                }
+                return _websocketProtocolHandler?.CreateSubscriptionObservable<TResponse>(request);
+            })
             // complete sequence on OperationCanceledException, this is triggered by the cancellation token
             .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
                 Observable.Empty<GraphQLResponse<TResponse>>())
@@ -206,7 +185,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                     {
                         // if the external handler is not set, propagate all exceptions except WebSocketExceptions
                         // this will ensure that the client tries to re-establish subscriptions on connection loss
-                        if (e is not WebSocketException)
+                        if (!(e is WebSocketException))
                             throw e;
                     }
                     else
@@ -217,12 +196,10 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
 
                     // throw exception on the observable to be caught by Retry() or complete sequence if cancellation was requested
                     if (_internalCancellationToken.IsCancellationRequested)
-                    {
                         return Observable.Empty<Tuple<GraphQLResponse<TResponse>, Exception>>();
-                    }
                     else
                     {
-                        Debug.WriteLine($"Catch handler thread id: {Environment.CurrentManagedThreadId}");
+                        Debug.WriteLine($"Catch handler thread id: {Thread.CurrentThread.ManagedThreadId}");
                         return Observable.Throw<Tuple<GraphQLResponse<TResponse>, Exception>>(e);
                     }
                 }
@@ -240,87 +217,24 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
                 // if the result contains an exception, throw it on the observable
                 if (t.Item2 != null)
                 {
-                    Debug.WriteLine($"unwrap exception thread id: {Environment.CurrentManagedThreadId} => {t.Item2}");
+                    Debug.WriteLine($"unwrap exception thread id: {Thread.CurrentThread.ManagedThreadId} => {t.Item2}");
                     return Observable.Throw<GraphQLResponse<TResponse>>(t.Item2);
                 }
                 if (t.Item1 == null)
                 {
-                    Debug.WriteLine($"empty item thread id: {Environment.CurrentManagedThreadId}");
+                    Debug.WriteLine($"empty item thread id: {Thread.CurrentThread.ManagedThreadId}");
                     return Observable.Empty<GraphQLResponse<TResponse>>();
                 }
                 return Observable.Return(t.Item1);
             });
-    /// <summary>
-    /// Send a regular GraphQL request (query, mutation) via websocket
-    /// </summary>
-    /// <typeparam name="TResponse">the response type</typeparam>
-    /// <param name="request">the <see cref="GraphQLRequest"/> to send</param>
-    /// <param name="cancellationToken">the token to cancel the request</param>
-    /// <returns></returns>
-    public Task<GraphQLResponse<TResponse>> SendRequest<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) =>
-        Observable.Create<GraphQLResponse<TResponse>>(async observer =>
-        {
-            var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
-            var websocketRequest = new GraphQLWebSocketRequest
-            {
-                Id = Guid.NewGuid().ToString("N"),
-                Type = GraphQLWebSocketMessageType.GQL_START,
-                Payload = preprocessedRequest
-            };
-            var observable = IncomingMessageStream
-                .Where(response => response != null && response.Id == websocketRequest.Id)
-                .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
-                .Select(response =>
-                {
-                    Debug.WriteLine($"received response for request {websocketRequest.Id}");
-                    var typedResponse =
-                        _client.JsonSerializer.DeserializeToWebsocketResponse<TResponse>(
-                            response.MessageBytes);
-                    return typedResponse.Payload;
-                });
-
-            try
-            {
-                // initialize websocket (completes immediately if socket is already open)
-                await InitializeWebSocket().ConfigureAwait(false);
-            }
-            catch (Exception e)
-            {
-                // subscribe observer to failed observable
-                return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
-            }
-
-            var disposable = new CompositeDisposable(
-                observable.Subscribe(observer)
-            );
-
-            Debug.WriteLine($"submitting request {websocketRequest.Id}");
-            // send request
-            try
-            {
-                await QueueWebSocketRequest(websocketRequest).ConfigureAwait(false);
-            }
-            catch (Exception e)
-            {
-                Debug.WriteLine(e);
-                throw;
-            }
 
-            return disposable;
-        })
-            // complete sequence on OperationCanceledException, this is triggered by the cancellation token
-            .Catch<GraphQLResponse<TResponse>, OperationCanceledException>(exception =>
-                Observable.Empty<GraphQLResponse<TResponse>>())
-            .FirstAsync()
-            .ToTask(cancellationToken);
-
-    private Task QueueWebSocketRequest(GraphQLWebSocketRequest request)
+    protected Task QueueWebSocketRequest(GraphQLWebSocketRequest request)
     {
         _requestSubject.OnNext(request);
         return request.SendTask();
     }
 
-    private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
+    protected async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest request)
     {
         try
         {
@@ -341,9 +255,9 @@ private async Task<Unit> SendWebSocketRequestAsync(GraphQLWebSocketRequest reque
         return Unit.Default;
     }
 
-    private async Task SendWebSocketMessageAsync(GraphQLWebSocketRequest request, CancellationToken cancellationToken = default)
+    protected async Task SendWebSocketMessageAsync(GraphQLWebSocketRequest request, CancellationToken cancellationToken = default)
     {
-        byte[] requestBytes = _client.JsonSerializer.SerializeToBytes(request);
+        var requestBytes = _client.JsonSerializer.SerializeToBytes(request);
         await _clientWebSocket.SendAsync(
             new ArraySegment<byte>(requestBytes),
             WebSocketMessageType.Text,
@@ -365,9 +279,7 @@ public Task InitializeWebSocket()
             if (_initializeWebSocketTask != null &&
                !_initializeWebSocketTask.IsFaulted &&
                !_initializeWebSocketTask.IsCompleted)
-            {
                 return _initializeWebSocketTask;
-            }
 
             // if the websocket is open, return a completed task
             if (_clientWebSocket != null && _clientWebSocket.State == WebSocketState.Open)
@@ -383,24 +295,22 @@ public Task InitializeWebSocket()
             switch (_clientWebSocket)
             {
                 case ClientWebSocket nativeWebSocket:
-                    nativeWebSocket.Options.AddSubProtocol("graphql-ws");
+                    ConfigureWebSocketSubProtocols(nativeWebSocket.Options.AddSubProtocol);
                     nativeWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
                     nativeWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                     Options.ConfigureWebsocketOptions(nativeWebSocket.Options);
                     break;
-
                 case System.Net.WebSockets.Managed.ClientWebSocket managedWebSocket:
-                    managedWebSocket.Options.AddSubProtocol("graphql-ws");
+                    ConfigureWebSocketSubProtocols(managedWebSocket.Options.AddSubProtocol);
                     managedWebSocket.Options.ClientCertificates = ((HttpClientHandler)Options.HttpMessageHandler).ClientCertificates;
                     managedWebSocket.Options.UseDefaultCredentials = ((HttpClientHandler)Options.HttpMessageHandler).UseDefaultCredentials;
                     break;
-
                 default:
                     throw new NotSupportedException($"unknown websocket type {_clientWebSocket.GetType().Name}");
             }
 #else
             _clientWebSocket = new ClientWebSocket();
-            _clientWebSocket.Options.AddSubProtocol("graphql-ws");
+            ConfigureWebSocketSubProtocols(_clientWebSocket.Options.AddSubProtocol);
 
             // the following properties are not supported in Blazor WebAssembly and throw a PlatformNotSupportedException error when accessed
             try
@@ -432,25 +342,53 @@ public Task InitializeWebSocket()
             }
 
             Options.ConfigureWebsocketOptions(_clientWebSocket.Options);
+
 #endif
             return _initializeWebSocketTask = ConnectAsync(_internalCancellationToken);
         }
     }
 
-    private async Task ConnectAsync(CancellationToken token)
+    public void ConfigureWebSocketSubProtocols(Action<string> addSubProtocol)
+    {
+        if (_client.Options.WebSocketProtocol is null)
+        {
+            foreach (string protocol in WebSocketProtocols.GetSupportedWebSocketProtocols())
+            {
+                addSubProtocol(protocol);
+            }
+        }
+        else
+            addSubProtocol(_client.Options.WebSocketProtocol);
+    }
+
+
+    protected async Task ConnectAsync(CancellationToken token)
     {
         try
         {
+            //Client sends a WebSocket handshake request with the sub-protocol: graphql-transport-ws
             await BackOff().ConfigureAwait(false);
             _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connecting);
-            Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Environment.CurrentManagedThreadId})");
+            Debug.WriteLine($"opening websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})");
             await _clientWebSocket.ConnectAsync(_webSocketUri, token).ConfigureAwait(false);
+            // check negotiated sub protocol and create matching instance of IWebsocketProtocolHandler
+            _websocketProtocolHandler = _clientWebSocket.SubProtocol switch
+            {
+                WebSocketProtocols.GRAPHQL_WS
+                    => new GraphQLWSProtocolHandler(this, _client, QueueWebSocketRequest, SendWebSocketMessageAsync),
+                WebSocketProtocols.GRAPHQL_TRANSPORT_WS
+                    => new GraphQLTransportWSProtocolHandler(this, _client, QueueWebSocketRequest, SendWebSocketMessageAsync),
+                _ => throw new NotSupportedException(
+                    $"negotiated websocket protocol \"{_clientWebSocket.SubProtocol}\" not supported")
+            };
             _stateSubject.OnNext(GraphQLWebsocketConnectionState.Connected);
             Debug.WriteLine($"connection established on websocket {_clientWebSocket.GetHashCode()}, invoking Options.OnWebsocketConnected()");
             await (Options.OnWebsocketConnected?.Invoke(_client) ?? Task.CompletedTask).ConfigureAwait(false);
             Debug.WriteLine($"invoking Options.OnWebsocketConnected() on websocket {_clientWebSocket.GetHashCode()}");
             _connectionAttempt = 1;
 
+            // Client immediately dispatches a ConnectionInit message optionally providing a payload as agreed with the server
+
             // create receiving observable
             _incomingMessages = Observable
                 .Defer(() => GetReceiveTask().ToObservable())
@@ -479,37 +417,10 @@ private async Task ConnectAsync(CancellationToken token)
             var connection = _incomingMessages.Connect();
             Debug.WriteLine($"new incoming message stream {_incomingMessages.GetHashCode()} created");
 
-            _incomingMessagesConnection = new CompositeDisposable(maintenanceSubscription, connection);
-
-            var initRequest = new GraphQLWebSocketRequest
-            {
-                Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
-                Payload = Options.ConfigureWebSocketConnectionInitPayload(Options)
-            };
-
-            // setup task to await connection_ack message
-            var ackTask = _incomingMessages
-                .Where(response => response != null)
-                .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
-                                       response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
-                .LastAsync()
-                .ToTask();
+            var closeConnectionDisposable = new CompositeDisposable();
+            _incomingMessagesConnection = new CompositeDisposable(connection, maintenanceSubscription, closeConnectionDisposable);
 
-            // send connection init
-            Debug.WriteLine($"sending connection init message");
-            await SendWebSocketMessageAsync(initRequest, CancellationToken.None).ConfigureAwait(false);
-            var response = await ackTask.ConfigureAwait(false);
-
-            if (response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
-            {
-                Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
-            }
-            else
-            {
-                string errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
-                Debug.WriteLine($"connection error received: {errorPayload}");
-                throw new GraphQLWebsocketConnectionException(errorPayload);
-            }
+            await _websocketProtocolHandler.InitializeConnectionAsync(_incomingMessages, closeConnectionDisposable).ConfigureAwait(false);
         }
         catch (Exception e)
         {
@@ -520,11 +431,12 @@ private async Task ConnectAsync(CancellationToken token)
         }
     }
 
+
     /// <summary>
     /// delay the next connection attempt using <see cref="GraphQLHttpClientOptions.BackOffStrategy"/>
     /// </summary>
     /// <returns></returns>
-    private Task BackOff()
+    protected Task BackOff()
     {
         _connectionAttempt++;
 
@@ -536,7 +448,7 @@ private Task BackOff()
         return Task.Delay(delay, _internalCancellationToken);
     }
 
-    private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
+    protected IObservable<WebsocketMessageWrapper> GetMessageStream() =>
         Observable.Create<WebsocketMessageWrapper>(async observer =>
             {
                 // make sure the websocket is connected
@@ -550,20 +462,20 @@ private IObservable<WebsocketMessageWrapper> GetMessageStream() =>
                 };
 
                 // add some debug output
-                int hashCode = subscription.GetHashCode();
+                var hashCode = subscription.GetHashCode();
                 subscription.Add(Disposable.Create(() => Debug.WriteLine($"incoming message subscription {hashCode} disposed")));
                 Debug.WriteLine($"new incoming message subscription {hashCode} created");
 
                 return subscription;
             });
 
-    private Task<WebsocketMessageWrapper> _receiveAsyncTask;
-    private readonly object _receiveTaskLocker = new();
+    protected Task<WebsocketMessageWrapper> _receiveAsyncTask = null;
+    protected readonly object _receiveTaskLocker = new();
     /// <summary>
     /// wrapper method to pick up the existing request task if already running
     /// </summary>
     /// <returns></returns>
-    private Task<WebsocketMessageWrapper> GetReceiveTask()
+    protected Task<WebsocketMessageWrapper> GetReceiveTask()
     {
         lock (_receiveTaskLocker)
         {
@@ -571,9 +483,7 @@ private Task<WebsocketMessageWrapper> GetReceiveTask()
             if (_receiveAsyncTask == null ||
                 _receiveAsyncTask.IsFaulted ||
                 _receiveAsyncTask.IsCompleted)
-            {
                 _receiveAsyncTask = ReceiveWebsocketMessagesAsync();
-            }
         }
 
         return _receiveAsyncTask;
@@ -583,13 +493,13 @@ private Task<WebsocketMessageWrapper> GetReceiveTask()
     /// read a single message from the websocket
     /// </summary>
     /// <returns></returns>
-    private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
+    protected async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
     {
         _internalCancellationToken.ThrowIfCancellationRequested();
 
         try
         {
-            Debug.WriteLine($"waiting for data on websocket {_clientWebSocket.GetHashCode()} (thread {Environment.CurrentManagedThreadId})...");
+            Debug.WriteLine($"waiting for data on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
 
             using var ms = new MemoryStream();
             WebSocketReceiveResult webSocketReceiveResult = null;
@@ -609,12 +519,21 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
                 case WebSocketMessageType.Text:
                     var response = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
                     response.MessageBytes = ms.ToArray();
-                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Environment.CurrentManagedThreadId})...");
+                    Debug.WriteLine($"{response.MessageBytes.Length} bytes received for id {response.Id} on websocket {_clientWebSocket.GetHashCode()} (thread {Thread.CurrentThread.ManagedThreadId})...");
                     return response;
 
                 case WebSocketMessageType.Close:
-                    var closeResponse = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
-                    closeResponse.MessageBytes = ms.ToArray();
+                    WebsocketMessageWrapper closeResponse = null;
+                    try
+                    {
+                        closeResponse = await _client.JsonSerializer.DeserializeToWebsocketResponseWrapperAsync(ms).ConfigureAwait(false);
+                    }
+                    catch (Exception e)
+                    {
+                        Console.WriteLine(e);
+                    }
+                    if (closeResponse != null)
+                        closeResponse.MessageBytes = ms.ToArray();
                     Debug.WriteLine($"Connection closed by the server.");
                     throw new Exception("Connection closed by the server.");
 
@@ -630,7 +549,7 @@ private async Task<WebsocketMessageWrapper> ReceiveWebsocketMessagesAsync()
         }
     }
 
-    private async Task CloseAsync()
+    protected async Task CloseAsync()
     {
         if (_clientWebSocket == null)
             return;
@@ -644,12 +563,16 @@ private async Task CloseAsync()
             return;
         }
 
-        Debug.WriteLine($"send \"connection_terminate\" message");
-        await SendWebSocketMessageAsync(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE }).ConfigureAwait(false);
+        if (_websocketProtocolHandler is not null)
+        {
+            Debug.WriteLine($"send \"connection_terminate\" message");
+            await _websocketProtocolHandler.SendCloseConnectionRequestAsync().ConfigureAwait(false);
+        }
 
         Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
         await _clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false);
         _stateSubject.OnNext(GraphQLWebsocketConnectionState.Disconnected);
+
     }
 
     #region IDisposable
@@ -671,10 +594,10 @@ public void Complete()
     /// Task to await the completion (a.k.a. disposal) of this websocket.
     /// </summary>
     /// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
-    public Task? Completion { get; private set; }
+    public Task? Completion { get; protected set; }
 
-    private readonly object _completedLocker = new();
-    private async Task CompleteAsync()
+    protected readonly object _completedLocker = new();
+    protected async Task CompleteAsync()
     {
         Debug.WriteLine("disposing GraphQLHttpWebSocket...");
 
diff --git a/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs b/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
new file mode 100644
index 00000000..c78581b1
--- /dev/null
+++ b/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
@@ -0,0 +1,321 @@
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
+using System.Text;
+using GraphQL.Client.Abstractions.Websocket;
+
+namespace GraphQL.Client.Http.Websocket;
+
+internal class GraphQLTransportWSProtocolHandler: IWebsocketProtocolHandler
+{
+    public string WebsocketProtocol => WebSocketProtocols.GRAPHQL_TRANSPORT_WS;
+
+    private readonly GraphQLHttpWebSocket _webSocketHandler;
+    private readonly GraphQLHttpClient _client;
+    private readonly Func<GraphQLWebSocketRequest, Task> _queueWebSocketRequest;
+    private readonly Func<GraphQLWebSocketRequest, CancellationToken, Task> _sendWebsocketMessage;
+
+    public GraphQLTransportWSProtocolHandler(
+        GraphQLHttpWebSocket webSocketHandler,
+        GraphQLHttpClient client,
+        Func<GraphQLWebSocketRequest, Task> queueWebSocketRequest,
+        Func<GraphQLWebSocketRequest, CancellationToken, Task> sendWebsocketMessage)
+    {
+        _webSocketHandler = webSocketHandler;
+        _client = client;
+        _queueWebSocketRequest = queueWebSocketRequest;
+        _sendWebsocketMessage = sendWebsocketMessage;
+    }
+
+    public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionObservable<TResponse>(GraphQLRequest request)
+        => Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+        {
+            Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
+            var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
+
+
+            var startRequest = new GraphQLWebSocketRequest
+            {
+                Id = Guid.NewGuid().ToString("N"),
+                Type = GraphQLWebSocketMessageType.GQL_SUBSCRIBE,
+                Payload = preprocessedRequest
+            };
+
+
+            var stopRequest = new GraphQLWebSocketRequest
+            {
+                Id = startRequest.Id,
+                Type = GraphQLWebSocketMessageType.GQL_COMPLETE
+            };
+
+            var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
+                _webSocketHandler.IncomingMessageStream
+                    // ignore null values and messages for other requests
+                    .Where(response => response != null && response.Id == startRequest.Id)
+                    .Subscribe(response =>
+                    {
+                        // terminate the sequence when a 'complete' message is received
+                        if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                        {
+                            Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+                            o.OnCompleted();
+                            return;
+                        }
+
+                        if (!(response.Type == GraphQLWebSocketMessageType.GQL_NEXT || response.Type == GraphQLWebSocketMessageType.GQL_ERROR))
+                            throw new WebSocketException("Did not receive 'next' nor 'error'");
+
+                        switch (response.Type)
+                        {
+                            case GraphQLWebSocketMessageType.GQL_NEXT:
+                                // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+                                Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+                                var typedResponse = _client.JsonSerializer.DeserializeToWebsocketResponse<GraphQLResponse<TResponse>>(response.MessageBytes);
+                                Debug.WriteLine($"payload => {Encoding.UTF8.GetString(response.MessageBytes)}");
+                                o.OnNext(typedResponse.Payload);
+                                break;
+                            case GraphQLWebSocketMessageType.GQL_ERROR:
+                                // the payload only consists of the error array
+                                Debug.WriteLine($"received error on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+                                Debug.WriteLine($"payload => {Encoding.UTF8.GetString(response.MessageBytes)}");
+                                var errorResponse = _client.JsonSerializer.DeserializeToWebsocketResponse<GraphQLError[]>(response.MessageBytes);
+                                o.OnNext(new GraphQLResponse<TResponse> { Errors = errorResponse.Payload });
+                                // in case of a GraphQL error, terminate the sequence after the response has been posted
+                                Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+                                o.OnCompleted();
+                                break;
+                            default:
+                                // If the message type was not 'complete', then it must only be 'next' or 'error'
+                                throw new WebSocketException("Did not receive 'next' nor 'error'");
+                        }
+                    },
+                        e =>
+                        {
+                            Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
+                            o.OnError(e);
+                        },
+                        () =>
+                        {
+                            Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+                            o.OnCompleted();
+                        })
+            );
+
+            try
+            {
+                // initialize websocket (completes immediately if socket is already open)
+                await _webSocketHandler.InitializeWebSocket().ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                // subscribe observer to failed observable
+                return (CompositeDisposable)Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+            }
+
+            var disposable = new CompositeDisposable(
+                observable.Subscribe(observer),
+                Disposable.Create(async () =>
+                {
+                    Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{_webSocketHandler.WebSocketState}'");
+                    // only try to send close request on open websocket
+                    if (_webSocketHandler.WebSocketState != WebSocketState.Open)
+                        return;
+
+                    try
+                    {
+                        Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
+                        await _queueWebSocketRequest(stopRequest).ConfigureAwait(false);
+                    }
+                    // do not break on disposing
+                    catch (OperationCanceledException) { }
+                })
+            );
+
+            Debug.WriteLine($"sending start message on subscription {startRequest.Id}");
+            // send subscription request
+            try
+            {
+                await _queueWebSocketRequest(startRequest).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine(e);
+                throw;
+            }
+
+            return disposable;
+        });
+
+    public IObservable<GraphQLResponse<TResponse>> CreateGraphQLRequestObservable<TResponse>(GraphQLRequest request)
+        => Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+        {
+            var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
+            var websocketRequest = new GraphQLWebSocketRequest
+            {
+                Id = Guid.NewGuid().ToString("N"),
+                Type = GraphQLWebSocketMessageType.GQL_SUBSCRIBE,
+                Payload = preprocessedRequest
+            };
+            var observable = _webSocketHandler.IncomingMessageStream
+                .Where(response => response != null && response.Id == websocketRequest.Id)
+                .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                .Select(response =>
+                {
+                    Debug.WriteLine($"received response for request {websocketRequest.Id}");
+                    switch (response.Type)
+                    {
+                        case GraphQLWebSocketMessageType.GQL_NEXT:
+                            var typedResponse = _client.JsonSerializer.DeserializeToWebsocketResponse<GraphQLResponse<TResponse>>(response.MessageBytes);
+                            return typedResponse.Payload;
+                        case GraphQLWebSocketMessageType.GQL_ERROR:
+                            // the payload only consists of the error array
+                            var errorResponse = _client.JsonSerializer.DeserializeToWebsocketResponse<GraphQLError[]>(response.MessageBytes);
+                            return new GraphQLResponse<TResponse> { Errors = errorResponse.Payload };
+                    }
+                    return null;
+                });
+
+            try
+            {
+                // initialize websocket (completes immediately if socket is already open)
+                await _webSocketHandler.InitializeWebSocket().ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                // subscribe observer to failed observable
+                return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+            }
+
+            var disposable = new CompositeDisposable(
+                observable.Subscribe(observer)
+            );
+
+            Debug.WriteLine($"submitting request {websocketRequest.Id}");
+            // send request
+            try
+            {
+                await _queueWebSocketRequest(websocketRequest).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine(e);
+                throw;
+            }
+
+            return disposable;
+        });
+
+    public IObservable<object?> CreatePongObservable()
+        => _webSocketHandler.IncomingMessageStream
+            .Where(msg => msg != null && msg.Type == GraphQLWebSocketMessageType.GQL_PONG)
+            .Select(msg =>
+            {
+                object? payload = null;
+                try
+                {
+                    // try to deserialize response to put it back in the pong request
+                    var responseObject =
+                        _client.JsonSerializer.DeserializeToWebsocketResponse<object?>(msg.MessageBytes);
+                    payload = responseObject.Payload;
+                }
+                catch (Exception)
+                {
+                    // ignore exception
+                }
+
+                return payload;
+            });
+
+    public async Task InitializeConnectionAsync(IObservable<WebsocketMessageWrapper> incomingMessages,
+        CompositeDisposable closeConnectionDisposable)
+    {
+        var initRequest = new GraphQLWebSocketRequest
+        {
+            Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+            Payload = _client.Options.ConfigureWebSocketConnectionInitPayload(_client.Options)
+        };
+
+        // setup task to await connection_ack message
+        var ackTask = incomingMessages
+            .Where(response => response != null)
+            .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
+                                   response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
+            .LastAsync()
+            .ToTask();
+
+        // send connection init
+        Debug.WriteLine($"sending connection init message");
+        await _sendWebsocketMessage(initRequest, CancellationToken.None).ConfigureAwait(false);
+        var response = await ackTask.ConfigureAwait(false);
+
+        if (response.Type != GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
+        {
+            string? errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
+            Debug.WriteLine($"connection error received: {errorPayload}");
+            throw new GraphQLWebsocketConnectionException(errorPayload);
+        }
+
+        Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
+
+        closeConnectionDisposable.Add(incomingMessages
+            .Where(msg => msg != null && msg.Type == GraphQLWebSocketMessageType.GQL_PING)
+            .SelectMany(msg => Observable.FromAsync(() => RespondWithPongAsync(msg)))
+            .Subscribe());
+    }
+
+    public Task SendCloseConnectionRequestAsync()
+        => _sendWebsocketMessage(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_COMPLETE }, CancellationToken.None);
+
+    private async Task RespondWithPongAsync(WebsocketMessageWrapper pingMessage)
+    {
+        // respond with a PONG when a ping is received
+        if (pingMessage.Type == GraphQLWebSocketMessageType.GQL_PING)
+        {
+            object? payload = null;
+            try
+            {
+                // try to deserialize response to put it back in the pong request
+                var responseObject = _client.JsonSerializer.DeserializeToWebsocketResponse<object?>(pingMessage.MessageBytes);
+                payload = responseObject.Payload;
+            }
+            catch (Exception)
+            {
+                // ignore exception
+            }
+            Debug.WriteLine($"ping received, responding with pong");
+            var pongRequest = new GraphQLWebSocketRequest
+            {
+                Type = GraphQLWebSocketMessageType.GQL_PONG,
+                Payload = payload
+            };
+
+            await _queueWebSocketRequest(pongRequest).ConfigureAwait(false);
+        }
+    }
+
+    public Task SendPingAsync(object? payload)
+    {
+        Debug.WriteLine("sending ping");
+        var webSocketRequest = new GraphQLWebSocketRequest
+        {
+            Type = GraphQLWebSocketMessageType.GQL_PING,
+            Payload = payload
+        };
+
+        return _queueWebSocketRequest(webSocketRequest);
+    }
+
+    public Task SendPongAsync(object? payload)
+    {
+        Debug.WriteLine("sending pong");
+        var webSocketRequest = new GraphQLWebSocketRequest
+        {
+            Type = GraphQLWebSocketMessageType.GQL_PONG,
+            Payload = payload
+        };
+
+        return _queueWebSocketRequest(webSocketRequest);
+    }
+}
diff --git a/src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs b/src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs
new file mode 100644
index 00000000..03efdba4
--- /dev/null
+++ b/src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs
@@ -0,0 +1,235 @@
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Disposables;
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
+using System.Text;
+using GraphQL.Client.Abstractions.Websocket;
+
+namespace GraphQL.Client.Http.Websocket;
+
+internal class GraphQLWSProtocolHandler : IWebsocketProtocolHandler
+{
+    public string WebsocketProtocol => WebSocketProtocols.GRAPHQL_WS;
+
+    private readonly GraphQLHttpWebSocket _webSocketHandler;
+    private readonly GraphQLHttpClient _client;
+    private readonly Func<GraphQLWebSocketRequest, Task> _queueWebSocketRequest;
+    private readonly Func<GraphQLWebSocketRequest, CancellationToken, Task> _sendWebsocketMessage;
+
+    public GraphQLWSProtocolHandler(
+        GraphQLHttpWebSocket webSocketHandler,
+        GraphQLHttpClient client,
+        Func<GraphQLWebSocketRequest, Task> queueWebSocketRequest,
+        Func<GraphQLWebSocketRequest, CancellationToken, Task> sendWebsocketMessage)
+    {
+        _webSocketHandler = webSocketHandler;
+        _client = client;
+        _queueWebSocketRequest = queueWebSocketRequest;
+        _sendWebsocketMessage = sendWebsocketMessage;
+    }
+
+    public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionObservable<TResponse>(GraphQLRequest request)
+        => Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+        {
+            Debug.WriteLine($"Create observable thread id: {Thread.CurrentThread.ManagedThreadId}");
+            var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
+
+            var startRequest = new GraphQLWebSocketRequest
+            {
+                Id = Guid.NewGuid().ToString("N"),
+                Type = GraphQLWebSocketMessageType.GQL_START,
+                Payload = preprocessedRequest
+            };
+            var stopRequest = new GraphQLWebSocketRequest
+            {
+                Id = startRequest.Id,
+                Type = GraphQLWebSocketMessageType.GQL_STOP
+            };
+
+            var observable = Observable.Create<GraphQLResponse<TResponse>>(o =>
+                _webSocketHandler.IncomingMessageStream
+                    // ignore null values and messages for other requests
+                    .Where(response => response != null && response.Id == startRequest.Id)
+                    .Subscribe(response =>
+                    {
+                        // terminate the sequence when a 'complete' message is received
+                        if (response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                        {
+                            Debug.WriteLine($"received 'complete' message on subscription {startRequest.Id}");
+                            o.OnCompleted();
+                            return;
+                        }
+
+                        // post the GraphQLResponse to the stream (even if a GraphQL error occurred)
+                        Debug.WriteLine($"received payload on subscription {startRequest.Id} (thread {Thread.CurrentThread.ManagedThreadId})");
+                        var typedResponse =
+                                    _client.JsonSerializer.DeserializeToWebsocketResponse<GraphQLResponse<TResponse>>(
+                                        response.MessageBytes);
+                        Debug.WriteLine($"payload => {System.Text.Encoding.UTF8.GetString(response.MessageBytes)}");
+                        o.OnNext(typedResponse.Payload);
+
+                        // in case of a GraphQL error, terminate the sequence after the response has been posted
+                        if (response.Type == GraphQLWebSocketMessageType.GQL_ERROR)
+                        {
+                            Debug.WriteLine($"terminating subscription {startRequest.Id} because of a GraphQL error");
+                            o.OnCompleted();
+                        }
+                    },
+                        e =>
+                        {
+                            Debug.WriteLine($"response stream for subscription {startRequest.Id} failed: {e}");
+                            o.OnError(e);
+                        },
+                        () =>
+                        {
+                            Debug.WriteLine($"response stream for subscription {startRequest.Id} completed");
+                            o.OnCompleted();
+                        })
+            );
+
+            try
+            {
+                // initialize websocket (completes immediately if socket is already open)
+                await _webSocketHandler.InitializeWebSocket().ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                // subscribe observer to failed observable
+                return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+            }
+
+            var disposable = new CompositeDisposable(
+                observable.Subscribe(observer),
+                Disposable.Create(async () =>
+                {
+                    Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{_webSocketHandler.WebSocketState}'");
+                    // only try to send close request on open websocket
+                    if (_webSocketHandler.WebSocketState != WebSocketState.Open)
+                        return;
+
+                    try
+                    {
+                        Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
+                        await _queueWebSocketRequest(stopRequest).ConfigureAwait(false);
+                    }
+                    // do not break on disposing
+                    catch (OperationCanceledException) { }
+                })
+            );
+
+            Debug.WriteLine($"sending start message on subscription {startRequest.Id}");
+            // send subscription request
+            try
+            {
+                await _queueWebSocketRequest(startRequest).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine(e);
+                throw;
+            }
+
+            return disposable;
+        });
+
+    public IObservable<GraphQLResponse<TResponse>> CreateGraphQLRequestObservable<TResponse>(GraphQLRequest request)
+        => Observable.Create<GraphQLResponse<TResponse>>(async observer =>
+        {
+            var preprocessedRequest = await _client.Options.PreprocessRequest(request, _client).ConfigureAwait(false);
+            var websocketRequest = new GraphQLWebSocketRequest
+            {
+                Id = Guid.NewGuid().ToString("N"),
+                Type = GraphQLWebSocketMessageType.GQL_START,
+                Payload = preprocessedRequest
+            };
+            var observable = _webSocketHandler.IncomingMessageStream
+                .Where(response => response != null && response.Id == websocketRequest.Id)
+                .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_COMPLETE)
+                .Select(response =>
+                {
+                    Debug.WriteLine($"received response for request {websocketRequest.Id}");
+                    var typedResponse =
+                        _client.JsonSerializer.DeserializeToWebsocketResponse<GraphQLResponse<TResponse>>(
+                            response.MessageBytes);
+                    return typedResponse.Payload;
+                });
+
+            try
+            {
+                // initialize websocket (completes immediately if socket is already open)
+                await _webSocketHandler.InitializeWebSocket().ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                // subscribe observer to failed observable
+                return Observable.Throw<GraphQLResponse<TResponse>>(e).Subscribe(observer);
+            }
+
+            var disposable = new CompositeDisposable(
+                observable.Subscribe(observer)
+            );
+
+            Debug.WriteLine($"submitting request {websocketRequest.Id}");
+            // send request
+            try
+            {
+                await _queueWebSocketRequest(websocketRequest).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                Debug.WriteLine(e);
+                throw;
+            }
+
+            return disposable;
+        });
+
+
+    public async Task InitializeConnectionAsync(IObservable<WebsocketMessageWrapper> incomingMessages,
+        CompositeDisposable closeConnectionDisposable)
+    {
+        var initRequest = new GraphQLWebSocketRequest
+        {
+            Type = GraphQLWebSocketMessageType.GQL_CONNECTION_INIT,
+            Payload = _client.Options.ConfigureWebSocketConnectionInitPayload(_client.Options)
+        };
+
+        // setup task to await connection_ack message
+        var ackTask = incomingMessages
+            .Where(response => response != null)
+            .TakeUntil(response => response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ACK ||
+                                   response.Type == GraphQLWebSocketMessageType.GQL_CONNECTION_ERROR)
+            .LastAsync()
+            .ToTask();
+
+        // send connection init
+        Debug.WriteLine($"sending connection init message");
+        await _sendWebsocketMessage(initRequest, CancellationToken.None).ConfigureAwait(false);
+        var response = await ackTask.ConfigureAwait(false);
+
+        if (response.Type != GraphQLWebSocketMessageType.GQL_CONNECTION_ACK)
+        {
+            string? errorPayload = Encoding.UTF8.GetString(response.MessageBytes);
+            Debug.WriteLine($"connection error received: {errorPayload}");
+            throw new GraphQLWebsocketConnectionException(errorPayload);
+        }
+
+        Debug.WriteLine($"connection acknowledged: {Encoding.UTF8.GetString(response.MessageBytes)}");
+    }
+
+    public Task SendCloseConnectionRequestAsync()
+        => _sendWebsocketMessage(new GraphQLWebSocketRequest { Type = GraphQLWebSocketMessageType.GQL_CONNECTION_TERMINATE }, CancellationToken.None);
+
+    public IObservable<object?> CreatePongObservable()
+        => throw PingPongNotSupportedException;
+
+    public Task SendPingAsync(object? payload)
+        => throw PingPongNotSupportedException;
+
+    public Task SendPongAsync(object? payload)
+        => throw PingPongNotSupportedException;
+
+    private NotSupportedException PingPongNotSupportedException
+        => new("ping/pong is not supported by the \"graphql-ws\" websocket protocol");
+}
diff --git a/src/GraphQL.Client/Websocket/IWebsocketProtocolHandler.cs b/src/GraphQL.Client/Websocket/IWebsocketProtocolHandler.cs
new file mode 100644
index 00000000..dc097ee4
--- /dev/null
+++ b/src/GraphQL.Client/Websocket/IWebsocketProtocolHandler.cs
@@ -0,0 +1,23 @@
+using System.Reactive.Disposables;
+using GraphQL.Client.Abstractions.Websocket;
+
+namespace GraphQL.Client.Http.Websocket;
+
+public interface IWebsocketProtocolHandler
+{
+    string WebsocketProtocol { get; }
+
+    IObservable<GraphQLResponse<TResponse>> CreateSubscriptionObservable<TResponse>(GraphQLRequest request);
+
+    IObservable<GraphQLResponse<TResponse>> CreateGraphQLRequestObservable<TResponse>(GraphQLRequest request);
+
+    IObservable<object?> CreatePongObservable();
+
+    Task InitializeConnectionAsync(IObservable<WebsocketMessageWrapper> incomingMessages, CompositeDisposable closeConnectionDisposable);
+
+    Task SendCloseConnectionRequestAsync();
+
+    Task SendPingAsync(object? payload);
+
+    Task SendPongAsync(object? payload);
+}
diff --git a/src/GraphQL.Client/Websocket/WebSocketProtocols.cs b/src/GraphQL.Client/Websocket/WebSocketProtocols.cs
new file mode 100644
index 00000000..957f8708
--- /dev/null
+++ b/src/GraphQL.Client/Websocket/WebSocketProtocols.cs
@@ -0,0 +1,20 @@
+using System.Reflection;
+
+namespace GraphQL.Client.Http.Websocket;
+public static class WebSocketProtocols
+{
+    public const string AUTO_NEGOTIATE = null;
+
+    //The WebSocket sub-protocol used for the [GraphQL over WebSocket Protocol](https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md).
+    public const string GRAPHQL_TRANSPORT_WS = "graphql-transport-ws";
+
+    //The deprecated subprotocol used by [subscriptions-transport-ws](https://github.com/apollographql/subscriptions-transport-ws).
+    public const string GRAPHQL_WS = "graphql-ws";
+
+    public static IEnumerable<string> GetSupportedWebSocketProtocols() =>
+        typeof(WebSocketProtocols)
+            .GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
+            .Where(info => (info.IsLiteral || info.IsInitOnly) && info.FieldType == typeof(string))
+            .Select(f => f.IsLiteral ? (string)f.GetRawConstantValue() : (string)f.GetValue(null))
+            .Where(s => s is not null);
+}
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index b0154c2a..5f34b2ba 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -1,5 +1,6 @@
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
+using GraphQL.Client.Http.Websocket;
 using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Client.Serializer.SystemTextJson;
 using GraphQL.Client.Tests.Common;
@@ -15,6 +16,8 @@ public abstract class IntegrationServerTestFixture
 
     public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
 
+    public abstract string? WebsocketProtocol { get; }
+
     public IntegrationServerTestFixture()
     {
         Port = NetworkHelpers.GetFreeTcpPortNumber();
@@ -47,16 +50,35 @@ private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebs
     {
         if (Serializer == null)
             throw new InvalidOperationException("JSON serializer not configured");
-        return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer);
+        return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer, WebsocketProtocol);
     }
 }
 
-public class NewtonsoftIntegrationServerTestFixture : IntegrationServerTestFixture
+public class NewtonsoftGraphQLWsServerTestFixture : IntegrationServerTestFixture
+{
+    public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new NewtonsoftJsonSerializer();
+    public override string? WebsocketProtocol => WebSocketProtocols.GRAPHQL_WS;
+}
+
+public class SystemTextJsonGraphQLWsServerTestFixture : IntegrationServerTestFixture
+{
+    public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
+    public override string? WebsocketProtocol => WebSocketProtocols.GRAPHQL_WS;
+}
+
+public class NewtonsoftGraphQLTransportWsServerTestFixture : IntegrationServerTestFixture
 {
     public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new NewtonsoftJsonSerializer();
+    public override string? WebsocketProtocol => WebSocketProtocols.GRAPHQL_TRANSPORT_WS;
 }
 
-public class SystemTextJsonIntegrationServerTestFixture : IntegrationServerTestFixture
+public class SystemTextJsonGraphQLTransportWsServerTestFixture : IntegrationServerTestFixture
+{
+    public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
+    public override string? WebsocketProtocol => WebSocketProtocols.GRAPHQL_TRANSPORT_WS;
+}
+public class SystemTextJsonAutoNegotiateServerTestFixture : IntegrationServerTestFixture
 {
     public override IGraphQLWebsocketJsonSerializer Serializer { get; } = new SystemTextJsonSerializer();
+    public override string? WebsocketProtocol => WebSocketProtocols.AUTO_NEGOTIATE;
 }
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index ac90c08b..609a1413 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,5 +1,6 @@
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
+using GraphQL.Client.Http.Websocket;
 using GraphQL.Client.Serializer.Newtonsoft;
 using GraphQL.Client.Tests.Common;
 using GraphQL.Client.Tests.Common.Helpers;
@@ -30,11 +31,12 @@ public static async Task<IWebHost> CreateServer(int port)
         return host;
     }
 
-    public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
+    public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null, string websocketProtocol = WebSocketProtocols.GRAPHQL_WS)
         => new GraphQLHttpClient(new GraphQLHttpClientOptions
         {
             EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
-            UseWebSocketForQueriesAndMutations = requestsViaWebsocket
+            UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
+            WebSocketProtocol = websocketProtocol
         },
             serializer ?? new NewtonsoftJsonSerializer());
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
index 768970e4..78539df0 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Newtonsoft.cs
@@ -3,9 +3,9 @@
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests;
 
-public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
+public class Newtonsoft : Base, IClassFixture<NewtonsoftGraphQLWsServerTestFixture>
 {
-    public Newtonsoft(NewtonsoftIntegrationServerTestFixture fixture) : base(fixture)
+    public Newtonsoft(NewtonsoftGraphQLWsServerTestFixture fixture) : base(fixture)
     {
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
index 9985692c..d42abb21 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/SystemTextJson.cs
@@ -3,9 +3,9 @@
 
 namespace GraphQL.Integration.Tests.QueryAndMutationTests;
 
-public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
+public class SystemTextJson : Base, IClassFixture<SystemTextJsonGraphQLWsServerTestFixture>
 {
-    public SystemTextJson(SystemTextJsonIntegrationServerTestFixture fixture) : base(fixture)
+    public SystemTextJson(SystemTextJsonGraphQLWsServerTestFixture fixture) : base(fixture)
     {
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 8978bc35..9c730e4c 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -476,5 +476,4 @@ public async void CanHandleQueryErrorInSubscription()
         await observer.Should().CompleteAsync();
         ChatClient.Dispose();
     }
-
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
deleted file mode 100644
index 87c23ba6..00000000
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Newtonsoft.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using GraphQL.Integration.Tests.Helpers;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace GraphQL.Integration.Tests.WebsocketTests;
-
-public class Newtonsoft : Base, IClassFixture<NewtonsoftIntegrationServerTestFixture>
-{
-    public Newtonsoft(ITestOutputHelper output, NewtonsoftIntegrationServerTestFixture fixture) : base(output, fixture)
-    {
-    }
-}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLTransportWs.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLTransportWs.cs
new file mode 100644
index 00000000..0a56d631
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLTransportWs.cs
@@ -0,0 +1,12 @@
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public class NewtonsoftGraphQLTransportWs : Base, IClassFixture<NewtonsoftGraphQLTransportWsServerTestFixture>
+{
+    public NewtonsoftGraphQLTransportWs(ITestOutputHelper output, NewtonsoftGraphQLTransportWsServerTestFixture fixture) : base(output, fixture)
+    {
+    }
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLWs.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLWs.cs
new file mode 100644
index 00000000..c20b133c
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/NewtonsoftGraphQLWs.cs
@@ -0,0 +1,12 @@
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public class NewtonsoftGraphQLWs : Base, IClassFixture<NewtonsoftGraphQLWsServerTestFixture>
+{
+    public NewtonsoftGraphQLWs(ITestOutputHelper output, NewtonsoftGraphQLWsServerTestFixture fixture) : base(output, fixture)
+    {
+    }
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
deleted file mode 100644
index e3648bf4..00000000
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJson.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using GraphQL.Integration.Tests.Helpers;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace GraphQL.Integration.Tests.WebsocketTests;
-
-public class SystemTextJson : Base, IClassFixture<SystemTextJsonIntegrationServerTestFixture>
-{
-    public SystemTextJson(ITestOutputHelper output, SystemTextJsonIntegrationServerTestFixture fixture) : base(output, fixture)
-    {
-    }
-}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs
new file mode 100644
index 00000000..0090e307
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs
@@ -0,0 +1,21 @@
+using FluentAssertions;
+using GraphQL.Client.Http.Websocket;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public class SystemTextJsonAutoNegotiate : Base, IClassFixture<SystemTextJsonAutoNegotiateServerTestFixture>
+{
+    public SystemTextJsonAutoNegotiate(ITestOutputHelper output, SystemTextJsonAutoNegotiateServerTestFixture fixture) : base(output, fixture)
+    {
+    }
+
+    [Fact]
+    public async Task WebSocketProtocolIsAutoNegotiated()
+    {
+        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+        ChatClient.WebSocketSubProtocol.Should().Be(WebSocketProtocols.GRAPHQL_TRANSPORT_WS);
+    }
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs
new file mode 100644
index 00000000..dfba089e
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs
@@ -0,0 +1,35 @@
+using FluentAssertions;
+using FluentAssertions.Reactive;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public class SystemTextJsonGraphQLTransportWs : Base, IClassFixture<SystemTextJsonGraphQLTransportWsServerTestFixture>
+{
+    public SystemTextJsonGraphQLTransportWs(ITestOutputHelper output, SystemTextJsonGraphQLTransportWsServerTestFixture fixture) : base(output, fixture)
+    {
+    }
+
+    [Fact]
+    public async void Sending_a_pong_message_should_not_throw()
+    {
+        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+
+        await ChatClient.Awaiting(client => client.SendPongAsync(null)).Should().NotThrowAsync().ConfigureAwait(false);
+        await ChatClient.Awaiting(client => client.SendPongAsync("some payload")).Should().NotThrowAsync().ConfigureAwait(false);
+    }
+
+    [Fact]
+    public async void Sending_a_ping_message_should_result_in_a_pong_message_from_the_server()
+    {
+        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+
+        using var pongObserver = ChatClient.PongStream.Observe();
+
+        await ChatClient.Awaiting(client => client.SendPingAsync(null)).Should().NotThrowAsync().ConfigureAwait(false);
+
+        await pongObserver.Should().PushAsync(1, TimeSpan.FromSeconds(1), "because the server was pinged by the client").ConfigureAwait(false);
+    }
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs
new file mode 100644
index 00000000..963f8292
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs
@@ -0,0 +1,40 @@
+using FluentAssertions;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GraphQL.Integration.Tests.WebsocketTests;
+
+public class SystemTextJsonGraphQLWs : Base, IClassFixture<SystemTextJsonGraphQLWsServerTestFixture>
+{
+    public SystemTextJsonGraphQLWs(ITestOutputHelper output, SystemTextJsonGraphQLWsServerTestFixture fixture) : base(output, fixture)
+    {
+    }
+
+    [Fact]
+    public async void Sending_a_ping_message_should_throw_not_supported_exception()
+    {
+        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+
+        await ChatClient.Awaiting(client => client.SendPingAsync(null))
+            .Should().ThrowAsync<NotSupportedException>().ConfigureAwait(false);
+    }
+
+    [Fact]
+    public async void Sending_a_pong_message_should_throw_not_supported_exception()
+    {
+        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+
+        await ChatClient.Awaiting(client => client.SendPongAsync(null))
+            .Should().ThrowAsync<NotSupportedException>().ConfigureAwait(false);
+    }
+
+    [Fact]
+    public async void Subscribing_to_the_pong_stream_should_throw_not_supported_exception()
+    {
+        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+
+        ChatClient.Invoking(client => client.PongStream.Subscribe())
+            .Should().Throw<NotSupportedException>();
+    }
+}

From 9f7d59307c50bbfdfb081a7b5c11ca0b779e777b Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 13 Apr 2023 18:16:24 +0200
Subject: [PATCH 428/455] Feature/make automatic header optional (#542)

* Make UserAgent request header optional.

* Changed to configurable user agent header.

* Update src/GraphQL.Client/GraphQLHttpClientOptions.cs

Co-authored-by: Alexander Rose <alex@rose-a.de>

* Update src/GraphQL.Client/GraphQLHttpRequest.cs

Co-authored-by: Alexander Rose <alex@rose-a.de>

* Update src/GraphQL.Client/GraphQLHttpRequest.cs

Co-authored-by: Alexander Rose <alex@rose-a.de>

* Update src/GraphQL.Client/GraphQLHttpRequest.cs

Co-authored-by: Alexander Rose <alex@rose-a.de>

* Update src/GraphQL.Client/GraphQLHttpRequest.cs

* refactor test helpers to provide access to GraphQLHttpClientOptions when creating the test client

* test user agent header

---------

Co-authored-by: Jesse <info@jessesander.nl>
Co-authored-by: Ivan Maximov <sungam3r@yandex.ru>
---
 src/GraphQL.Client/GraphQLHttpClient.cs       | 18 ++---
 .../GraphQLHttpClientOptions.cs               |  7 ++
 src/GraphQL.Client/GraphQLHttpRequest.cs      |  3 +
 .../Chat/Schema/ChatQuery.cs                  | 19 +++++-
 .../GraphQL.Client.Tests.Common.csproj        |  5 +-
 .../Properties/launchSettings.json            | 12 ++++
 .../Helpers/IntegrationServerTestFixture.cs   | 26 +++----
 .../Helpers/WebHostHelpers.cs                 | 42 +++---------
 .../UserAgentHeaderTests.cs                   | 68 +++++++++++++++++++
 .../WebsocketTests/Base.cs                    |  4 +-
 tests/IntegrationTestServer/Startup.cs        |  2 +-
 11 files changed, 145 insertions(+), 61 deletions(-)
 create mode 100644 tests/GraphQL.Client.Tests.Common/Properties/launchSettings.json
 create mode 100644 tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index d634fe2e..82c27452 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -60,17 +60,13 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
         _disposeHttpClient = true;
     }
 
-    public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
-    {
-        Options = options ?? throw new ArgumentNullException(nameof(options));
-        JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
-        HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
-
-        if (!HttpClient.DefaultRequestHeaders.UserAgent.Any())
-            HttpClient.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue(GetType().Assembly.GetName().Name, GetType().Assembly.GetName().Version.ToString()));
-
-        _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
-    }
+        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
+        {
+            Options = options ?? throw new ArgumentNullException(nameof(options));
+            JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
+            HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
+            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
+        }
 
     #endregion
 
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 74de6441..13a9c576 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -80,4 +80,11 @@ public class GraphQLHttpClientOptions
     /// See https://github.com/apollographql/subscriptions-transport-ws/blob/master/PROTOCOL.md#gql_connection_init.
     /// </summary>
     public Func<GraphQLHttpClientOptions, object?> ConfigureWebSocketConnectionInitPayload { get; set; } = options => null;
+
+    /// <summary>
+    /// The default user agent request header.
+    /// Default to the GraphQL client assembly.
+    /// </summary>
+    public ProductInfoHeaderValue? DefaultUserAgentRequestHeader { get; set; }
+        = new ProductInfoHeaderValue(typeof(GraphQLHttpClient).Assembly.GetName().Name, typeof(GraphQLHttpClient).Assembly.GetName().Version.ToString());
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 925c060e..6d3a7633 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -43,6 +43,9 @@ public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions
         message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
         message.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
 
+        if (options.DefaultUserAgentRequestHeader != null)
+            message.Headers.UserAgent.Add(options.DefaultUserAgentRequestHeader);
+
 #pragma warning disable CS0618 // Type or member is obsolete
         PreprocessHttpRequestMessage(message);
 #pragma warning restore CS0618 // Type or member is obsolete
diff --git a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
index 61bf6055..5b506225 100644
--- a/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
+++ b/tests/GraphQL.Client.Tests.Common/Chat/Schema/ChatQuery.cs
@@ -1,9 +1,13 @@
 using GraphQL.Types;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace GraphQL.Client.Tests.Common.Chat.Schema;
 
 public class ChatQuery : ObjectGraphType
 {
+    private readonly IServiceProvider _serviceProvider;
+
     public static readonly Dictionary<string, object> TestExtensions = new()
     {
         {"extension1", "hello world"},
@@ -16,8 +20,9 @@ public class ChatQuery : ObjectGraphType
     public readonly ManualResetEventSlim LongRunningQueryBlocker = new ManualResetEventSlim();
     public readonly ManualResetEventSlim WaitingOnQueryBlocker = new ManualResetEventSlim();
 
-    public ChatQuery(IChat chat)
+    public ChatQuery(IChat chat, IServiceProvider serviceProvider)
     {
+        _serviceProvider = serviceProvider;
         Name = "ChatQuery";
 
         Field<ListGraphType<MessageType>>("messages").Resolve(context => chat.AllMessages.Take(100));
@@ -37,5 +42,17 @@ public ChatQuery(IChat chat)
                 WaitingOnQueryBlocker.Reset();
                 return "finally returned";
             });
+
+        Field<StringGraphType>("clientUserAgent")
+            .Resolve(context =>
+            {
+                var contextAccessor = _serviceProvider.GetRequiredService<IHttpContextAccessor>();
+                if (!contextAccessor.HttpContext.Request.Headers.UserAgent.Any())
+                {
+                    context.Errors.Add(new ExecutionError("user agent header not set"));
+                    return null;
+                }
+                return contextAccessor.HttpContext.Request.Headers.UserAgent.ToString();
+            });
     }
 }
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 9bfadf6b..23bce138 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
@@ -16,4 +16,7 @@
     <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
 </Project>
diff --git a/tests/GraphQL.Client.Tests.Common/Properties/launchSettings.json b/tests/GraphQL.Client.Tests.Common/Properties/launchSettings.json
new file mode 100644
index 00000000..a50815da
--- /dev/null
+++ b/tests/GraphQL.Client.Tests.Common/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "GraphQL.Client.Tests.Common": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:59034"
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
index 5f34b2ba..eca64acc 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/IntegrationServerTestFixture.cs
@@ -12,7 +12,7 @@ public abstract class IntegrationServerTestFixture
 {
     public int Port { get; private set; }
 
-    public IWebHost Server { get; private set; }
+    public IWebHost? Server { get; private set; }
 
     public abstract IGraphQLWebsocketJsonSerializer Serializer { get; }
 
@@ -27,7 +27,7 @@ public async Task CreateServer()
     {
         if (Server != null)
             return;
-        Server = await WebHostHelpers.CreateServer(Port);
+        Server = await WebHostHelpers.CreateServer(Port).ConfigureAwait(false);
     }
 
     public async Task ShutdownServer()
@@ -40,18 +40,20 @@ public async Task ShutdownServer()
         Server = null;
     }
 
-    public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-        => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
+    public GraphQLHttpClient GetStarWarsClient(Action<GraphQLHttpClientOptions>? configure = null)
+        => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, configure);
 
-    public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-        => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
+    public GraphQLHttpClient GetChatClient(Action<GraphQLHttpClientOptions>? configure = null)
+        => GetGraphQLClient(Common.CHAT_ENDPOINT, configure);
 
-    private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false)
-    {
-        if (Serializer == null)
-            throw new InvalidOperationException("JSON serializer not configured");
-        return WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket, Serializer, WebsocketProtocol);
-    }
+    private GraphQLHttpClient GetGraphQLClient(string endpoint, Action<GraphQLHttpClientOptions>? configure) =>
+        Serializer == null
+            ? throw new InvalidOperationException("JSON serializer not configured")
+            : WebHostHelpers.GetGraphQLClient(Port, endpoint, Serializer, options =>
+            {
+                configure?.Invoke(options);
+                options.WebSocketProtocol = WebsocketProtocol;
+            });
 }
 
 public class NewtonsoftGraphQLWsServerTestFixture : IntegrationServerTestFixture
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index 609a1413..e077fe10 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -2,8 +2,6 @@
 using GraphQL.Client.Http;
 using GraphQL.Client.Http.Websocket;
 using GraphQL.Client.Serializer.Newtonsoft;
-using GraphQL.Client.Tests.Common;
-using GraphQL.Client.Tests.Common.Helpers;
 using IntegrationTestServer;
 
 namespace GraphQL.Integration.Tests.Helpers;
@@ -31,37 +29,15 @@ public static async Task<IWebHost> CreateServer(int port)
         return host;
     }
 
-    public static GraphQLHttpClient GetGraphQLClient(int port, string endpoint, bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null, string websocketProtocol = WebSocketProtocols.GRAPHQL_WS)
-        => new GraphQLHttpClient(new GraphQLHttpClientOptions
-        {
-            EndPoint = new Uri($"http://localhost:{port}{endpoint}"),
-            UseWebSocketForQueriesAndMutations = requestsViaWebsocket,
-            WebSocketProtocol = websocketProtocol
-        },
-            serializer ?? new NewtonsoftJsonSerializer());
-}
-
-public class TestServerSetup : IDisposable
-{
-    public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer)
+    public static GraphQLHttpClient GetGraphQLClient(
+        int port,
+        string endpoint,
+        IGraphQLWebsocketJsonSerializer? serializer = null,
+        Action<GraphQLHttpClientOptions>? configure = null)
     {
-        Serializer = serializer;
-        Port = NetworkHelpers.GetFreeTcpPortNumber();
+        var options = new GraphQLHttpClientOptions();
+        configure?.Invoke(options);
+        options.EndPoint = new Uri($"http://localhost:{port}{endpoint}");
+        return new GraphQLHttpClient(options, serializer ?? new NewtonsoftJsonSerializer());
     }
-
-    public int Port { get; }
-
-    public IWebHost Server { get; set; }
-
-    public IGraphQLWebsocketJsonSerializer Serializer { get; set; }
-
-    public GraphQLHttpClient GetStarWarsClient(bool requestsViaWebsocket = false)
-        => GetGraphQLClient(Common.STAR_WARS_ENDPOINT, requestsViaWebsocket);
-
-    public GraphQLHttpClient GetChatClient(bool requestsViaWebsocket = false)
-        => GetGraphQLClient(Common.CHAT_ENDPOINT, requestsViaWebsocket);
-
-    private GraphQLHttpClient GetGraphQLClient(string endpoint, bool requestsViaWebsocket = false) => WebHostHelpers.GetGraphQLClient(Port, endpoint, requestsViaWebsocket);
-
-    public void Dispose() => Server?.Dispose();
 }
diff --git a/tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs b/tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs
new file mode 100644
index 00000000..bf631be5
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs
@@ -0,0 +1,68 @@
+using System.Net.Http.Headers;
+using FluentAssertions;
+using GraphQL.Client.Abstractions;
+using GraphQL.Client.Http;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
+
+namespace GraphQL.Integration.Tests;
+
+public class UserAgentHeaderTests : IAsyncLifetime, IClassFixture<SystemTextJsonAutoNegotiateServerTestFixture>
+{
+    private readonly IntegrationServerTestFixture Fixture;
+    private GraphQLHttpClient? ChatClient;
+
+    public UserAgentHeaderTests(SystemTextJsonAutoNegotiateServerTestFixture fixture)
+    {
+        Fixture = fixture;
+    }
+
+    public async Task InitializeAsync() => await Fixture.CreateServer().ConfigureAwait(false);
+
+    public Task DisposeAsync()
+    {
+        ChatClient?.Dispose();
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public async void Can_set_custom_user_agent()
+    {
+        const string userAgent = "CustomUserAgent";
+        ChatClient = Fixture.GetChatClient(options => options.DefaultUserAgentRequestHeader = ProductInfoHeaderValue.Parse(userAgent));
+
+        var graphQLRequest = new GraphQLRequest("query clientUserAgent { clientUserAgent }");
+        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty }).ConfigureAwait(false);
+
+        response.Errors.Should().BeNull();
+        response.Data.clientUserAgent.Should().Be(userAgent);
+    }
+
+    [Fact]
+    public async void Default_user_agent_is_set_as_expected()
+    {
+        string? expectedUserAgent = new ProductInfoHeaderValue(
+            typeof(GraphQLHttpClient).Assembly.GetName().Name,
+            typeof(GraphQLHttpClient).Assembly.GetName().Version.ToString()).ToString();
+
+        ChatClient = Fixture.GetChatClient();
+
+        var graphQLRequest = new GraphQLRequest("query clientUserAgent { clientUserAgent }");
+        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty }).ConfigureAwait(false);
+
+        response.Errors.Should().BeNull();
+        response.Data.clientUserAgent.Should().Be(expectedUserAgent);
+    }
+
+    [Fact]
+    public async void No_Default_user_agent_if_set_to_null()
+    {
+        ChatClient = Fixture.GetChatClient(options => options.DefaultUserAgentRequestHeader = null);
+
+        var graphQLRequest = new GraphQLRequest("query clientUserAgent { clientUserAgent }");
+        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty }).ConfigureAwait(false);
+
+        response.Errors.Should().HaveCount(1);
+        response.Errors[0].Message.Should().Be("user agent header not set");
+    }
+}
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index 9c730e4c..e16a4a38 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -21,7 +21,7 @@ public abstract class Base : IAsyncLifetime
 {
     protected readonly ITestOutputHelper Output;
     protected readonly IntegrationServerTestFixture Fixture;
-    protected GraphQLHttpClient ChatClient;
+    protected GraphQLHttpClient? ChatClient;
 
     protected Base(ITestOutputHelper output, IntegrationServerTestFixture fixture)
     {
@@ -43,7 +43,7 @@ public async Task InitializeAsync()
         Fixture.Server.Services.GetService<Chat>().AddMessage(InitialMessage);
 
         // then create the chat client
-        ChatClient ??= Fixture.GetChatClient(true);
+        ChatClient ??= Fixture.GetChatClient(options => options.UseWebSocketForQueriesAndMutations = true);
     }
 
     public Task DisposeAsync()
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index d2b8d427..ee8526c1 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -25,7 +25,7 @@ public Startup(IConfiguration configuration, IWebHostEnvironment environment)
     public void ConfigureServices(IServiceCollection services)
     {
         services.Configure<KestrelServerOptions>(options => options.AllowSynchronousIO = true);
-        //
+        services.AddHttpContextAccessor();
         services.AddChatSchema();
         services.AddStarWarsSchema();
         services.AddGraphQL(builder => builder

From 37c547eabcbd5c6a3e07852a4bd9ed475a6927d2 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sun, 16 Apr 2023 16:00:40 +0300
Subject: [PATCH 429/455] Bump GraphQL.NET to v7.4 (#547)

---
 .../GraphQLWebSocketMessageType.cs                |  1 -
 .../GraphQL.Client.LocalExecution.csproj          |  2 +-
 .../GraphQL.Client.Serializer.Newtonsoft.csproj   |  4 ++--
 .../ConstantCaseJsonNamingPolicy.cs               |  2 +-
 src/GraphQL.Client/GraphQLHttpClient.cs           | 15 +++++++--------
 .../GraphQLTransportWSProtocolHandler.cs          |  2 +-
 .../GraphQL.Client.Serializer.Tests.csproj        |  6 +++---
 .../GraphQL.Client.Tests.Common.csproj            |  4 ++--
 .../StarWars/Types/CharacterInterface.cs          |  4 ++--
 .../Helpers/WebHostHelpers.cs                     |  1 -
 .../GraphQL.Server.Test.csproj                    |  6 +++---
 .../IntegrationTestServer.csproj                  |  4 ++--
 12 files changed, 24 insertions(+), 27 deletions(-)

diff --git a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
index a1628c6e..fbc3a5f5 100644
--- a/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
+++ b/src/GraphQL.Client.Abstractions.Websocket/GraphQLWebSocketMessageType.cs
@@ -134,5 +134,4 @@ public static class GraphQLWebSocketMessageType
     /// </summary>
 
     public const string GQL_NEXT = "next"; // Server -> Client
-    
 }
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 253f9283..7971ef82 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.0.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
index a3c9700a..22126805 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/GraphQL.Client.Serializer.Newtonsoft.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <Description>A serializer implementation for GraphQL.Client using Newtonsoft.Json as underlying JSON library</Description>
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
index acc7f9b1..f8560306 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ConstantCaseJsonNamingPolicy.cs
@@ -1,4 +1,4 @@
-using System.Text.Json;
+using System.Text.Json;
 using GraphQL.Client.Abstractions.Utilities;
 
 namespace GraphQL.Client.Serializer.SystemTextJson;
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 82c27452..7ffea50b 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,5 +1,4 @@
 using System.Diagnostics;
-using System.Net.Http.Headers;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
@@ -60,13 +59,13 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
         _disposeHttpClient = true;
     }
 
-        public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
-        {
-            Options = options ?? throw new ArgumentNullException(nameof(options));
-            JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
-            HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
-            _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
-        }
+    public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
+    {
+        Options = options ?? throw new ArgumentNullException(nameof(options));
+        JsonSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer), "please configure the JSON serializer you want to use");
+        HttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
+        _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
+    }
 
     #endregion
 
diff --git a/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs b/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
index c78581b1..1ac5ffeb 100644
--- a/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
@@ -8,7 +8,7 @@
 
 namespace GraphQL.Client.Http.Websocket;
 
-internal class GraphQLTransportWSProtocolHandler: IWebsocketProtocolHandler
+internal class GraphQLTransportWSProtocolHandler : IWebsocketProtocolHandler
 {
     public string WebsocketProtocol => WebSocketProtocols.GRAPHQL_TRANSPORT_WS;
 
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index fac5bf23..2daa9c99 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <Import Project="../tests.props" />
 
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.3.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.3.1" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.4.0" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.4.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 23bce138..98393c8f 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net7.0</TargetFramework>
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.3.1" />
+    <PackageReference Include="GraphQL" Version="7.4.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
index a25daec3..0cf9d6b2 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/CharacterInterface.cs
@@ -9,8 +9,8 @@ public CharacterInterface()
     {
         Name = "Character";
 
-        Field<NonNullGraphType<StringGraphType>>("id").Description("The id of the character.").Resolve(context => context.Source.Id);
-        Field<StringGraphType>("name").Description("The name of the character.").Resolve(context => context.Source.Name);
+        Field<NonNullGraphType<StringGraphType>>("id").Description("The id of the character.");
+        Field<StringGraphType>("name").Description("The name of the character.");
 
         Field<ListGraphType<CharacterInterface>>("friends");
         Field<ConnectionType<CharacterInterface, EdgeType<CharacterInterface>>>("friendsConnection");
diff --git a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
index e077fe10..9354f183 100644
--- a/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
+++ b/tests/GraphQL.Integration.Tests/Helpers/WebHostHelpers.cs
@@ -1,6 +1,5 @@
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http;
-using GraphQL.Client.Http.Websocket;
 using GraphQL.Client.Serializer.Newtonsoft;
 using IntegrationTestServer;
 
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 901724ee..d0b222c1 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.3.0" />
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.3.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.3.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.4.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.4.0" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index d26b2adb..ad1e5255 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>net7</TargetFramework>
@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.All" Version="7.3.0" />
+    <PackageReference Include="GraphQL.Server.All" Version="7.4.0" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
     <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
   </ItemGroup>

From 3805cdd192982b125e3d81c4035c13f4c3e4e141 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 21 Apr 2023 22:50:30 +0300
Subject: [PATCH 430/455] Bump GraphQL.NewtonsoftJson from 7.4.0 to 7.4.1
 (#549)

Bumps [GraphQL.NewtonsoftJson](https://github.com/graphql-dotnet/graphql-dotnet) from 7.4.0 to 7.4.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.4.0...7.4.1)

---
updated-dependencies:
- dependency-name: GraphQL.NewtonsoftJson
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 2daa9c99..e79b1508 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <Import Project="../tests.props" />
 
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.4.0" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.4.1" />
     <PackageReference Include="GraphQL.SystemTextJson" Version="7.4.0" />
   </ItemGroup>
 

From 76755db59f73b5ac81bc77216ead0703d6d72bb9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 21 Apr 2023 23:56:04 +0300
Subject: [PATCH 431/455] Bump GraphQL.SystemTextJson from 7.4.0 to 7.4.1
 (#550)

Bumps [GraphQL.SystemTextJson](https://github.com/graphql-dotnet/graphql-dotnet) from 7.4.0 to 7.4.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.4.0...7.4.1)

---
updated-dependencies:
- dependency-name: GraphQL.SystemTextJson
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Serializer.Tests.csproj                      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index e79b1508..ed2da1ab 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.4.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.4.0" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.4.1" />
   </ItemGroup>
 
   <ItemGroup>

From aa87838f8bae99926aeb47f47cd338d0ecb232fd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 26 Apr 2023 08:54:37 +0300
Subject: [PATCH 432/455] Bump GraphQL.MicrosoftDI from 7.4.0 to 7.4.1 (#552)

Bumps [GraphQL.MicrosoftDI](https://github.com/graphql-dotnet/graphql-dotnet) from 7.4.0 to 7.4.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.4.0...7.4.1)

---
updated-dependencies:
- dependency-name: GraphQL.MicrosoftDI
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.LocalExecution.csproj                      | 4 ++--
 tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj          | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 7971ef82..04261eb7 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <Description>A GraphQL Client which executes the queries directly on a provided GraphQL schema using graphql-dotnet</Description>
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.1" />
     <PackageReference Include="System.Reactive" Version="5.0.0" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index d0b222c1..7220da61 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.1" />
     <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.4.0" />
     <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.4.0" />
   </ItemGroup>

From 7e1aa16336afeef4304727ec620a446943fa7aae Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Wed, 26 Apr 2023 11:05:08 +0300
Subject: [PATCH 433/455] Make GraphQLRequest.Extensions dictionary (#556)

---
 src/GraphQL.Client/GraphQLHttpRequest.cs                    | 6 ++++--
 src/GraphQL.Primitives/GraphQLRequest.cs                    | 6 +++---
 .../TestData/SerializeToStringTestData.cs                   | 4 ++++
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 6d3a7633..9ff0c600 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -11,11 +11,13 @@ public GraphQLHttpRequest()
     {
     }
 
-    public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null) : base(query, variables, operationName)
+    public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
+        : base(query, variables, operationName, extensions)
     {
     }
 
-    public GraphQLHttpRequest(GraphQLRequest other) : base(other)
+    public GraphQLHttpRequest(GraphQLRequest other)
+        : base(other)
     {
     }
 
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 59593d7b..f33ed88a 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -40,15 +40,15 @@ public object? Variables
     /// <summary>
     /// Represents the request extensions
     /// </summary>
-    public object? Extensions
+    public Dictionary<string, object?>? Extensions
     {
-        get => TryGetValue(EXTENSIONS_KEY, out object value) ? value : null;
+        get => TryGetValue(EXTENSIONS_KEY, out object value) && value is Dictionary<string, object?> d ? d : null;
         set => this[EXTENSIONS_KEY] = value;
     }
 
     public GraphQLRequest() { }
 
-    public GraphQLRequest(string query, object? variables = null, string? operationName = null, object? extensions = null)
+    public GraphQLRequest(string query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
     {
         Query = query;
         Variables = variables;
diff --git a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
index e01c6335..85bc5e3b 100644
--- a/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/TestData/SerializeToStringTestData.cs
@@ -10,6 +10,10 @@ public IEnumerator<object[]> GetEnumerator()
             "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":null}",
             new GraphQLRequest("simple query string")
         };
+        yield return new object[] {
+            "{\"query\":\"simplequerystring\",\"variables\":null,\"operationName\":null,\"extensions\":{\"a\":\"abc\",\"b\":true,\"c\":{\"d\":42}}}",
+            new GraphQLRequest("simple query string", extensions: new Dictionary<string, object?> { ["a"] = "abc", ["b"] = true, ["c"] = new Dictionary<string, object> { ["d"] = 42 } })
+        };
         yield return new object[] {
             "{\"query\":\"simplequerystring\",\"variables\":{\"camelCaseProperty\":\"camelCase\",\"PascalCaseProperty\":\"PascalCase\"},\"operationName\":null,\"extensions\":null}",
             new GraphQLRequest("simple query string", new { camelCaseProperty = "camelCase", PascalCaseProperty = "PascalCase"})

From 8210ac36aa5fabedc24826497ce86ec5ec29796f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 26 Apr 2023 13:06:34 +0300
Subject: [PATCH 434/455] Bump GraphQL from 7.4.0 to 7.4.1 (#551)

Bumps [GraphQL](https://github.com/graphql-dotnet/graphql-dotnet) from 7.4.0 to 7.4.1.
- [Release notes](https://github.com/graphql-dotnet/graphql-dotnet/releases)
- [Commits](https://github.com/graphql-dotnet/graphql-dotnet/compare/7.4.0...7.4.1)

---
updated-dependencies:
- dependency-name: GraphQL
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../GraphQL.Client.Tests.Common.csproj                        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 98393c8f..138f4c67 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net7.0</TargetFramework>
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.4.0" />
+    <PackageReference Include="GraphQL" Version="7.4.1" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
   </ItemGroup>
 

From f1a5bf85aa45eb2ad2ed12fbcc3db425e999e3b0 Mon Sep 17 00:00:00 2001
From: Mikolaj <kocotte@outlook.com>
Date: Mon, 8 May 2023 08:56:53 +0200
Subject: [PATCH 435/455] Improve default IsValidResponseToDeserialize
 implementation (#560)

* change default implementation of response validation method to ensure correct response content type

* add tests for the default validation method

* remove unnecessary comments

Co-authored-by: Ivan Maximov <sungam3r@yandex.ru>

* accepted response types private, formatting

* make DefaultIsValidResponseToDeserialize publicly accessible

Co-authored-by: Ivan Maximov <sungam3r@yandex.ru>

* AcceptedResponseContentTypes as static field

---------

Co-authored-by: Ivan Maximov <sungam3r@yandex.ru>
---
 .../GraphQLHttpClientOptions.cs               | 14 ++++++++--
 .../DefaultValidationTest.cs                  | 28 +++++++++++++++++++
 2 files changed, 39 insertions(+), 3 deletions(-)
 create mode 100644 tests/GraphQL.Client.Serializer.Tests/DefaultValidationTest.cs

diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 13a9c576..169260f0 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -61,9 +61,17 @@ public class GraphQLHttpClientOptions
     /// Note that compatible to the draft graphql-over-http spec GraphQL Server MAY return 4xx status codes (401/403, etc.)
     /// with well-formed GraphQL response containing errors collection.
     /// </summary>
-    public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = r =>
-        // Why not application/json? See https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md#processing-the-response
-        r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest || r.Content.Headers.ContentType?.MediaType == "application/graphql+json";
+    public Func<HttpResponseMessage, bool> IsValidResponseToDeserialize { get; set; } = DefaultIsValidResponseToDeserialize;
+
+    private static readonly IReadOnlyCollection<string> _acceptedResponseContentTypes = new[] { "application/graphql+json", "application/json", "application/graphql-response+json" };
+
+    public static bool DefaultIsValidResponseToDeserialize(HttpResponseMessage r)
+    {
+        if (r.Content.Headers.ContentType?.MediaType != null && !_acceptedResponseContentTypes.Contains(r.Content.Headers.ContentType.MediaType))
+            return false;
+
+        return r.IsSuccessStatusCode || r.StatusCode == HttpStatusCode.BadRequest;
+    }
 
     /// <summary>
     /// This callback is called after successfully establishing a websocket connection but before any regular request is made.
diff --git a/tests/GraphQL.Client.Serializer.Tests/DefaultValidationTest.cs b/tests/GraphQL.Client.Serializer.Tests/DefaultValidationTest.cs
new file mode 100644
index 00000000..861b59b6
--- /dev/null
+++ b/tests/GraphQL.Client.Serializer.Tests/DefaultValidationTest.cs
@@ -0,0 +1,28 @@
+using System.Net;
+using System.Net.Http.Headers;
+using FluentAssertions;
+using GraphQL.Client.Http;
+using Xunit;
+
+namespace GraphQL.Client.Serializer.Tests;
+
+public class DefaultValidationTest
+{
+    [Theory]
+    [InlineData(HttpStatusCode.OK, "application/json", true)]
+    [InlineData(HttpStatusCode.OK, "application/graphql-response+json", true)]
+    [InlineData(HttpStatusCode.BadRequest, "application/json", true)]
+    [InlineData(HttpStatusCode.BadRequest, "text/html", false)]
+    [InlineData(HttpStatusCode.OK, "text/html", false)]
+    [InlineData(HttpStatusCode.Forbidden, "text/html", false)]
+    [InlineData(HttpStatusCode.Forbidden, "application/json", false)]
+    public void IsValidResponse_OkJson_True(HttpStatusCode statusCode, string mediaType, bool expectedResult)
+    {
+        var response = new HttpResponseMessage(statusCode);
+        response.Content.Headers.ContentType = new MediaTypeHeaderValue(mediaType);
+
+        bool isValid = new GraphQLHttpClientOptions().IsValidResponseToDeserialize(response);
+
+        isValid.Should().Be(expectedResult);
+    }
+}

From a5dfcd89928c494b449dec80498add1343e66257 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Wed, 10 May 2023 01:24:53 +0300
Subject: [PATCH 436/455] Remove
 GraphQLHttpRequest.PreprocessHttpRequestMessage (#561)

---
 src/GraphQL.Client/GraphQLHttpRequest.cs      | 11 ----------
 .../QueryAndMutationTests/Base.cs             | 22 -------------------
 2 files changed, 33 deletions(-)

diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 9ff0c600..c9d4e01a 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -1,5 +1,4 @@
 using System.Net.Http.Headers;
-using System.Runtime.Serialization;
 using System.Text;
 using GraphQL.Client.Abstractions;
 
@@ -21,13 +20,6 @@ public GraphQLHttpRequest(GraphQLRequest other)
     {
     }
 
-    /// <summary>
-    /// Allows to preprocess a <see cref="HttpRequestMessage"/> before it is sent, i.e. add custom headers
-    /// </summary>
-    [IgnoreDataMember]
-    [Obsolete("Inherit from GraphQLHttpRequest and override ToHttpRequestMessage() to customize the HttpRequestMessage. Will be removed in v4.0.0.")]
-    public Action<HttpRequestMessage> PreprocessHttpRequestMessage { get; set; } = message => { };
-
     /// <summary>
     /// Creates a <see cref="HttpRequestMessage"/> from this <see cref="GraphQLHttpRequest"/>.
     /// Used by <see cref="GraphQLHttpClient"/> to convert GraphQL requests when sending them as regular HTTP requests.
@@ -48,9 +40,6 @@ public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions
         if (options.DefaultUserAgentRequestHeader != null)
             message.Headers.UserAgent.Add(options.DefaultUserAgentRequestHeader);
 
-#pragma warning disable CS0618 // Type or member is obsolete
-        PreprocessHttpRequestMessage(message);
-#pragma warning restore CS0618 // Type or member is obsolete
         return message;
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index bff54832..0b120ba4 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -163,28 +163,6 @@ query Human($id: String!){
         Assert.Equal("Han Solo", queryResponse.Data.Human.Name);
     }
 
-    [Fact]
-    public async void PreprocessHttpRequestMessageIsCalled()
-    {
-        var callbackTester = new CallbackMonitor<HttpRequestMessage>();
-        var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
-        {
-#pragma warning disable CS0618 // Type or member is obsolete
-            PreprocessHttpRequestMessage = callbackTester.Invoke
-#pragma warning restore CS0618 // Type or member is obsolete
-        };
-
-        var expectedHeaders = new HttpRequestMessage().Headers;
-        expectedHeaders.UserAgent.Add(new ProductInfoHeaderValue("GraphQL.Client", typeof(GraphQLHttpClient).Assembly.GetName().Version.ToString()));
-        expectedHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql-response+json"));
-        expectedHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
-        expectedHeaders.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
-        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
-        callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(expectedHeaders);
-        Assert.Null(response.Errors);
-        Assert.Equal("Luke", response.Data.Human.Name);
-    }
-
     [Fact]
     public async Task PostRequestCanBeCancelled()
     {

From 42ffd7a56b1e186ad0ce3e9a749fd3792d3d29c5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 19 May 2023 19:43:09 +0300
Subject: [PATCH 437/455] Bump Microsoft.NET.Test.Sdk from 17.5.0 to 17.6.0
 (#562)

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.5.0 to 17.6.0.
- [Release notes](https://github.com/microsoft/vstest/releases)
- [Changelog](https://github.com/microsoft/vstest/blob/main/docs/releases.md)
- [Commits](https://github.com/microsoft/vstest/compare/v17.5.0...v17.6.0)

---
updated-dependencies:
- dependency-name: Microsoft.NET.Test.Sdk
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 87ec1373..3c9038bf 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
     <PackageReference Include="coverlet.collector" Version="3.2.0">

From 344a3e9f2ff2d110d331d377c25611e0306ed042 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 23 May 2023 19:35:40 +0300
Subject: [PATCH 438/455] Bump coverlet.collector from 3.2.0 to 6.0.0 (#567)

Bumps [coverlet.collector](https://github.com/coverlet-coverage/coverlet) from 3.2.0 to 6.0.0.
- [Release notes](https://github.com/coverlet-coverage/coverlet/releases)
- [Commits](https://github.com/coverlet-coverage/coverlet/compare/v3.2.0...v6.0.0)

---
updated-dependencies:
- dependency-name: coverlet.collector
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/tests.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/tests.props b/tests/tests.props
index 3c9038bf..f2765e66 100644
--- a/tests/tests.props
+++ b/tests/tests.props
@@ -10,7 +10,7 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
     <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
-    <PackageReference Include="coverlet.collector" Version="3.2.0">
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime;build;native;contentfiles;analyzers;buildtransitive</IncludeAssets>
     </PackageReference>

From e92e7af15246ec6e57bb874a43e4ab6dd7ce89a3 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Sat, 2 Sep 2023 06:47:04 +0300
Subject: [PATCH 439/455] Fix server test

---
 tests/GraphQL.Server.Test/Startup.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/GraphQL.Server.Test/Startup.cs b/tests/GraphQL.Server.Test/Startup.cs
index 114ce5ff..04dddcdc 100644
--- a/tests/GraphQL.Server.Test/Startup.cs
+++ b/tests/GraphQL.Server.Test/Startup.cs
@@ -22,6 +22,7 @@ public void ConfigureServices(IServiceCollection services)
     {
         services.AddGraphQL(builder => builder
             .AddSchema<TestSchema>()
+            .AddSystemTextJson()
             .UseApolloTracing(enableMetrics: true)
             .AddErrorInfoProvider(opt => opt.ExposeExceptionDetails = true)
         );

From 5436facadb3a82e434128fa3768f147e0b907d67 Mon Sep 17 00:00:00 2001
From: Joris van Eijden <joris.vaneijden@gmail.com>
Date: Fri, 29 Sep 2023 09:46:40 +0200
Subject: [PATCH 440/455] Fix ImmutableConverter.cs (#572)

* Update ImmutableConverter.cs

Swap properties and parameters in applicability check of ImmutableConverter.
This prevents properties from being lost when they are not all represented in the contructor as parameters.

* Add unit test

* Move test to base zo all serializers are covered

---------

Co-authored-by: Joris van Eijden <joris.vaneijden@oneshoe.nl>
---
 .../ImmutableConverter.cs                     | 33 +++++++++----------
 .../BaseSerializerTest.cs                     | 25 ++++++++++++++
 2 files changed, 41 insertions(+), 17 deletions(-)

diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index 96bad2c6..2087631d 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -19,31 +19,30 @@ public override bool CanConvert(Type typeToConvert)
         if (nullableUnderlyingType != null && nullableUnderlyingType.IsValueType)
             return false;
 
-        bool result;
         var constructors = typeToConvert.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
         if (constructors.Length != 1)
         {
-            result = false;
+            return false;
         }
-        else
+
+        var constructor = constructors[0];
+        var parameters = constructor.GetParameters();
+
+        if (parameters.Length <= 0)
         {
-            var constructor = constructors[0];
-            var parameters = constructor.GetParameters();
+            return false;
+        }
 
-            if (parameters.Length > 0)
-            {
-                var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
-                result = parameters
-                    .Select(parameter => properties.Any(p => NameOfPropertyAndParameter.Matches(p.Name, parameter.Name, typeToConvert.IsAnonymous())))
-                    .All(hasMatchingProperty => hasMatchingProperty);
-            }
-            else
-            {
-                result = false;
-            }
+        var properties = typeToConvert.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+
+        if (properties.Length > parameters.Length)
+        {
+            return false;
         }
 
-        return result;
+        return properties
+            .Select(property => parameters.Any(parameter => NameOfPropertyAndParameter.Matches(property.Name, parameter.Name, typeToConvert.IsAnonymous())))
+            .All(hasMatchingParameter => hasMatchingParameter);
     }
 
     public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index ddb71471..0a7102a1 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -190,4 +190,29 @@ public void CanSerializeNullableStruct()
 
         action.Should().NotThrow();
     }
+
+    [Fact]
+    public async Task CanDeserializeObjectWithBothConstructorAndProperties()
+    {
+        // Arrange
+        const string jsonString = @"{ ""data"": { ""property1"": ""value1"", ""property2"": ""value2"" } }";
+        var contentStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonString));
+
+        // Act
+        var result = await ClientSerializer.DeserializeFromUtf8StreamAsync<WithConstructorAndProperties>(contentStream, default).ConfigureAwait(false);
+
+        // Assert
+        result.Data.Property1.Should().Be("value1");
+        result.Data.Property2.Should().Be("value2");
+    }
+
+    private class WithConstructorAndProperties
+    {
+        public WithConstructorAndProperties(string property2)
+        {
+            Property2 = property2;
+        }
+        public string? Property1 { get; set; }
+        public string Property2 { get; }
+    }
 }

From d422bfdd0f5e3a1fba2af86c1aa9aaa41e28e495 Mon Sep 17 00:00:00 2001
From: Vivek Jayachandran <125931307+Vivek4Int@users.noreply.github.com>
Date: Fri, 29 Sep 2023 20:48:19 +1300
Subject: [PATCH 441/455] Explicitly setting content header to avoid issues
 with some GraphQL servers. (#595)

* Explicitly setting content header to avoid issues with some GraphQL servers. For instance synthetic GraphQL generated out of Azure APIM.
---
 src/GraphQL.Client/GraphQLHttpRequest.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index c9d4e01a..d03b9f8e 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -35,7 +35,10 @@ public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions
         };
         message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql-response+json"));
         message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
-        message.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
+        message.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
+
+        // Explicitly setting content header to avoid issues with some GrahQL servers
+        message.Content.Headers.ContentType = new MediaTypeHeaderValue(options.MediaType);
 
         if (options.DefaultUserAgentRequestHeader != null)
             message.Headers.UserAgent.Add(options.DefaultUserAgentRequestHeader);

From cfac737d07bca0a067488d62a6336361b7f2a6a8 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 23 Nov 2023 09:30:34 +0100
Subject: [PATCH 442/455] Fix Newtonsoft.Json MapConverter (#602)

* extend test to cover issue

* fix test

* fix newtonsoft mapconverter

* update gitversion

* Try to fix breaking change regarding implicit using uf System.Net.Http

* update sourcelink package to v 8.0.0

* rm package ref to sourcelink

* add using System.Net.Http to GraphQLHttpWebSocket

* upgrade net7 projects to net8
---
 Directory.Build.targets                       | 10 +--
 dotnet-tools.json                             |  2 +-
 .../GraphQL.Client.Example.csproj             |  2 +-
 .../MapConverter.cs                           | 12 ++--
 src/GraphQL.Client/GraphQLHttpClient.cs       |  4 ++
 .../GraphQLHttpClientOptions.cs               |  4 ++
 src/GraphQL.Client/GraphQLHttpRequest.cs      |  4 ++
 .../Websocket/GraphQLHttpWebSocket.cs         |  4 ++
 .../ConsistencyTests.cs                       | 64 ++++++++++++++-----
 .../GraphQL.Client.Serializer.Tests.csproj    |  2 +-
 .../GraphQL.Client.Tests.Common.csproj        |  2 +-
 .../GraphQL.Integration.Tests.csproj          |  2 +-
 .../GraphQL.Primitives.Tests.csproj           |  2 +-
 .../GraphQL.Server.Test.csproj                |  2 +-
 .../IntegrationTestServer.csproj              |  2 +-
 15 files changed, 84 insertions(+), 34 deletions(-)

diff --git a/Directory.Build.targets b/Directory.Build.targets
index a75e6500..f09b31ba 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -6,7 +6,7 @@
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild> <!--TODO: remove? since generated on CI-->
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(IsPackable)' == 'true' AND '$(GitVersion_SemVer)' != ''">
+  <!-- <PropertyGroup Condition="'$(IsPackable)' == 'true' AND '$(GitVersion_SemVer)' != ''">
     <GetVersion>false</GetVersion>
     <WriteVersionInfoToBuildLog>false</WriteVersionInfoToBuildLog>
     <UpdateAssemblyInfo>false</UpdateAssemblyInfo>
@@ -23,7 +23,7 @@
     <FileVersion Condition=" '$(FileVersion)' == '' ">$(GitVersion_AssemblySemFileVer)</FileVersion>
     <RepositoryBranch Condition=" '$(RepositoryBranch)' == '' ">$(GitVersion_BranchName)</RepositoryBranch>
     <RepositoryCommit Condition=" '$(RepositoryCommit)' == '' ">$(GitVersion_Sha)</RepositoryCommit>
-  </PropertyGroup>
+  </PropertyGroup> -->
 
   <PropertyGroup Condition="'$(IsPackable)' != 'true'">
     <NoWarn>$(NoWarn);1591</NoWarn>
@@ -33,10 +33,10 @@
     <None Include="..\..\assets\logo.64x64.png" Pack="true" PackagePath="\" Visible="false" />
     <None Include="..\..\README.md" Pack="true" PackagePath="\" Visible="false" />
     <None Include="..\..\LICENSE.txt" Pack="true" PackagePath="\" Visible="false" />
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
-    <PackageReference Update="GitVersionTask" Version="5.6.7">
+    <!-- <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" /> -->
+    <PackageReference Include="GitVersion.MsBuild" Version="5.12.0">
       <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
   </ItemGroup>
 
diff --git a/dotnet-tools.json b/dotnet-tools.json
index 7254cc09..e5146732 100644
--- a/dotnet-tools.json
+++ b/dotnet-tools.json
@@ -8,7 +8,7 @@
       ]
     },
     "gitversion.tool": {
-      "version": "5.10.3",
+      "version": "5.12.0",
       "commands": [
         "dotnet-gitversion"
       ]
diff --git a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
index 28c2c457..07866dfc 100644
--- a/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
+++ b/examples/GraphQL.Client.Example/GraphQL.Client.Example.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7</TargetFramework>
+    <TargetFramework>net8</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
index 90b22ed8..5bc53686 100644
--- a/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
+++ b/src/GraphQL.Client.Serializer.Newtonsoft/MapConverter.cs
@@ -9,15 +9,15 @@ public override void WriteJson(JsonWriter writer, Map value, JsonSerializer seri
         throw new NotImplementedException(
             "This converter currently is only intended to be used to read a JSON object into a strongly-typed representation.");
 
-    public override Map ReadJson(JsonReader reader, Type objectType, Map existingValue, bool hasExistingValue, JsonSerializer serializer)
+    public override Map? ReadJson(JsonReader reader, Type objectType, Map existingValue, bool hasExistingValue, JsonSerializer serializer)
     {
         var rootToken = JToken.ReadFrom(reader);
-        if (rootToken is JObject)
+        return rootToken.Type switch
         {
-            return (Map)ReadDictionary(rootToken, new Map());
-        }
-        else
-            throw new ArgumentException("This converter can only parse when the root element is a JSON Object.");
+            JTokenType.Object => (Map)ReadDictionary(rootToken, new Map()),
+            JTokenType.Null => null,
+            _ => throw new ArgumentException("This converter can only parse when the root element is a JSON Object.")
+        };
     }
 
     private object? ReadToken(JToken? token) =>
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 7ffea50b..dd03334a 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -1,4 +1,8 @@
 using System.Diagnostics;
+#pragma warning disable IDE0005
+// see https://learn.microsoft.com/en-us/dotnet/core/compatibility/sdk/8.0/implicit-global-using-netfx
+using System.Net.Http;
+#pragma warning restore IDE0005
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Abstractions.Websocket;
 using GraphQL.Client.Http.Websocket;
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 169260f0..6c3b30d1 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -1,4 +1,8 @@
 using System.Net;
+#pragma warning disable IDE0005
+// see https://learn.microsoft.com/en-us/dotnet/core/compatibility/sdk/8.0/implicit-global-using-netfx
+using System.Net.Http;
+#pragma warning restore IDE0005
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
 using GraphQL.Client.Http.Websocket;
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index d03b9f8e..986f1dd5 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -1,3 +1,7 @@
+#pragma warning disable IDE0005
+// see https://learn.microsoft.com/en-us/dotnet/core/compatibility/sdk/8.0/implicit-global-using-netfx
+using System.Net.Http;
+#pragma warning restore IDE0005
 using System.Net.Http.Headers;
 using System.Text;
 using GraphQL.Client.Abstractions;
diff --git a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
index 32925567..4be55bc7 100644
--- a/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLHttpWebSocket.cs
@@ -1,4 +1,8 @@
 using System.Diagnostics;
+#pragma warning disable IDE0005
+// see https://learn.microsoft.com/en-us/dotnet/core/compatibility/sdk/8.0/implicit-global-using-netfx
+using System.Net.Http;
+#pragma warning restore IDE0005
 using System.Net.WebSockets;
 using System.Reactive;
 using System.Reactive.Disposables;
diff --git a/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
index 200c0acf..7a3f8f55 100644
--- a/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/ConsistencyTests.cs
@@ -9,10 +9,8 @@ namespace GraphQL.Client.Serializer.Tests;
 
 public class ConsistencyTests
 {
-    [Fact]
-    public void MapConvertersShouldBehaveConsistent()
-    {
-        const string json = @"{
+    [Theory]
+    [InlineData(@"{
                 ""array"": [
                   ""some stuff"",
                   ""something else""
@@ -27,7 +25,26 @@ public void MapConvertersShouldBehaveConsistent()
                   {""number"": 1234.567},
                   {""number"": 567.8}
                 ]
-            }";
+            }")]
+    [InlineData("null")]
+    public void MapConvertersShouldBehaveConsistent(string json)
+    {
+        //const string json = @"{
+        //        ""array"": [
+        //          ""some stuff"",
+        //          ""something else""
+        //        ],
+        //        ""string"": ""this is a string"",
+        //        ""boolean"": true,
+        //        ""number"": 1234.567,
+        //        ""nested object"": {
+        //            ""prop1"": false
+        //        },
+        //        ""arrayOfObjects"": [
+        //          {""number"": 1234.567},
+        //          {""number"": 567.8}
+        //        ]
+        //    }";
 
         var newtonsoftSerializer = new NewtonsoftJsonSerializer();
         var systemTextJsonSerializer = new SystemTextJsonSerializer();
@@ -45,16 +62,33 @@ public void MapConvertersShouldBehaveConsistent()
             .RespectingRuntimeTypes());
     }
 
-    private void CompareMaps(Dictionary<string, object> first, Dictionary<string, object> second)
+    /// <summary>
+    /// Regression test for https://github.com/graphql-dotnet/graphql-client/issues/601
+    /// </summary>
+    [Fact]
+    public void MapConvertersShouldBeAbleToDeserializeNullValues()
     {
-        foreach (var keyValuePair in first)
-        {
-            second.Should().ContainKey(keyValuePair.Key);
-            second[keyValuePair.Key].Should().BeOfType(keyValuePair.Value.GetType());
-            if (keyValuePair.Value is Dictionary<string, object> map)
-                CompareMaps(map, (Dictionary<string, object>)second[keyValuePair.Key]);
-            else
-                keyValuePair.Value.Should().BeEquivalentTo(second[keyValuePair.Key]);
-        }
+        var newtonsoftSerializer = new NewtonsoftJsonSerializer();
+        var systemTextJsonSerializer = new SystemTextJsonSerializer();
+        string json = "null";
+
+        JsonConvert.DeserializeObject<Map>(json, newtonsoftSerializer.JsonSerializerSettings).Should().BeNull();
+        System.Text.Json.JsonSerializer.Deserialize<Map>(json, systemTextJsonSerializer.Options).Should().BeNull();
+    }
+
+    private void CompareMaps(Dictionary<string, object>? first, Dictionary<string, object>? second)
+    {
+        if (first is null)
+            second.Should().BeNull();
+        else
+            foreach (var keyValuePair in first)
+            {
+                second.Should().ContainKey(keyValuePair.Key);
+                second[keyValuePair.Key].Should().BeOfType(keyValuePair.Value.GetType());
+                if (keyValuePair.Value is Dictionary<string, object> map)
+                    CompareMaps(map, (Dictionary<string, object>)second[keyValuePair.Key]);
+                else
+                    keyValuePair.Value.Should().BeEquivalentTo(second[keyValuePair.Key]);
+            }
     }
 }
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index ed2da1ab..7273de9a 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net7</TargetFramework>
+    <TargetFramework>net8</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 138f4c67..460fe724 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index d6f082fe..fdc033fa 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net7</TargetFramework>
+    <TargetFramework>net8</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index 235c025a..5210f214 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -3,7 +3,7 @@
   <Import Project="../tests.props" />
 
   <PropertyGroup>
-    <TargetFramework>net7</TargetFramework>
+    <TargetFramework>net8</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 7220da61..4b81bde3 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net7</TargetFramework>
+    <TargetFramework>net8</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index ad1e5255..85b003c9 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net7</TargetFramework>
+    <TargetFramework>net8</TargetFramework>
     <StartupObject>IntegrationTestServer.Program</StartupObject>
     <IsPackable>false</IsPackable>
   </PropertyGroup>

From fbf37dfff2830e36a45296079bac27ec60fad550 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 23 Nov 2023 10:14:46 +0100
Subject: [PATCH 443/455] Upgrade dependencies (#603)

* upgrade dependencies

* fix code warnings
---
 .../GraphQL.Client.LocalExecution.csproj            |  4 ++--
 .../GraphQL.Client.Serializer.SystemTextJson.csproj |  2 +-
 .../ImmutableConverter.cs                           |  3 +++
 src/GraphQL.Client/GraphQL.Client.csproj            |  2 +-
 .../BaseSerializerTest.cs                           |  3 ++-
 .../GraphQL.Client.Serializer.Tests.csproj          | 13 +++++++++++--
 .../GraphQL.Client.Tests.Common.csproj              |  4 ++--
 .../GraphQL.Integration.Tests.csproj                | 13 +++++++++++--
 .../QueryAndMutationTests/Base.cs                   |  3 +--
 .../GraphQL.Integration.Tests/UriExtensionTests.cs  |  4 ++--
 .../UserAgentHeaderTests.cs                         |  8 ++++----
 .../WebsocketTests/Base.cs                          |  2 +-
 .../WebsocketTests/SystemTextJsonAutoNegotiate.cs   |  2 +-
 .../SystemTextJsonGraphQLTransportWs.cs             | 12 ++++++------
 .../WebsocketTests/SystemTextJsonGraphQLWs.cs       | 10 +++++-----
 .../GraphQL.Primitives.Tests.csproj                 |  9 +++++++++
 .../GraphQL.Primitives.Tests/GraphQLRequestTest.cs  | 11 ++++++-----
 .../GraphQL.Server.Test/GraphQL.Server.Test.csproj  |  6 +++---
 .../IntegrationTestServer.csproj                    |  6 +++---
 19 files changed, 74 insertions(+), 43 deletions(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 04261eb7..1e5575e0 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -6,8 +6,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.1" />
-    <PackageReference Include="System.Reactive" Version="5.0.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.6.1" />
+    <PackageReference Include="System.Reactive" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index e49b975d..bd570172 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Text.Json" Version="4.7.0" />
+    <PackageReference Include="System.Text.Json" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
index 2087631d..5a14d5ff 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/ImmutableConverter.cs
@@ -95,7 +95,10 @@ public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOp
             DefaultBufferSize = options.DefaultBufferSize,
             DictionaryKeyPolicy = options.DictionaryKeyPolicy,
             Encoder = options.Encoder,
+#pragma warning disable SYSLIB0020
+            // obsolete warning disabled to keep compatibility until deprecated field is removed
             IgnoreNullValues = options.IgnoreNullValues,
+#pragma warning restore SYSLIB0020
             IgnoreReadOnlyProperties = options.IgnoreReadOnlyProperties,
             MaxDepth = options.MaxDepth,
             PropertyNameCaseInsensitive = options.PropertyNameCaseInsensitive,
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 35dc2e16..241e3bcc 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -15,7 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" PrivateAssets="All" />
-    <PackageReference Include="System.Reactive" Version="5.0.0" />
+    <PackageReference Include="System.Reactive" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461'">
diff --git a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
index 0a7102a1..7cf5c3e1 100644
--- a/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
+++ b/tests/GraphQL.Client.Serializer.Tests/BaseSerializerTest.cs
@@ -199,7 +199,8 @@ public async Task CanDeserializeObjectWithBothConstructorAndProperties()
         var contentStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonString));
 
         // Act
-        var result = await ClientSerializer.DeserializeFromUtf8StreamAsync<WithConstructorAndProperties>(contentStream, default).ConfigureAwait(false);
+        var result = await ClientSerializer
+            .DeserializeFromUtf8StreamAsync<WithConstructorAndProperties>(contentStream, default);
 
         // Assert
         result.Data.Property1.Should().Be("value1");
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index 7273de9a..edf3881f 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.4.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.4.1" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.6.1" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.6.1" />
   </ItemGroup>
 
   <ItemGroup>
@@ -19,4 +19,13 @@
     <ProjectReference Include="..\GraphQL.Client.Tests.Common\GraphQL.Client.Tests.Common.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Update="xunit" Version="2.6.2" />
+    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
 </Project>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index 460fe724..f199b89a 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,8 +7,8 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.4.1" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="GraphQL" Version="7.6.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index fdc033fa..bb5b4616 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="7.0.5" />
-    <PackageReference Include="Microsoft.Reactive.Testing" Version="5.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Reactive.Testing" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>
@@ -18,4 +18,13 @@
     <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Update="xunit" Version="2.6.2" />
+    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
 </Project>
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index 0b120ba4..cb25adc6 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -1,5 +1,4 @@
 using System.Net;
-using System.Net.Http.Headers;
 using FluentAssertions;
 using GraphQL.Client.Abstractions;
 using GraphQL.Client.Http;
@@ -185,7 +184,7 @@ query Long {
         // unblock the query
         chatQuery.LongRunningQueryBlocker.Set();
         // check execution time
-        request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+        (await request.Invoke()).Data.longRunning.Should().Be("finally returned");
 
         // reset stuff
         chatQuery.LongRunningQueryBlocker.Reset();
diff --git a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
index 7e374578..80d032af 100644
--- a/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
+++ b/tests/GraphQL.Integration.Tests/UriExtensionTests.cs
@@ -30,12 +30,12 @@ public void HasWebSocketSchemaTest(string url, bool result)
     [InlineData("ftp://this-url-cannot-be-converted.net", false, null)]
     // AppSync example
     [InlineData("wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=", true, "wss://example1234567890000.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=123456789ABCDEF&payload=e30=")]
-    public void GetWebSocketUriTest(string input, bool canConvert, string result)
+    public void GetWebSocketUriTest(string input, bool canConvert, string? result)
     {
         var inputUri = new Uri(input);
         if (canConvert)
         {
-            inputUri.GetWebSocketUri().Should().BeEquivalentTo(new Uri(result));
+            inputUri.GetWebSocketUri().Should().BeEquivalentTo(new Uri(result!));
         }
         else
         {
diff --git a/tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs b/tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs
index bf631be5..ba5b7bbf 100644
--- a/tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs
+++ b/tests/GraphQL.Integration.Tests/UserAgentHeaderTests.cs
@@ -17,7 +17,7 @@ public UserAgentHeaderTests(SystemTextJsonAutoNegotiateServerTestFixture fixture
         Fixture = fixture;
     }
 
-    public async Task InitializeAsync() => await Fixture.CreateServer().ConfigureAwait(false);
+    public async Task InitializeAsync() => await Fixture.CreateServer();
 
     public Task DisposeAsync()
     {
@@ -32,7 +32,7 @@ public async void Can_set_custom_user_agent()
         ChatClient = Fixture.GetChatClient(options => options.DefaultUserAgentRequestHeader = ProductInfoHeaderValue.Parse(userAgent));
 
         var graphQLRequest = new GraphQLRequest("query clientUserAgent { clientUserAgent }");
-        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty }).ConfigureAwait(false);
+        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty });
 
         response.Errors.Should().BeNull();
         response.Data.clientUserAgent.Should().Be(userAgent);
@@ -48,7 +48,7 @@ public async void Default_user_agent_is_set_as_expected()
         ChatClient = Fixture.GetChatClient();
 
         var graphQLRequest = new GraphQLRequest("query clientUserAgent { clientUserAgent }");
-        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty }).ConfigureAwait(false);
+        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty });
 
         response.Errors.Should().BeNull();
         response.Data.clientUserAgent.Should().Be(expectedUserAgent);
@@ -60,7 +60,7 @@ public async void No_Default_user_agent_if_set_to_null()
         ChatClient = Fixture.GetChatClient(options => options.DefaultUserAgentRequestHeader = null);
 
         var graphQLRequest = new GraphQLRequest("query clientUserAgent { clientUserAgent }");
-        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty }).ConfigureAwait(false);
+        var response = await ChatClient.SendQueryAsync(graphQLRequest, () => new { clientUserAgent = string.Empty });
 
         response.Errors.Should().HaveCount(1);
         response.Errors[0].Message.Should().Be("user agent header not set");
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
index e16a4a38..98d4226d 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/Base.cs
@@ -121,7 +121,7 @@ query Long {
         // unblock the query
         chatQuery.LongRunningQueryBlocker.Set();
         // check execution time
-        request.Invoke().Result.Data.longRunning.Should().Be("finally returned");
+        (await request.Invoke()).Data.longRunning.Should().Be("finally returned");
 
         // reset stuff
         chatQuery.LongRunningQueryBlocker.Reset();
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs
index 0090e307..e6d72c90 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonAutoNegotiate.cs
@@ -15,7 +15,7 @@ public SystemTextJsonAutoNegotiate(ITestOutputHelper output, SystemTextJsonAutoN
     [Fact]
     public async Task WebSocketProtocolIsAutoNegotiated()
     {
-        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+        await ChatClient.InitializeWebsocketConnection();
         ChatClient.WebSocketSubProtocol.Should().Be(WebSocketProtocols.GRAPHQL_TRANSPORT_WS);
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs
index dfba089e..50fc92a0 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLTransportWs.cs
@@ -15,21 +15,21 @@ public SystemTextJsonGraphQLTransportWs(ITestOutputHelper output, SystemTextJson
     [Fact]
     public async void Sending_a_pong_message_should_not_throw()
     {
-        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+        await ChatClient.InitializeWebsocketConnection();
 
-        await ChatClient.Awaiting(client => client.SendPongAsync(null)).Should().NotThrowAsync().ConfigureAwait(false);
-        await ChatClient.Awaiting(client => client.SendPongAsync("some payload")).Should().NotThrowAsync().ConfigureAwait(false);
+        await ChatClient.Awaiting(client => client.SendPongAsync(null)).Should().NotThrowAsync();
+        await ChatClient.Awaiting(client => client.SendPongAsync("some payload")).Should().NotThrowAsync();
     }
 
     [Fact]
     public async void Sending_a_ping_message_should_result_in_a_pong_message_from_the_server()
     {
-        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+        await ChatClient.InitializeWebsocketConnection();
 
         using var pongObserver = ChatClient.PongStream.Observe();
 
-        await ChatClient.Awaiting(client => client.SendPingAsync(null)).Should().NotThrowAsync().ConfigureAwait(false);
+        await ChatClient.Awaiting(client => client.SendPingAsync(null)).Should().NotThrowAsync();
 
-        await pongObserver.Should().PushAsync(1, TimeSpan.FromSeconds(1), "because the server was pinged by the client").ConfigureAwait(false);
+        await pongObserver.Should().PushAsync(1, TimeSpan.FromSeconds(1), "because the server was pinged by the client");
     }
 }
diff --git a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs
index 963f8292..b1efe0b1 100644
--- a/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests/SystemTextJsonGraphQLWs.cs
@@ -14,25 +14,25 @@ public SystemTextJsonGraphQLWs(ITestOutputHelper output, SystemTextJsonGraphQLWs
     [Fact]
     public async void Sending_a_ping_message_should_throw_not_supported_exception()
     {
-        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+        await ChatClient.InitializeWebsocketConnection();
 
         await ChatClient.Awaiting(client => client.SendPingAsync(null))
-            .Should().ThrowAsync<NotSupportedException>().ConfigureAwait(false);
+            .Should().ThrowAsync<NotSupportedException>();
     }
 
     [Fact]
     public async void Sending_a_pong_message_should_throw_not_supported_exception()
     {
-        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+        await ChatClient.InitializeWebsocketConnection();
 
         await ChatClient.Awaiting(client => client.SendPongAsync(null))
-            .Should().ThrowAsync<NotSupportedException>().ConfigureAwait(false);
+            .Should().ThrowAsync<NotSupportedException>();
     }
 
     [Fact]
     public async void Subscribing_to_the_pong_stream_should_throw_not_supported_exception()
     {
-        await ChatClient.InitializeWebsocketConnection().ConfigureAwait(false);
+        await ChatClient.InitializeWebsocketConnection();
 
         ChatClient.Invoking(client => client.PongStream.Subscribe())
             .Should().Throw<NotSupportedException>();
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index 5210f214..ffe7c0a6 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -10,4 +10,13 @@
     <ProjectReference Include="..\..\src\GraphQL.Primitives\GraphQL.Primitives.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Update="xunit" Version="2.6.2" />
+    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
 </Project>
diff --git a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
index b56e6376..45560652 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
+++ b/tests/GraphQL.Primitives.Tests/GraphQLRequestTest.cs
@@ -1,3 +1,4 @@
+using FluentAssertions;
 using Xunit;
 
 namespace GraphQL.Primitives.Tests;
@@ -26,7 +27,7 @@ public void ConstructorExtendedFact()
     public void Equality1Fact()
     {
         var graphQLRequest = new GraphQLRequest("{hero{name}}");
-        Assert.Equal(graphQLRequest, graphQLRequest);
+        graphQLRequest.Equals(graphQLRequest).Should().BeTrue();
     }
 
     [Fact]
@@ -34,7 +35,7 @@ public void Equality2Fact()
     {
         var graphQLRequest1 = new GraphQLRequest("{hero{name}}");
         var graphQLRequest2 = new GraphQLRequest("{hero{name}}");
-        Assert.Equal(graphQLRequest1, graphQLRequest2);
+        graphQLRequest1.Equals(graphQLRequest2).Should().BeTrue();
     }
 
     [Fact]
@@ -42,7 +43,7 @@ public void Equality3Fact()
     {
         var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
         var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue" }, "operationName");
-        Assert.Equal(graphQLRequest1, graphQLRequest2);
+        graphQLRequest1.Equals(graphQLRequest2).Should().BeTrue();
     }
 
     [Fact]
@@ -66,7 +67,7 @@ public void InEquality1Fact()
     {
         var graphQLRequest1 = new GraphQLRequest("{hero{name1}}");
         var graphQLRequest2 = new GraphQLRequest("{hero{name2}}");
-        Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+        graphQLRequest1.Equals(graphQLRequest2).Should().BeFalse();
     }
 
     [Fact]
@@ -74,7 +75,7 @@ public void InEquality2Fact()
     {
         var graphQLRequest1 = new GraphQLRequest("{hero{name}}", new { varName = "varValue1" }, "operationName");
         var graphQLRequest2 = new GraphQLRequest("{hero{name}}", new { varName = "varValue2" }, "operationName");
-        Assert.NotEqual(graphQLRequest1, graphQLRequest2);
+        graphQLRequest1.Equals(graphQLRequest2).Should().BeFalse();
     }
 
     [Fact]
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 4b81bde3..00d8126c 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.4.1" />
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.4.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.4.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.6.1" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.6.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.6.0" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 85b003c9..66d8071d 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,9 +11,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.All" Version="7.4.0" />
-    <PackageReference Include="System.Reactive" Version="5.0.0" />
-    <PackageReference Include="System.Reactive.Compatibility" Version="5.0.0" />
+    <PackageReference Include="GraphQL.Server.All" Version="7.6.0" />
+    <PackageReference Include="System.Reactive" Version="6.0.0" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>

From 3e062755e952bbdc20b3158e17ecb131214c6103 Mon Sep 17 00:00:00 2001
From: zooeywm <zooeywm@gmail.com>
Date: Wed, 20 Mar 2024 19:39:42 +0800
Subject: [PATCH 444/455] Add new often used constructor (#627)

---
 src/GraphQL.Client/GraphQLHttpClient.cs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index dd03334a..10076b8a 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -71,6 +71,15 @@ public GraphQLHttpClient(GraphQLHttpClientOptions options, IGraphQLWebsocketJson
         _lazyHttpWebSocket = new Lazy<GraphQLHttpWebSocket>(CreateGraphQLHttpWebSocket);
     }
 
+    public GraphQLHttpClient(Action<GraphQLHttpClientOptions> configure, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
+        : this(configure.New(), serializer, httpClient) { }
+
+    public GraphQLHttpClient(Uri endPoint, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
+        : this(o => o.EndPoint = endPoint, serializer, httpClient) { }
+
+    public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serializer, HttpClient httpClient)
+        : this(new Uri(endPoint), serializer, httpClient) { }
+
     #endregion
 
     #region IGraphQLClient

From 875520a3804e6a70967ec94fd809512e9772980b Mon Sep 17 00:00:00 2001
From: Adam Williams <lol768@users.noreply.github.com>
Date: Tue, 16 Apr 2024 09:14:35 +0100
Subject: [PATCH 445/455] Address #630 (#631)

* Address #630

* Multi-framework build for primitives project

* PR feedback: extension methods
---
 .../GraphQL.Client.Abstractions.csproj          |  2 +-
 .../GraphQLClientExtensions.cs                  |  6 ++++--
 .../GraphQL.Primitives.csproj                   |  2 +-
 src/GraphQL.Primitives/GraphQLRequest.cs        |  5 ++++-
 src/GraphQL.Primitives/StringSyntaxAttribute.cs | 17 +++++++++++++++++
 5 files changed, 27 insertions(+), 5 deletions(-)
 create mode 100644 src/GraphQL.Primitives/StringSyntaxAttribute.cs

diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index 58f116f2..a18177ca 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Description>Abstractions for GraphQL.Client</Description>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net7.0;net8.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index e27d1a9a..cce6db1a 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -1,9 +1,11 @@
+using System.Diagnostics.CodeAnalysis;
+
 namespace GraphQL.Client.Abstractions;
 
 public static class GraphQLClientExtensions
 {
     public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
-        string query, object? variables = null,
+        [StringSyntax("GraphQL")] string query, object? variables = null,
         string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
     {
         _ = defineResponseType;
@@ -12,7 +14,7 @@ public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IG
     }
 
     public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
-        string query, object? variables = null,
+        [StringSyntax("GraphQL")] string query, object? variables = null,
         string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
     {
         _ = defineResponseType;
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index 676e6fe8..b49b7360 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>GraphQL basic types</Description>
     <RootNamespace>GraphQL</RootNamespace>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net7.0;net8.0</TargetFrameworks>
   </PropertyGroup>
 
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index f33ed88a..7aecb656 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -1,3 +1,5 @@
+using System.Diagnostics.CodeAnalysis;
+
 namespace GraphQL;
 
 /// <summary>
@@ -13,6 +15,7 @@ public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequ
     /// <summary>
     /// The Query
     /// </summary>
+    [StringSyntax("GraphQL")]
     public string Query
     {
         get => TryGetValue(QUERY_KEY, out object value) ? (string)value : null;
@@ -48,7 +51,7 @@ public object? Variables
 
     public GraphQLRequest() { }
 
-    public GraphQLRequest(string query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
+    public GraphQLRequest([StringSyntax("GraphQL")] string query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
     {
         Query = query;
         Variables = variables;
diff --git a/src/GraphQL.Primitives/StringSyntaxAttribute.cs b/src/GraphQL.Primitives/StringSyntaxAttribute.cs
new file mode 100644
index 00000000..8ea74c0e
--- /dev/null
+++ b/src/GraphQL.Primitives/StringSyntaxAttribute.cs
@@ -0,0 +1,17 @@
+#if !NET7_0_OR_GREATER
+
+namespace System.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// Stub
+/// </summary>
+public sealed class StringSyntaxAttribute : Attribute
+{
+    public const string CompositeFormat = nameof(CompositeFormat);
+
+    public StringSyntaxAttribute(string syntax)
+    {
+    }
+
+}
+#endif

From 6d1c0109d3085a2e992dca6fb032e7c3477b81d3 Mon Sep 17 00:00:00 2001
From: Kenneth Tubman <dev@kentubman5.com>
Date: Tue, 16 Apr 2024 05:06:54 -0400
Subject: [PATCH 446/455] Removed reference to
 GraphQL.Client.Serializer.Newtonsoft in GraphQL.Client.LocalExecution (#633)

---
 .../GraphQL.Client.LocalExecution.csproj                         | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 1e5575e0..81bc57c3 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -12,7 +12,6 @@
 
   <ItemGroup>
     <ProjectReference Include="..\GraphQL.Client.Abstractions\GraphQL.Client.Abstractions.csproj" />
-    <ProjectReference Include="..\GraphQL.Client.Serializer.Newtonsoft\GraphQL.Client.Serializer.Newtonsoft.csproj" />
   </ItemGroup>
 
 </Project>

From 6681418dd19657bcbc808a7858190da97e410930 Mon Sep 17 00:00:00 2001
From: Kim Lukas Bechtold <51699215+kimlukas@users.noreply.github.com>
Date: Mon, 22 Apr 2024 08:39:32 +0200
Subject: [PATCH 447/455] Waiting when disposing till the stop message was sent
 (#635)

Co-authored-by: kim <kim.bechtold@webfactory-i4.de>
---
 .../Websocket/GraphQLTransportWSProtocolHandler.cs            | 4 ++--
 src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs b/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
index 1ac5ffeb..2f3b28b0 100644
--- a/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLTransportWSProtocolHandler.cs
@@ -116,7 +116,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionObservable<TRes
 
             var disposable = new CompositeDisposable(
                 observable.Subscribe(observer),
-                Disposable.Create(async () =>
+                Disposable.Create(() =>
                 {
                     Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{_webSocketHandler.WebSocketState}'");
                     // only try to send close request on open websocket
@@ -126,7 +126,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionObservable<TRes
                     try
                     {
                         Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
-                        await _queueWebSocketRequest(stopRequest).ConfigureAwait(false);
+                        _queueWebSocketRequest(stopRequest).GetAwaiter().GetResult();
                     }
                     // do not break on disposing
                     catch (OperationCanceledException) { }
diff --git a/src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs b/src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs
index 03efdba4..e08da57e 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLWSProtocolHandler.cs
@@ -101,7 +101,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionObservable<TRes
 
             var disposable = new CompositeDisposable(
                 observable.Subscribe(observer),
-                Disposable.Create(async () =>
+                Disposable.Create(() =>
                 {
                     Debug.WriteLine($"disposing subscription {startRequest.Id}, websocket state is '{_webSocketHandler.WebSocketState}'");
                     // only try to send close request on open websocket
@@ -111,7 +111,7 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionObservable<TRes
                     try
                     {
                         Debug.WriteLine($"sending stop message on subscription {startRequest.Id}");
-                        await _queueWebSocketRequest(stopRequest).ConfigureAwait(false);
+                        _queueWebSocketRequest(stopRequest).GetAwaiter().GetResult();
                     }
                     // do not break on disposing
                     catch (OperationCanceledException) { }

From c6af8e4e745ad305a389349672b1b1c860504057 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 22 Apr 2024 07:26:04 +0000
Subject: [PATCH 448/455] Bump actions/upload-artifact from 3 to 4 (#610)

---
 .github/workflows/branches.yml | 2 +-
 .github/workflows/master.yml   | 2 +-
 .github/workflows/publish.yml  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 494f1c75..d2e02ead 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -48,7 +48,7 @@ jobs:
     - name: Create NuGet packages
       run: dotnet pack -c Release --no-restore --no-build -o nupkg
     - name: Upload nuget packages
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: nupkg
         path: nupkg
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 3fc48c41..638d0141 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -49,7 +49,7 @@ jobs:
     - name: Create NuGet packages
       run: dotnet pack -c Release --no-restore --no-build -o nupkg
     - name: Upload nuget packages as artifacts
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: nupkg
         path: nupkg
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index a7ebfb2e..d882f674 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -51,7 +51,7 @@ jobs:
     - name: Create NuGet packages
       run: dotnet pack -c Release --no-restore --no-build -o nupkg
     - name: Upload nuget packages as artifacts
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: nupkg
         path: nupkg

From 28f9d6865efb4b2436b46b0ee1df0964321c4603 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:30:47 +0200
Subject: [PATCH 449/455] Bump actions/setup-dotnet from 3 to 4 (#608)

Bumps [actions/setup-dotnet](https://github.com/actions/setup-dotnet) from 3 to 4.
- [Release notes](https://github.com/actions/setup-dotnet/releases)
- [Commits](https://github.com/actions/setup-dotnet/compare/v3...v4)

---
updated-dependencies:
- dependency-name: actions/setup-dotnet
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/branches.yml | 2 +-
 .github/workflows/master.yml   | 2 +-
 .github/workflows/publish.yml  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index d2e02ead..9b0c6169 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -22,7 +22,7 @@ jobs:
       with:
         fetch-depth: 0
     - name: Setup .NET SDK
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
         dotnet-version: |
           7.0.x
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 638d0141..63015235 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -21,7 +21,7 @@ jobs:
       with:
         fetch-depth: 0
     - name: Setup .NET SDK
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
         dotnet-version: "7.0.x"
         source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index d882f674..0abace42 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -25,7 +25,7 @@ jobs:
         echo github.ref: ${{ github.ref }}
         exit 1
     - name: Setup .NET SDK
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
         dotnet-version: "7.0.x"
         source-url: https://api.nuget.org/v3/index.json

From 26abe3e99498eaa4d06ba174e3be25384f77544d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:31:39 +0200
Subject: [PATCH 450/455] Bump actions/checkout from 3 to 4 (#606)

Bumps [actions/checkout](https://github.com/actions/checkout) from 3 to 4.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v3...v4)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/branches.yml | 2 +-
 .github/workflows/master.yml   | 2 +-
 .github/workflows/publish.yml  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 9b0c6169..52a0b4c1 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
     - name: Setup .NET SDK
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 63015235..4803f900 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
     - name: Setup .NET SDK
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 0abace42..60978cdf 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
     - name: Check github.ref starts with 'refs/tags/'

From 95d3476b0dea110c30c9f5e82788ab2b262078bc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:32:41 +0200
Subject: [PATCH 451/455] Bump actions/github-script from 6 to 7 (#605)

Bumps [actions/github-script](https://github.com/actions/github-script) from 6 to 7.
- [Release notes](https://github.com/actions/github-script/releases)
- [Commits](https://github.com/actions/github-script/compare/v6...v7)

---
updated-dependencies:
- dependency-name: actions/github-script
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/publish.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 60978cdf..eb5df29b 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -58,7 +58,7 @@ jobs:
     - name: Publish Nuget packages to Nuget registry
       run: dotnet nuget push "nupkg/*" -k ${{secrets.NUGET_API_KEY}}
     - name: Upload Nuget packages as release artifacts
-      uses: actions/github-script@v6
+      uses: actions/github-script@v7
       with:
         github-token: ${{secrets.GITHUB_TOKEN}}
         script: |

From 79b0161e611829ea563671b2d7972f8bf803d900 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 22 Apr 2024 09:36:09 +0200
Subject: [PATCH 452/455] Prepare Release 6.0.4 (#634)

* add stringsyntaxattribute to constructor of GraphQLHttpRequest, ad "QL" abbreviation to resharper dictionary

* disable compiler warnings in stub StringSyntaxAttribute for netstandard2.0

* upgrade dependencies

* use dotnet 8.0 for gh workflows
---
 .github/workflows/branches.yml                |  2 +-
 .github/workflows/master.yml                  |  2 +-
 .github/workflows/publish.yml                 |  2 +-
 GraphQL.Client.sln                            |  1 +
 GraphQL.Client.sln.DotSettings                |  2 +
 .../GraphQL.Client.LocalExecution.csproj      |  2 +-
 ...QL.Client.Serializer.SystemTextJson.csproj |  2 +-
 src/GraphQL.Client/GraphQLHttpRequest.cs      | 99 ++++++++++---------
 .../StringSyntaxAttribute.cs                  | 10 +-
 .../GraphQL.Client.Serializer.Tests.csproj    | 14 ++-
 .../GraphQL.Client.Tests.Common.csproj        |  2 +-
 .../StarWars/Types/DroidType.cs               |  3 +-
 .../StarWars/Types/HumanType.cs               |  3 +-
 .../GraphQL.Integration.Tests.csproj          | 12 ++-
 .../GraphQL.Primitives.Tests.csproj           | 10 +-
 .../GraphQL.Server.Test.csproj                |  6 +-
 .../IntegrationTestServer.csproj              |  2 +-
 17 files changed, 96 insertions(+), 78 deletions(-)
 create mode 100644 GraphQL.Client.sln.DotSettings

diff --git a/.github/workflows/branches.yml b/.github/workflows/branches.yml
index 52a0b4c1..8ae6f0f8 100644
--- a/.github/workflows/branches.yml
+++ b/.github/workflows/branches.yml
@@ -25,7 +25,7 @@ jobs:
       uses: actions/setup-dotnet@v4
       with:
         dotnet-version: |
-          7.0.x
+          8.0.x
     - name: Restore dotnet tools
       run: dotnet tool restore
     - name: Fetch complete repository including tags
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index 4803f900..b26156bb 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -23,7 +23,7 @@ jobs:
     - name: Setup .NET SDK
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: "7.0.x"
+        dotnet-version: "8.0.x"
         source-url: https://nuget.pkg.github.com/graphql-dotnet/index.json
       env:
         NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index eb5df29b..bbb89933 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -27,7 +27,7 @@ jobs:
     - name: Setup .NET SDK
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: "7.0.x"
+        dotnet-version: "8.0.x"
         source-url: https://api.nuget.org/v3/index.json
       env:
         NUGET_AUTH_TOKEN: ${{secrets.NUGET_API_KEY}}
diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 89782ecc..af2fd372 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -32,6 +32,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{
 	ProjectSection(SolutionItems) = preProject
 		.github\workflows\branches.yml = .github\workflows\branches.yml
 		.github\workflows\master.yml = .github\workflows\master.yml
+		.github\workflows\publish.yml = .github\workflows\publish.yml
 	EndProjectSection
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Primitives", "src\GraphQL.Primitives\GraphQL.Primitives.csproj", "{87FC440E-6A4D-47D8-9EB2-416FC31CC4A6}"
diff --git a/GraphQL.Client.sln.DotSettings b/GraphQL.Client.sln.DotSettings
new file mode 100644
index 00000000..9e5ec22f
--- /dev/null
+++ b/GraphQL.Client.sln.DotSettings
@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=QL/@EntryIndexedValue">QL</s:String></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
index 81bc57c3..687cc656 100644
--- a/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
+++ b/src/GraphQL.Client.LocalExecution/GraphQL.Client.LocalExecution.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.6.1" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.8.0" />
     <PackageReference Include="System.Reactive" Version="6.0.0" />
   </ItemGroup>
 
diff --git a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
index bd570172..2a436c50 100644
--- a/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
+++ b/src/GraphQL.Client.Serializer.SystemTextJson/GraphQL.Client.Serializer.SystemTextJson.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
-    <PackageReference Include="System.Text.Json" Version="8.0.0" />
+    <PackageReference Include="System.Text.Json" Version="8.0.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 986f1dd5..b89d1814 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -1,52 +1,53 @@
-#pragma warning disable IDE0005
-// see https://learn.microsoft.com/en-us/dotnet/core/compatibility/sdk/8.0/implicit-global-using-netfx
-using System.Net.Http;
-#pragma warning restore IDE0005
-using System.Net.Http.Headers;
-using System.Text;
-using GraphQL.Client.Abstractions;
-
-namespace GraphQL.Client.Http;
-
-public class GraphQLHttpRequest : GraphQLRequest
-{
-    public GraphQLHttpRequest()
-    {
-    }
-
-    public GraphQLHttpRequest(string query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
-        : base(query, variables, operationName, extensions)
-    {
-    }
-
-    public GraphQLHttpRequest(GraphQLRequest other)
-        : base(other)
-    {
-    }
-
-    /// <summary>
-    /// Creates a <see cref="HttpRequestMessage"/> from this <see cref="GraphQLHttpRequest"/>.
-    /// Used by <see cref="GraphQLHttpClient"/> to convert GraphQL requests when sending them as regular HTTP requests.
-    /// </summary>
-    /// <param name="options">the <see cref="GraphQLHttpClientOptions"/> passed from <see cref="GraphQLHttpClient"/></param>
-    /// <param name="serializer">the <see cref="IGraphQLJsonSerializer"/> passed from <see cref="GraphQLHttpClient"/></param>
-    /// <returns></returns>
-    public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions options, IGraphQLJsonSerializer serializer)
-    {
-        var message = new HttpRequestMessage(HttpMethod.Post, options.EndPoint)
-        {
-            Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
-        };
-        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql-response+json"));
-        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+#pragma warning disable IDE0005
+// see https://learn.microsoft.com/en-us/dotnet/core/compatibility/sdk/8.0/implicit-global-using-netfx
+using System.Diagnostics.CodeAnalysis;
+using System.Net.Http;
+#pragma warning restore IDE0005
+using System.Net.Http.Headers;
+using System.Text;
+using GraphQL.Client.Abstractions;
+
+namespace GraphQL.Client.Http;
+
+public class GraphQLHttpRequest : GraphQLRequest
+{
+    public GraphQLHttpRequest()
+    {
+    }
+
+    public GraphQLHttpRequest([StringSyntax("GraphQL")] string query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
+        : base(query, variables, operationName, extensions)
+    {
+    }
+
+    public GraphQLHttpRequest(GraphQLRequest other)
+        : base(other)
+    {
+    }
+
+    /// <summary>
+    /// Creates a <see cref="HttpRequestMessage"/> from this <see cref="GraphQLHttpRequest"/>.
+    /// Used by <see cref="GraphQLHttpClient"/> to convert GraphQL requests when sending them as regular HTTP requests.
+    /// </summary>
+    /// <param name="options">the <see cref="GraphQLHttpClientOptions"/> passed from <see cref="GraphQLHttpClient"/></param>
+    /// <param name="serializer">the <see cref="IGraphQLJsonSerializer"/> passed from <see cref="GraphQLHttpClient"/></param>
+    /// <returns></returns>
+    public virtual HttpRequestMessage ToHttpRequestMessage(GraphQLHttpClientOptions options, IGraphQLJsonSerializer serializer)
+    {
+        var message = new HttpRequestMessage(HttpMethod.Post, options.EndPoint)
+        {
+            Content = new StringContent(serializer.SerializeToString(this), Encoding.UTF8, options.MediaType)
+        };
+        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/graphql-response+json"));
+        message.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
         message.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
 
         // Explicitly setting content header to avoid issues with some GrahQL servers
-        message.Content.Headers.ContentType = new MediaTypeHeaderValue(options.MediaType);
-
-        if (options.DefaultUserAgentRequestHeader != null)
-            message.Headers.UserAgent.Add(options.DefaultUserAgentRequestHeader);
-
-        return message;
-    }
-}
+        message.Content.Headers.ContentType = new MediaTypeHeaderValue(options.MediaType);
+
+        if (options.DefaultUserAgentRequestHeader != null)
+            message.Headers.UserAgent.Add(options.DefaultUserAgentRequestHeader);
+
+        return message;
+    }
+}
diff --git a/src/GraphQL.Primitives/StringSyntaxAttribute.cs b/src/GraphQL.Primitives/StringSyntaxAttribute.cs
index 8ea74c0e..76e5b5e4 100644
--- a/src/GraphQL.Primitives/StringSyntaxAttribute.cs
+++ b/src/GraphQL.Primitives/StringSyntaxAttribute.cs
@@ -1,5 +1,6 @@
 #if !NET7_0_OR_GREATER
 
+// ReSharper disable once CheckNamespace
 namespace System.Diagnostics.CodeAnalysis;
 
 /// <summary>
@@ -7,11 +8,14 @@ namespace System.Diagnostics.CodeAnalysis;
 /// </summary>
 public sealed class StringSyntaxAttribute : Attribute
 {
+    // ReSharper disable once InconsistentNaming
+#pragma warning disable IDE1006
     public const string CompositeFormat = nameof(CompositeFormat);
+#pragma warning restore IDE1006
 
+#pragma warning disable IDE0060
     public StringSyntaxAttribute(string syntax)
-    {
-    }
-
+    { }
+#pragma warning restore IDE0060
 }
 #endif
diff --git a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
index edf3881f..b0efc377 100644
--- a/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
+++ b/tests/GraphQL.Client.Serializer.Tests/GraphQL.Client.Serializer.Tests.csproj
@@ -7,8 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.6.1" />
-    <PackageReference Include="GraphQL.SystemTextJson" Version="7.6.1" />
+    <PackageReference Include="GraphQL.NewtonsoftJson" Version="7.8.0" />
+    <PackageReference Include="GraphQL.SystemTextJson" Version="7.8.0" />
   </ItemGroup>
 
   <ItemGroup>
@@ -20,9 +20,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Update="xunit" Version="2.6.2" />
-    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.4">
+    <PackageReference Update="coverlet.collector" Version="6.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Update="xunit" Version="2.7.1" />
+    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
index f199b89a..6b76cf7d 100644
--- a/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
+++ b/tests/GraphQL.Client.Tests.Common/GraphQL.Client.Tests.Common.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions.Reactive" Version="0.2.0" />
-    <PackageReference Include="GraphQL" Version="7.6.1" />
+    <PackageReference Include="GraphQL" Version="7.8.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
   </ItemGroup>
 
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
index 72680c43..661737f6 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/DroidType.cs
@@ -15,8 +15,7 @@ public DroidType(StarWarsData data)
 
         Field<ListGraphType<CharacterInterface>>("friends").Resolve(context => data.GetFriends(context.Source));
 
-        Connection<CharacterInterface>()
-            .Name("friendsConnection")
+        Connection<CharacterInterface>("friendsConnection")
             .Description("A list of a character's friends.")
             .Bidirectional()
             .Resolve(context => context.GetPagedResults<Droid, StarWarsCharacter>(data, context.Source.Friends));
diff --git a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
index a95e01d0..ed19cf5c 100644
--- a/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
+++ b/tests/GraphQL.Client.Tests.Common/StarWars/Types/HumanType.cs
@@ -14,8 +14,7 @@ public HumanType(StarWarsData data)
 
         Field<ListGraphType<CharacterInterface>>("friends").Resolve(context => data.GetFriends(context.Source));
 
-        Connection<CharacterInterface>()
-            .Name("friendsConnection")
+        Connection<CharacterInterface>("friendsConnection")
             .Description("A list of a character's friends.")
             .Bidirectional()
             .Resolve(context => context.GetPagedResults<Human, StarWarsCharacter>(data, context.Source.Friends));
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index bb5b4616..4a3f7dc2 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.0.4" />
     <PackageReference Include="Microsoft.Reactive.Testing" Version="6.0.0" />
   </ItemGroup>
 
@@ -19,9 +19,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Update="xunit" Version="2.6.2" />
-    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.4">
+    <PackageReference Update="coverlet.collector" Version="6.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Update="xunit" Version="2.7.1" />
+    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
index ffe7c0a6..d17dbc94 100644
--- a/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
+++ b/tests/GraphQL.Primitives.Tests/GraphQL.Primitives.Tests.csproj
@@ -11,9 +11,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Update="xunit" Version="2.6.2" />
-    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.4">
+    <PackageReference Update="coverlet.collector" Version="6.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Update="Microsoft.NET.Test.Sdk" Version="17.9.0" />
+    <PackageReference Update="xunit" Version="2.7.1" />
+    <PackageReference Update="xunit.runner.visualstudio" Version="2.5.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
index 00d8126c..191bfd81 100644
--- a/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
+++ b/tests/GraphQL.Server.Test/GraphQL.Server.Test.csproj
@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.6.1" />
-    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.6.0" />
-    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.6.0" />
+    <PackageReference Include="GraphQL.MicrosoftDI" Version="7.8.0" />
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="7.7.1" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="7.7.1" />
   </ItemGroup>
 
 </Project>
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index 66d8071d..58854750 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GraphQL.Server.All" Version="7.6.0" />
+    <PackageReference Include="GraphQL.Server.All" Version="7.7.1" />
     <PackageReference Include="System.Reactive" Version="6.0.0" />
     <PackageReference Include="System.Reactive.Compatibility" Version="6.0.0" />
   </ItemGroup>

From fd2cf06f7f294176719d48a7ed4f062d2baf6b14 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 22 Apr 2024 11:50:31 +0200
Subject: [PATCH 453/455] Document syntax highlighting (#637)

* copy code for StringSyntaxAttribute from original source

* document syntax highlighting

* add note on usage of GraphQLHttpClient

* add note on response type

* fix wording
---
 README.md                                     | 23 ++++++-
 .../StringSyntaxAttribute.cs                  | 69 ++++++++++++++++---
 2 files changed, 82 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 0866ef7a..6dc83af6 100644
--- a/README.md
+++ b/README.md
@@ -29,6 +29,9 @@ The Library will try to follow the following standards and documents:
 var graphQLClient = new GraphQLHttpClient("https://api.example.com/graphql", new NewtonsoftJsonSerializer());
 ```
 
+> [!NOTE]
+> *GraphQLHttpClient* is meant to be used as a single longlived instance per endpoint (i.e. register as singleton in a DI system), which should be reused for multiple requests.
+
 ### Create a GraphQLRequest:
 #### Simple Request:
 ```csharp
@@ -64,7 +67,10 @@ var personAndFilmsRequest = new GraphQLRequest {
 };
 ```
 
-Be careful when using `byte[]` in your variables object, as most JSON serializers will treat that as binary data! If you really need to send a *list of bytes* with a `byte[]` as a source, then convert it to a `List<byte>` first, which will tell the serializer to output a list of numbers instead of a base64-encoded string.
+> [!WARNING]
+> Be careful when using `byte[]` in your variables object, as most JSON serializers will treat that as binary data.
+> 
+> If you really need to send a *list of bytes* with a `byte[]` as a  source, then convert it to a `List<byte>` first, which will tell the serializer to output a list of numbers instead of a base64-encoded string.
 
 ### Execute Query/Mutation:
 
@@ -100,6 +106,11 @@ var graphQLResponse = await graphQLClient.SendQueryAsync(personAndFilmsRequest,
 var personName = graphQLResponse.Data.person.Name;
 ```
 
+> [!IMPORTANT]
+> Note that the field in the GraphQL response which gets deserialized into the response object is the `data` field.
+>
+> A common mistake is to try to directly use the `PersonType` class as response type (because thats the *thing* you actually want to query), but the returned response object contains a property `person` containing a `PersonType` object (like the `ResponseType` modelled above).
+
 ### Use Subscriptions
 
 ```csharp
@@ -141,6 +152,16 @@ var subscription = subscriptionStream.Subscribe(response =>
 subscription.Dispose();
 ```
 
+## Syntax Highlighting for GraphQL strings in IDEs
+
+.NET 7.0 introduced the [StringSyntaxAttribute](https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.stringsyntaxattribute?view=net-8.0) to have a unified way of telling what data is expected in a given `string` or `ReadOnlySpan<char>`. IDEs like Visual Studio and Rider can then use this to provide syntax highlighting and checking.
+
+From v6.0.4 on all GraphQL string parameters in this library are decorated with the `[StringSyntax("GraphQL")]` attribute.
+
+Currently, there is no native support for GraphQL formatting and syntax highlighting in Visual Studio, but the [GraphQLTools Extension](https://marketplace.visualstudio.com/items?itemName=codearchitects-research.GraphQLTools) provides that for you.
+
+For Rider, JetBrains provides a [Plugin](https://plugins.jetbrains.com/plugin/8097-graphql), too.
+
 ## Useful Links:
 
 * [StarWars Example Server (GitHub)](https://github.com/graphql/swapi-graphql)
diff --git a/src/GraphQL.Primitives/StringSyntaxAttribute.cs b/src/GraphQL.Primitives/StringSyntaxAttribute.cs
index 76e5b5e4..8be2e889 100644
--- a/src/GraphQL.Primitives/StringSyntaxAttribute.cs
+++ b/src/GraphQL.Primitives/StringSyntaxAttribute.cs
@@ -1,21 +1,72 @@
 #if !NET7_0_OR_GREATER
 
+// ReSharper disable InconsistentNaming
 // ReSharper disable once CheckNamespace
 namespace System.Diagnostics.CodeAnalysis;
 
-/// <summary>
-/// Stub
-/// </summary>
+/// <summary>Stub version of the StringSyntaxAttribute, which was introduced in .NET 7</summary>
 public sealed class StringSyntaxAttribute : Attribute
 {
-    // ReSharper disable once InconsistentNaming
+    /// <summary>Initializes the <see cref="StringSyntaxAttribute"/> with the identifier of the syntax used.</summary>
+    /// <param name="syntax">The syntax identifier.</param>
+    public StringSyntaxAttribute(string syntax)
+    {
+        Syntax = syntax;
+        Arguments = Array.Empty<object?>();
+    }
+
+    /// <summary>Initializes the <see cref="StringSyntaxAttribute"/> with the identifier of the syntax used.</summary>
+    /// <param name="syntax">The syntax identifier.</param>
+    /// <param name="arguments">Optional arguments associated with the specific syntax employed.</param>
+    public StringSyntaxAttribute(string syntax, params object?[] arguments)
+    {
+        Syntax = syntax;
+        Arguments = arguments;
+    }
+
+    /// <summary>Gets the identifier of the syntax used.</summary>
+    public string Syntax { get; }
+
+    /// <summary>Optional arguments associated with the specific syntax employed.</summary>
+    public object?[] Arguments { get; }
+
+    /// <summary>The syntax identifier for strings containing composite formats for string formatting.</summary>
 #pragma warning disable IDE1006
     public const string CompositeFormat = nameof(CompositeFormat);
-#pragma warning restore IDE1006
 
-#pragma warning disable IDE0060
-    public StringSyntaxAttribute(string syntax)
-    { }
-#pragma warning restore IDE0060
+    /// <summary>The syntax identifier for strings containing date format specifiers.</summary>
+    public const string DateOnlyFormat = nameof(DateOnlyFormat);
+
+    /// <summary>The syntax identifier for strings containing date and time format specifiers.</summary>
+    public const string DateTimeFormat = nameof(DateTimeFormat);
+
+    /// <summary>The syntax identifier for strings containing <see cref="Enum"/> format specifiers.</summary>
+    public const string EnumFormat = nameof(EnumFormat);
+
+    /// <summary>The syntax identifier for strings containing <see cref="Guid"/> format specifiers.</summary>
+    public const string GuidFormat = nameof(GuidFormat);
+
+    /// <summary>The syntax identifier for strings containing JavaScript Object Notation (JSON).</summary>
+    public const string Json = nameof(Json);
+
+    /// <summary>The syntax identifier for strings containing numeric format specifiers.</summary>
+    public const string NumericFormat = nameof(NumericFormat);
+
+    /// <summary>The syntax identifier for strings containing regular expressions.</summary>
+    public const string Regex = nameof(Regex);
+
+    /// <summary>The syntax identifier for strings containing time format specifiers.</summary>
+    public const string TimeOnlyFormat = nameof(TimeOnlyFormat);
+
+    /// <summary>The syntax identifier for strings containing <see cref="TimeSpan"/> format specifiers.</summary>
+    public const string TimeSpanFormat = nameof(TimeSpanFormat);
+
+    /// <summary>The syntax identifier for strings containing URIs.</summary>
+    public const string Uri = nameof(Uri);
+
+    /// <summary>The syntax identifier for strings containing XML.</summary>
+    public const string Xml = nameof(Xml);
+#pragma warning restore IDE1006
 }
+
 #endif

From dbd9c20cf8bcb0625aebe5dfb9317309c6755b01 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Mon, 22 Apr 2024 16:29:05 +0200
Subject: [PATCH 454/455] Add GraphQLQuery record type for reusable query
 declarations with syntax highlighting (#638)

* add GraphQLQuery record type for reusable query declarations

* enable GraphQLQuery record from .NET 6.0 upwards

* document GraphQLQuery type

* optimize linebreaks in Readme

* fix code formatting in readme
---
 README.md                                     | 53 ++++++++++++++-----
 .../GraphQL.Client.Abstractions.csproj        |  2 +-
 .../GraphQLClientExtensions.cs                | 21 +++++++-
 src/GraphQL.Client/GraphQL.Client.csproj      |  2 +-
 src/GraphQL.Client/GraphQLHttpRequest.cs      |  7 +++
 .../GraphQLSubscriptionException.cs           | 11 ++--
 .../GraphQLWebsocketConnectionException.cs    | 11 ++--
 .../GraphQL.Primitives.csproj                 |  2 +-
 src/GraphQL.Primitives/GraphQLQuery.cs        | 15 ++++++
 src/GraphQL.Primitives/GraphQLRequest.cs      |  8 +++
 .../QueryAndMutationTests/Base.cs             | 16 +++---
 11 files changed, 114 insertions(+), 34 deletions(-)
 create mode 100644 src/GraphQL.Primitives/GraphQLQuery.cs

diff --git a/README.md b/README.md
index 6dc83af6..fe859ced 100644
--- a/README.md
+++ b/README.md
@@ -14,34 +14,38 @@ Provides the following packages:
 | GraphQL.Client.Serializer.SystemTextJson | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Client.Serializer.SystemTextJson)](https://www.nuget.org/packages/GraphQL.Client.Serializer.SystemTextJson) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Client.Serializer.SystemTextJson)](https://www.nuget.org/packages/GraphQL.Client.Serializer.SystemTextJson) | 
 | GraphQL.Primitives | [![Nuget](https://img.shields.io/nuget/dt/GraphQL.Primitives)](https://www.nuget.org/packages/GraphQL.Primitives/) | [![Nuget](https://img.shields.io/nuget/vpre/GraphQL.Primitives)](https://www.nuget.org/packages/GraphQL.Primitives) | 
 
-## Specification:
+## Specification
 The Library will try to follow the following standards and documents:
 
 * [GraphQL Specification](https://spec.graphql.org/June2018/)
 * [GraphQL HomePage](https://graphql.org/learn)
 
-## Usage:
+## Usage
 
 ### Create a GraphQLHttpClient
 
 ```csharp
-// To use NewtonsoftJsonSerializer, add a reference to NuGet package GraphQL.Client.Serializer.Newtonsoft
-var graphQLClient = new GraphQLHttpClient("https://api.example.com/graphql", new NewtonsoftJsonSerializer());
+// To use NewtonsoftJsonSerializer, add a reference to 
+// NuGet package GraphQL.Client.Serializer.Newtonsoft
+var graphQLClient = new GraphQLHttpClient(
+    "https://api.example.com/graphql", 
+    new NewtonsoftJsonSerializer());
 ```
 
 > [!NOTE]
-> *GraphQLHttpClient* is meant to be used as a single longlived instance per endpoint (i.e. register as singleton in a DI system), which should be reused for multiple requests.
+> *GraphQLHttpClient* is meant to be used as a single long-lived instance per endpoint (i.e. register as singleton in a DI system), which should be reused for multiple requests.
 
 ### Create a GraphQLRequest:
 #### Simple Request:
 ```csharp
 var heroRequest = new GraphQLRequest {
-    Query = @"
+    Query = """
     {
         hero {
             name
         }
-    }"
+    }
+    """
 };
 ```
 
@@ -49,7 +53,7 @@ var heroRequest = new GraphQLRequest {
 
 ```csharp
 var personAndFilmsRequest = new GraphQLRequest {
-    Query =@"
+    Query ="""
     query PersonAndFilms($id: ID) {
         person(id: $id) {
             name
@@ -59,7 +63,8 @@ var personAndFilmsRequest = new GraphQLRequest {
                 }
             }
         }
-    }",
+    }
+    """,
     OperationName = "PersonAndFilms",
     Variables = new {
         id = "cGVvcGxlOjE="
@@ -72,7 +77,7 @@ var personAndFilmsRequest = new GraphQLRequest {
 > 
 > If you really need to send a *list of bytes* with a `byte[]` as a  source, then convert it to a `List<byte>` first, which will tell the serializer to output a list of numbers instead of a base64-encoded string.
 
-### Execute Query/Mutation:
+### Execute Query/Mutation
 
 ```csharp
 public class ResponseType 
@@ -102,7 +107,9 @@ var personName = graphQLResponse.Data.Person.Name;
 Using the extension method for anonymously typed responses (namespace `GraphQL.Client.Abstractions`) you could achieve the same result with the following code:
 
 ```csharp
-var graphQLResponse = await graphQLClient.SendQueryAsync(personAndFilmsRequest, () => new { person = new PersonType()} );
+var graphQLResponse = await graphQLClient.SendQueryAsync(
+    personAndFilmsRequest, 
+    () => new { person = new PersonType()});
 var personName = graphQLResponse.Data.person.Name;
 ```
 
@@ -162,7 +169,29 @@ Currently, there is no native support for GraphQL formatting and syntax highligh
 
 For Rider, JetBrains provides a [Plugin](https://plugins.jetbrains.com/plugin/8097-graphql), too.
 
-## Useful Links:
+To leverage syntax highlighting in variable declarations, the `GraphQLQuery` value record type is provided:
+
+```csharp
+GraphQLQuery query = new("""
+                         query PersonAndFilms($id: ID) {
+                             person(id: $id) {
+                                 name
+                                 filmConnection {
+                                     films {
+                                         title
+                                     }
+                                 }
+                             }
+                         }
+                         """);
+                         
+var graphQLResponse = await graphQLClient.SendQueryAsync<ResponseType>(
+    query, 
+    "PersonAndFilms",
+    new { id = "cGVvcGxlOjE=" });
+```
+
+## Useful Links
 
 * [StarWars Example Server (GitHub)](https://github.com/graphql/swapi-graphql)
 * [StarWars Example Server (EndPoint)](https://swapi.apis.guru/)
diff --git a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
index a18177ca..4fa8f98f 100644
--- a/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
+++ b/src/GraphQL.Client.Abstractions/GraphQL.Client.Abstractions.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Description>Abstractions for GraphQL.Client</Description>
-    <TargetFrameworks>netstandard2.0;net7.0;net8.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net6.0;net7.0;net8.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index cce6db1a..92b03980 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -6,22 +6,39 @@ public static class GraphQLClientExtensions
 {
     public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
         [StringSyntax("GraphQL")] string query, object? variables = null,
-        string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
+        string? operationName = null, Func<TResponse>? defineResponseType = null, CancellationToken cancellationToken = default)
     {
         _ = defineResponseType;
         return client.SendQueryAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
             cancellationToken: cancellationToken);
     }
 
+#if NET6_0_OR_GREATER
+    public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
+        GraphQLQuery query, object? variables = null,
+        string? operationName = null, Func<TResponse>? defineResponseType = null,
+        CancellationToken cancellationToken = default)
+        => SendQueryAsync(client, query.Text, variables, operationName, defineResponseType,
+            cancellationToken);
+#endif
+
     public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
         [StringSyntax("GraphQL")] string query, object? variables = null,
-        string? operationName = null, Func<TResponse> defineResponseType = null, CancellationToken cancellationToken = default)
+        string? operationName = null, Func<TResponse>? defineResponseType = null, CancellationToken cancellationToken = default)
     {
         _ = defineResponseType;
         return client.SendMutationAsync<TResponse>(new GraphQLRequest(query, variables, operationName),
             cancellationToken: cancellationToken);
     }
 
+#if NET6_0_OR_GREATER
+    public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
+        GraphQLQuery query, object? variables = null, string? operationName = null, Func<TResponse>? defineResponseType = null,
+        CancellationToken cancellationToken = default)
+        => SendMutationAsync(client, query.Text, variables, operationName, defineResponseType,
+            cancellationToken);
+#endif
+
     public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
         GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
     {
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 241e3bcc..19a2bb7d 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net461;net6.0;net7.0;net8.0</TargetFrameworks>
     <RootNamespace>GraphQL.Client.Http</RootNamespace>
   </PropertyGroup>
 
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index b89d1814..3882195a 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -20,6 +20,13 @@ public GraphQLHttpRequest([StringSyntax("GraphQL")] string query, object? variab
     {
     }
 
+#if NET6_0_OR_GREATER
+    public GraphQLHttpRequest(GraphQLQuery query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
+        : base(query, variables, operationName, extensions)
+    {
+    }
+#endif
+
     public GraphQLHttpRequest(GraphQLRequest other)
         : base(other)
     {
diff --git a/src/GraphQL.Client/GraphQLSubscriptionException.cs b/src/GraphQL.Client/GraphQLSubscriptionException.cs
index ccaab426..21dd8982 100644
--- a/src/GraphQL.Client/GraphQLSubscriptionException.cs
+++ b/src/GraphQL.Client/GraphQLSubscriptionException.cs
@@ -1,17 +1,12 @@
+#if !NET8_0_OR_GREATER
 using System.Runtime.Serialization;
+#endif
 
 namespace GraphQL.Client.Http;
 
 [Serializable]
 public class GraphQLSubscriptionException : Exception
 {
-    //
-    // For guidelines regarding the creation of new exception types, see
-    //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
-    // and
-    //    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
-    //
-
     public GraphQLSubscriptionException()
     {
     }
@@ -20,9 +15,11 @@ public GraphQLSubscriptionException(object error) : base(error.ToString())
     {
     }
 
+#if !NET8_0_OR_GREATER
     protected GraphQLSubscriptionException(
         SerializationInfo info,
         StreamingContext context) : base(info, context)
     {
     }
+#endif
 }
diff --git a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
index f9811b98..aedebb90 100644
--- a/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
+++ b/src/GraphQL.Client/Websocket/GraphQLWebsocketConnectionException.cs
@@ -1,4 +1,6 @@
+#if !NET8_0_OR_GREATER
 using System.Runtime.Serialization;
+#endif
 
 namespace GraphQL.Client.Http.Websocket;
 
@@ -9,15 +11,18 @@ public GraphQLWebsocketConnectionException()
     {
     }
 
-    protected GraphQLWebsocketConnectionException(SerializationInfo info, StreamingContext context) : base(info, context)
+    public GraphQLWebsocketConnectionException(string message) : base(message)
     {
     }
 
-    public GraphQLWebsocketConnectionException(string message) : base(message)
+    public GraphQLWebsocketConnectionException(string message, Exception innerException) : base(message, innerException)
     {
     }
 
-    public GraphQLWebsocketConnectionException(string message, Exception innerException) : base(message, innerException)
+#if !NET8_0_OR_GREATER
+    protected GraphQLWebsocketConnectionException(SerializationInfo info, StreamingContext context) : base(info, context)
     {
     }
+#endif
+
 }
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index b49b7360..44f6e6fe 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>GraphQL basic types</Description>
     <RootNamespace>GraphQL</RootNamespace>
-    <TargetFrameworks>netstandard2.0;net7.0;net8.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net6.0;net7.0;net8.0</TargetFrameworks>
   </PropertyGroup>
 
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQLQuery.cs b/src/GraphQL.Primitives/GraphQLQuery.cs
new file mode 100644
index 00000000..b4ccf635
--- /dev/null
+++ b/src/GraphQL.Primitives/GraphQLQuery.cs
@@ -0,0 +1,15 @@
+#if NET6_0_OR_GREATER
+using System.Diagnostics.CodeAnalysis;
+
+namespace GraphQL;
+
+/// <summary>
+/// Value record for a GraphQL query string
+/// </summary>
+/// <param name="Text">the actual query string</param>
+public readonly record struct GraphQLQuery([StringSyntax("GraphQL")] string Text)
+{
+    public static implicit operator string(GraphQLQuery query)
+        => query.Text;
+};
+#endif
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index 7aecb656..c208a90f 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -59,6 +59,14 @@ public GraphQLRequest([StringSyntax("GraphQL")] string query, object? variables
         Extensions = extensions;
     }
 
+#if NET6_0_OR_GREATER
+    public GraphQLRequest(GraphQLQuery query, object? variables = null, string? operationName = null,
+        Dictionary<string, object?>? extensions = null)
+        : this(query.Text, variables, operationName, extensions)
+    {
+    }
+#endif
+
     public GraphQLRequest(GraphQLRequest other) : base(other) { }
 
     /// <summary>
diff --git a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
index cb25adc6..e20fdd39 100644
--- a/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
+++ b/tests/GraphQL.Integration.Tests/QueryAndMutationTests/Base.cs
@@ -82,13 +82,15 @@ public async void QueryWithDynamicReturnTypeTheory(int id, string name)
     [ClassData(typeof(StarWarsHumans))]
     public async void QueryWitVarsTheory(int id, string name)
     {
-        var graphQLRequest = new GraphQLRequest(@"
-				query Human($id: String!){
-					human(id: $id) {
-						name
-					}
-				}",
-            new { id = id.ToString() });
+        var query = new GraphQLQuery("""
+                                        query Human($id: String!){
+                                        human(id: $id) {
+                                                name
+                                            }
+                                        }
+                                        """);
+
+        var graphQLRequest = new GraphQLRequest(query, new { id = id.ToString() });
 
         var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
 

From 6236c9b2c6f3568f96a9f8e12aa6fb367321c068 Mon Sep 17 00:00:00 2001
From: Ivan Maximov <sungam3r@yandex.ru>
Date: Tue, 21 May 2024 09:34:59 +0300
Subject: [PATCH 455/455] Add APQ support (#555)

* Add APQ support

* changes

* rem

* note

* progress

* progress

* fix variable name

* move APQ code to SendQueryAsync method to allow usage over websocket, too

* make the APQDisabledForSession flag public (helps for testing)

* create a test that uses the APQ feature

* test APQ with websocket transport

* move code for generation of the APQ extension into GraphQLRequest

* fix naming

* replace system.memory reference with narrower system.buffers reference

* Update src/GraphQL.Primitives/GraphQLRequest.cs

Co-authored-by: Shane Krueger <shane@acdmail.com>

* Update src/GraphQL.Primitives/GraphQLRequest.cs

Co-authored-by: Shane Krueger <shane@acdmail.com>

* document APQ feature +semver: feature

* optimize docs

---------

Co-authored-by: Alexander Rose <arose@haprotec.de>
Co-authored-by: Alexander Rose <alex@rose-a.de>
Co-authored-by: Shane Krueger <shane@acdmail.com>
---
 GraphQL.Client.sln.DotSettings                |   1 +
 README.md                                     |  33 +++++-
 .../GraphQLClientExtensions.cs                |   4 -
 src/GraphQL.Client/GraphQLHttpClient.cs       |  54 ++++++++-
 .../GraphQLHttpClientOptions.cs               |  19 ++-
 src/GraphQL.Client/GraphQLHttpRequest.cs      |   3 -
 src/GraphQL.Client/GraphQLHttpResponse.cs     |   9 +-
 .../GraphQL.Primitives.csproj                 |   3 +
 src/GraphQL.Primitives/GraphQLQuery.cs        |  33 ++++--
 src/GraphQL.Primitives/GraphQLRequest.cs      |  33 +++++-
 src/GraphQL.Primitives/Hash.cs                |  44 +++++++
 .../APQ/AutomaticPersistentQueriesTest.cs     | 110 ++++++++++++++++++
 tests/IntegrationTestServer/Startup.cs        |   1 +
 13 files changed, 315 insertions(+), 32 deletions(-)
 create mode 100644 src/GraphQL.Primitives/Hash.cs
 create mode 100644 tests/GraphQL.Integration.Tests/APQ/AutomaticPersistentQueriesTest.cs

diff --git a/GraphQL.Client.sln.DotSettings b/GraphQL.Client.sln.DotSettings
index 9e5ec22f..230ed27f 100644
--- a/GraphQL.Client.sln.DotSettings
+++ b/GraphQL.Client.sln.DotSettings
@@ -1,2 +1,3 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=APQ/@EntryIndexedValue">APQ</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=QL/@EntryIndexedValue">QL</s:String></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/README.md b/README.md
index fe859ced..52ed68d7 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,9 @@ The Library will try to follow the following standards and documents:
 
 ## Usage
 
+The intended use of `GraphQLHttpClient` is to keep one instance alive per endpoint (obvious in case you're
+operating full websocket, but also true for regular requests) and is built with thread-safety in mind.
+
 ### Create a GraphQLHttpClient
 
 ```csharp
@@ -159,17 +162,22 @@ var subscription = subscriptionStream.Subscribe(response =>
 subscription.Dispose();
 ```
 
-## Syntax Highlighting for GraphQL strings in IDEs
+### Automatic persisted queries (APQ)
 
-.NET 7.0 introduced the [StringSyntaxAttribute](https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.stringsyntaxattribute?view=net-8.0) to have a unified way of telling what data is expected in a given `string` or `ReadOnlySpan<char>`. IDEs like Visual Studio and Rider can then use this to provide syntax highlighting and checking.
+[Automatic persisted queries (APQ)](https://www.apollographql.com/docs/apollo-server/performance/apq/) are supported since client version 6.1.0.
 
-From v6.0.4 on all GraphQL string parameters in this library are decorated with the `[StringSyntax("GraphQL")]` attribute.
+APQ can be enabled by configuring `GraphQLHttpClientOptions.EnableAutomaticPersistedQueries` to resolve to `true`.
 
-Currently, there is no native support for GraphQL formatting and syntax highlighting in Visual Studio, but the [GraphQLTools Extension](https://marketplace.visualstudio.com/items?itemName=codearchitects-research.GraphQLTools) provides that for you.
+By default, the client will automatically disable APQ for the current session if the server responds with a `PersistedQueryNotSupported` error or a 400 or 600 HTTP status code.
+This can be customized by configuring `GraphQLHttpClientOptions.DisableAPQ`.
 
-For Rider, JetBrains provides a [Plugin](https://plugins.jetbrains.com/plugin/8097-graphql), too.
+To re-enable APQ after it has been automatically disabled, `GraphQLHttpClient` needs to be disposed an recreated.
 
-To leverage syntax highlighting in variable declarations, the `GraphQLQuery` value record type is provided:
+APQ works by first sending a hash of the query string to the server, and only sending the full query string if the server has not yet cached a query with a matching hash.
+With queries supplied as a string parameter to `GraphQLRequest`, the hash gets computed each time the request is sent.
+
+When you want to reuse a query string (propably to leverage APQ :wink:), declare the query using the `GraphQLQuery` class. This way, the hash gets computed once on construction
+of the `GraphQLQuery` object and handed down to each `GraphQLRequest` using the query.
 
 ```csharp
 GraphQLQuery query = new("""
@@ -191,6 +199,19 @@ var graphQLResponse = await graphQLClient.SendQueryAsync<ResponseType>(
     new { id = "cGVvcGxlOjE=" });
 ```
 
+### Syntax Highlighting for GraphQL strings in IDEs
+
+.NET 7.0 introduced the [StringSyntaxAttribute](https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.stringsyntaxattribute?view=net-8.0) to have a unified way of telling what data is expected in a given `string` or `ReadOnlySpan<char>`. IDEs like Visual Studio and Rider can then use this to provide syntax highlighting and checking.
+
+From v6.0.4 on all GraphQL string parameters in this library are decorated with the `[StringSyntax("GraphQL")]` attribute.
+
+Currently, there is no native support for GraphQL formatting and syntax highlighting in Visual Studio, but the [GraphQLTools Extension](https://marketplace.visualstudio.com/items?itemName=codearchitects-research.GraphQLTools) provides that for you.
+
+For Rider, JetBrains provides a [Plugin](https://plugins.jetbrains.com/plugin/8097-graphql), too.
+
+To leverage syntax highlighting in variable declarations, use the `GraphQLQuery` class.
+
+
 ## Useful Links
 
 * [StarWars Example Server (GitHub)](https://github.com/graphql/swapi-graphql)
diff --git a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
index 92b03980..c2e4bb7c 100644
--- a/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
+++ b/src/GraphQL.Client.Abstractions/GraphQLClientExtensions.cs
@@ -13,14 +13,12 @@ public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IG
             cancellationToken: cancellationToken);
     }
 
-#if NET6_0_OR_GREATER
     public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
         GraphQLQuery query, object? variables = null,
         string? operationName = null, Func<TResponse>? defineResponseType = null,
         CancellationToken cancellationToken = default)
         => SendQueryAsync(client, query.Text, variables, operationName, defineResponseType,
             cancellationToken);
-#endif
 
     public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
         [StringSyntax("GraphQL")] string query, object? variables = null,
@@ -31,13 +29,11 @@ public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this
             cancellationToken: cancellationToken);
     }
 
-#if NET6_0_OR_GREATER
     public static Task<GraphQLResponse<TResponse>> SendMutationAsync<TResponse>(this IGraphQLClient client,
         GraphQLQuery query, object? variables = null, string? operationName = null, Func<TResponse>? defineResponseType = null,
         CancellationToken cancellationToken = default)
         => SendMutationAsync(client, query.Text, variables, operationName, defineResponseType,
             cancellationToken);
-#endif
 
     public static Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(this IGraphQLClient client,
         GraphQLRequest request, Func<TResponse> defineResponseType, CancellationToken cancellationToken = default)
diff --git a/src/GraphQL.Client/GraphQLHttpClient.cs b/src/GraphQL.Client/GraphQLHttpClient.cs
index 10076b8a..5f54d21b 100644
--- a/src/GraphQL.Client/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/GraphQLHttpClient.cs
@@ -17,7 +17,6 @@ public class GraphQLHttpClient : IGraphQLWebSocketClient, IDisposable
     private readonly CancellationTokenSource _cancellationTokenSource = new();
 
     private readonly bool _disposeHttpClient = false;
-
     /// <summary>
     /// the json serializer
     /// </summary>
@@ -33,6 +32,12 @@ public class GraphQLHttpClient : IGraphQLWebSocketClient, IDisposable
     /// </summary>
     public GraphQLHttpClientOptions Options { get; }
 
+    /// <summary>
+    /// This flag is set to <see langword="true"/> when an error has occurred on an APQ and <see cref="GraphQLHttpClientOptions.DisableAPQ"/>
+    /// has returned <see langword="true"/>. To reset this, the instance of <see cref="GraphQLHttpClient"/> has to be disposed and a new one must be created.
+    /// </summary>
+    public bool APQDisabledForSession { get; private set; }
+
     /// <inheritdoc />
     public IObservable<Exception> WebSocketReceiveErrors => GraphQlHttpWebSocket.ReceiveErrors;
 
@@ -84,12 +89,49 @@ public GraphQLHttpClient(string endPoint, IGraphQLWebsocketJsonSerializer serial
 
     #region IGraphQLClient
 
+    private const int APQ_SUPPORTED_VERSION = 1;
+
     /// <inheritdoc />
     public async Task<GraphQLResponse<TResponse>> SendQueryAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
     {
-        return Options.UseWebSocketForQueriesAndMutations || Options.WebSocketEndPoint is not null && Options.EndPoint is null || Options.EndPoint.HasWebSocketScheme()
-            ? await GraphQlHttpWebSocket.SendRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false)
-            : await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        string? savedQuery = null;
+        bool useAPQ = false;
+
+        if (request.Query != null && !APQDisabledForSession && Options.EnableAutomaticPersistedQueries(request))
+        {
+            // https://www.apollographql.com/docs/react/api/link/persisted-queries/
+            useAPQ = true;
+            request.GeneratePersistedQueryExtension();
+            savedQuery = request.Query;
+            request.Query = null;
+        }
+
+        var response = await SendQueryInternalAsync<TResponse>(request, cancellationToken);
+
+        if (useAPQ)
+        {
+            if (response.Errors?.Any(error => string.Equals(error.Message, "PersistedQueryNotFound", StringComparison.CurrentCultureIgnoreCase)) == true)
+            {
+                // GraphQL server supports APQ!
+
+                // Alas, for the first time we did not guess and in vain removed Query, so we return Query and
+                // send request again. This is one-time "cache miss", not so scary.
+                request.Query = savedQuery;
+                return await SendQueryInternalAsync<TResponse>(request, cancellationToken);
+            }
+            else
+            {
+                // GraphQL server either supports APQ of some other version, or does not support it at all.
+                // Send a request for the second time. This is better than returning an error. Let the client work with APQ disabled.
+                APQDisabledForSession = Options.DisableAPQ(response);
+                request.Query = savedQuery;
+                return await SendQueryInternalAsync<TResponse>(request, cancellationToken);
+            }
+        }
+
+        return response;
     }
 
     /// <inheritdoc />
@@ -123,6 +165,10 @@ public IObservable<GraphQLResponse<TResponse>> CreateSubscriptionStream<TRespons
     public Task SendPongAsync(object? payload) => GraphQlHttpWebSocket.SendPongAsync(payload);
 
     #region Private Methods
+    private async Task<GraphQLResponse<TResponse>> SendQueryInternalAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default) =>
+        Options.UseWebSocketForQueriesAndMutations || Options.WebSocketEndPoint is not null && Options.EndPoint is null || Options.EndPoint.HasWebSocketScheme()
+            ? await GraphQlHttpWebSocket.SendRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false)
+            : await SendHttpRequestAsync<TResponse>(request, cancellationToken).ConfigureAwait(false);
 
     private async Task<GraphQLHttpResponse<TResponse>> SendHttpRequestAsync<TResponse>(GraphQLRequest request, CancellationToken cancellationToken = default)
     {
diff --git a/src/GraphQL.Client/GraphQLHttpClientOptions.cs b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
index 6c3b30d1..eda0d024 100644
--- a/src/GraphQL.Client/GraphQLHttpClientOptions.cs
+++ b/src/GraphQL.Client/GraphQLHttpClientOptions.cs
@@ -25,7 +25,7 @@ public class GraphQLHttpClientOptions
     public Uri? WebSocketEndPoint { get; set; }
 
     /// <summary>
-    /// The GraphQL websocket protocol to be used. Defaults to the older "graphql-ws" protocol to not break old code. 
+    /// The GraphQL websocket protocol to be used. Defaults to the older "graphql-ws" protocol to not break old code.
     /// </summary>
     public string? WebSocketProtocol { get; set; } = WebSocketProtocols.AUTO_NEGOTIATE;
 
@@ -99,4 +99,21 @@ public static bool DefaultIsValidResponseToDeserialize(HttpResponseMessage r)
     /// </summary>
     public ProductInfoHeaderValue? DefaultUserAgentRequestHeader { get; set; }
         = new ProductInfoHeaderValue(typeof(GraphQLHttpClient).Assembly.GetName().Name, typeof(GraphQLHttpClient).Assembly.GetName().Version.ToString());
+
+    /// <summary>
+    /// Delegate permitting use of <see href="https://www.apollographql.com/docs/react/api/link/persisted-queries/">Automatic Persisted Queries (APQ)</see>.
+    /// By default, returns <see langword="false" /> for all requests. Note that GraphQL server should support APQ. Otherwise, the client disables APQ completely
+    /// after an unsuccessful attempt to send an APQ request and then send only regular requests.
+    /// </summary>
+    public Func<GraphQLRequest, bool> EnableAutomaticPersistedQueries { get; set; } = _ => false;
+
+    /// <summary>
+    /// A delegate which takes an <see cref="IGraphQLResponse"/> and returns a boolean to disable any future persisted queries for that session.
+    /// This defaults to disabling on PersistedQueryNotSupported or a 400 or 500 HTTP error.
+    /// </summary>
+    public Func<IGraphQLResponse, bool> DisableAPQ { get; set; } = response =>
+    {
+        return response.Errors?.Any(error => string.Equals(error.Message, "PersistedQueryNotSupported", StringComparison.CurrentCultureIgnoreCase)) == true
+            || response is IGraphQLHttpResponse httpResponse && (int)httpResponse.StatusCode >= 400 && (int)httpResponse.StatusCode < 600;
+    };
 }
diff --git a/src/GraphQL.Client/GraphQLHttpRequest.cs b/src/GraphQL.Client/GraphQLHttpRequest.cs
index 3882195a..67f37892 100644
--- a/src/GraphQL.Client/GraphQLHttpRequest.cs
+++ b/src/GraphQL.Client/GraphQLHttpRequest.cs
@@ -19,13 +19,10 @@ public GraphQLHttpRequest([StringSyntax("GraphQL")] string query, object? variab
         : base(query, variables, operationName, extensions)
     {
     }
-
-#if NET6_0_OR_GREATER
     public GraphQLHttpRequest(GraphQLQuery query, object? variables = null, string? operationName = null, Dictionary<string, object?>? extensions = null)
         : base(query, variables, operationName, extensions)
     {
     }
-#endif
 
     public GraphQLHttpRequest(GraphQLRequest other)
         : base(other)
diff --git a/src/GraphQL.Client/GraphQLHttpResponse.cs b/src/GraphQL.Client/GraphQLHttpResponse.cs
index cc676851..8b4f53ba 100644
--- a/src/GraphQL.Client/GraphQLHttpResponse.cs
+++ b/src/GraphQL.Client/GraphQLHttpResponse.cs
@@ -3,7 +3,7 @@
 
 namespace GraphQL.Client.Http;
 
-public class GraphQLHttpResponse<T> : GraphQLResponse<T>
+public class GraphQLHttpResponse<T> : GraphQLResponse<T>, IGraphQLHttpResponse
 {
     public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode)
     {
@@ -19,6 +19,13 @@ public GraphQLHttpResponse(GraphQLResponse<T> response, HttpResponseHeaders resp
     public HttpStatusCode StatusCode { get; set; }
 }
 
+public interface IGraphQLHttpResponse : IGraphQLResponse
+{
+    HttpResponseHeaders ResponseHeaders { get; set; }
+
+    HttpStatusCode StatusCode { get; set; }
+}
+
 public static class GraphQLResponseExtensions
 {
     public static GraphQLHttpResponse<T> ToGraphQLHttpResponse<T>(this GraphQLResponse<T> response, HttpResponseHeaders responseHeaders, HttpStatusCode statusCode) => new(response, responseHeaders, statusCode);
diff --git a/src/GraphQL.Primitives/GraphQL.Primitives.csproj b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
index 44f6e6fe..9cbacbe6 100644
--- a/src/GraphQL.Primitives/GraphQL.Primitives.csproj
+++ b/src/GraphQL.Primitives/GraphQL.Primitives.csproj
@@ -6,4 +6,7 @@
     <TargetFrameworks>netstandard2.0;net6.0;net7.0;net8.0</TargetFrameworks>
   </PropertyGroup>
 
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Buffers" Version="4.5.1" />
+  </ItemGroup>
 </Project>
diff --git a/src/GraphQL.Primitives/GraphQLQuery.cs b/src/GraphQL.Primitives/GraphQLQuery.cs
index b4ccf635..df6eded8 100644
--- a/src/GraphQL.Primitives/GraphQLQuery.cs
+++ b/src/GraphQL.Primitives/GraphQLQuery.cs
@@ -1,15 +1,34 @@
-#if NET6_0_OR_GREATER
 using System.Diagnostics.CodeAnalysis;
-
 namespace GraphQL;
 
 /// <summary>
-/// Value record for a GraphQL query string
+/// Value object representing a GraphQL query string and storing the corresponding APQ hash. <br />
+/// Use this to hold query strings you want to use more than once.
 /// </summary>
-/// <param name="Text">the actual query string</param>
-public readonly record struct GraphQLQuery([StringSyntax("GraphQL")] string Text)
+public class GraphQLQuery : IEquatable<GraphQLQuery>
 {
+    /// <summary>
+    /// The actual query string
+    /// </summary>
+    public string Text { get; }
+
+    /// <summary>
+    /// The SHA256 hash used for the automatic persisted queries feature (APQ)
+    /// </summary>
+    public string Sha256Hash { get; }
+
+    public GraphQLQuery([StringSyntax("GraphQL")] string text)
+    {
+        Text = text;
+        Sha256Hash = Hash.Compute(Text);
+    }
+
     public static implicit operator string(GraphQLQuery query)
         => query.Text;
-};
-#endif
+
+    public bool Equals(GraphQLQuery other) => Sha256Hash == other.Sha256Hash;
+
+    public override bool Equals(object? obj) => obj is GraphQLQuery other && Equals(other);
+
+    public override int GetHashCode() => Sha256Hash.GetHashCode();
+}
diff --git a/src/GraphQL.Primitives/GraphQLRequest.cs b/src/GraphQL.Primitives/GraphQLRequest.cs
index c208a90f..2d3e13ce 100644
--- a/src/GraphQL.Primitives/GraphQLRequest.cs
+++ b/src/GraphQL.Primitives/GraphQLRequest.cs
@@ -11,19 +11,28 @@ public class GraphQLRequest : Dictionary<string, object>, IEquatable<GraphQLRequ
     public const string QUERY_KEY = "query";
     public const string VARIABLES_KEY = "variables";
     public const string EXTENSIONS_KEY = "extensions";
+    public const string EXTENSIONS_PERSISTED_QUERY_KEY = "persistedQuery";
+    public const int APQ_SUPPORTED_VERSION = 1;
+
+    private string? _sha265Hash;
 
     /// <summary>
-    /// The Query
+    /// The query string
     /// </summary>
     [StringSyntax("GraphQL")]
-    public string Query
+    public string? Query
     {
         get => TryGetValue(QUERY_KEY, out object value) ? (string)value : null;
-        set => this[QUERY_KEY] = value;
+        set
+        {
+            this[QUERY_KEY] = value;
+            // if the query string gets overwritten, reset the hash value
+            _sha265Hash = null;
+        }
     }
 
     /// <summary>
-    /// The name of the Operation
+    /// The operation to execute
     /// </summary>
     public string? OperationName
     {
@@ -59,16 +68,28 @@ public GraphQLRequest([StringSyntax("GraphQL")] string query, object? variables
         Extensions = extensions;
     }
 
-#if NET6_0_OR_GREATER
     public GraphQLRequest(GraphQLQuery query, object? variables = null, string? operationName = null,
         Dictionary<string, object?>? extensions = null)
         : this(query.Text, variables, operationName, extensions)
     {
+        _sha265Hash = query.Sha256Hash;
     }
-#endif
 
     public GraphQLRequest(GraphQLRequest other) : base(other) { }
 
+    public void GeneratePersistedQueryExtension()
+    {
+        if (Query is null)
+            throw new InvalidOperationException($"{nameof(Query)} is null");
+
+        Extensions ??= new();
+        Extensions[EXTENSIONS_PERSISTED_QUERY_KEY] = new Dictionary<string, object>
+        {
+            ["version"] = APQ_SUPPORTED_VERSION,
+            ["sha256Hash"] = _sha265Hash ??= Hash.Compute(Query),
+        };
+    }
+
     /// <summary>
     /// Returns a value that indicates whether this instance is equal to a specified object
     /// </summary>
diff --git a/src/GraphQL.Primitives/Hash.cs b/src/GraphQL.Primitives/Hash.cs
new file mode 100644
index 00000000..e360dd65
--- /dev/null
+++ b/src/GraphQL.Primitives/Hash.cs
@@ -0,0 +1,44 @@
+using System.Buffers;
+using System.Diagnostics;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace GraphQL;
+
+internal static class Hash
+{
+    private static SHA256? _sha256;
+
+    internal static string Compute(string query)
+    {
+        int expected = Encoding.UTF8.GetByteCount(query);
+        byte[]? inputBytes = ArrayPool<byte>.Shared.Rent(expected);
+        int written = Encoding.UTF8.GetBytes(query, 0, query.Length, inputBytes, 0);
+        Debug.Assert(written == expected, (string)$"Encoding.UTF8.GetBytes returned unexpected bytes: {written} instead of {expected}");
+
+        var shaShared = Interlocked.Exchange(ref _sha256, null) ?? SHA256.Create();
+
+#if NET5_0_OR_GREATER
+        Span<byte> bytes = stackalloc byte[32];
+        if (!shaShared.TryComputeHash(inputBytes.AsSpan().Slice(0, written), bytes, out int bytesWritten)) // bytesWritten ignored since it is always 32
+            throw new InvalidOperationException("Too small buffer for hash");
+#else
+        byte[] bytes = shaShared.ComputeHash(inputBytes, 0, written);
+#endif
+
+        ArrayPool<byte>.Shared.Return(inputBytes);
+        Interlocked.CompareExchange(ref _sha256, shaShared, null);
+
+#if NET5_0_OR_GREATER
+        return Convert.ToHexString(bytes);
+#else
+        var builder = new StringBuilder(bytes.Length * 2);
+        foreach (byte item in bytes)
+        {
+            builder.Append(item.ToString("x2"));
+        }
+
+        return builder.ToString();
+#endif
+    }
+}
diff --git a/tests/GraphQL.Integration.Tests/APQ/AutomaticPersistentQueriesTest.cs b/tests/GraphQL.Integration.Tests/APQ/AutomaticPersistentQueriesTest.cs
new file mode 100644
index 00000000..0c71a4ee
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/APQ/AutomaticPersistentQueriesTest.cs
@@ -0,0 +1,110 @@
+using System.Diagnostics.CodeAnalysis;
+using FluentAssertions;
+using GraphQL.Client.Abstractions;
+using GraphQL.Client.Http;
+using GraphQL.Client.Tests.Common.StarWars.TestData;
+using GraphQL.Integration.Tests.Helpers;
+using Xunit;
+
+namespace GraphQL.Integration.Tests.APQ;
+
+[SuppressMessage("ReSharper", "UseConfigureAwaitFalse")]
+public class AutomaticPersistentQueriesTest : IAsyncLifetime, IClassFixture<SystemTextJsonAutoNegotiateServerTestFixture>
+{
+    public SystemTextJsonAutoNegotiateServerTestFixture Fixture { get; }
+    protected GraphQLHttpClient StarWarsClient;
+    protected GraphQLHttpClient StarWarsWebsocketClient;
+
+    public AutomaticPersistentQueriesTest(SystemTextJsonAutoNegotiateServerTestFixture fixture)
+    {
+        Fixture = fixture;
+    }
+
+    public async Task InitializeAsync()
+    {
+        await Fixture.CreateServer();
+        StarWarsClient = Fixture.GetStarWarsClient(options => options.EnableAutomaticPersistedQueries = _ => true);
+        StarWarsWebsocketClient = Fixture.GetStarWarsClient(options =>
+        {
+            options.EnableAutomaticPersistedQueries = _ => true;
+            options.UseWebSocketForQueriesAndMutations = true;
+        });
+    }
+
+    public Task DisposeAsync()
+    {
+        StarWarsClient?.Dispose();
+        return Task.CompletedTask;
+    }
+
+    [Theory]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void After_querying_all_starwars_humans_the_APQDisabledForSession_is_still_false_Async(int id, string name)
+    {
+        var query = new GraphQLQuery("""
+                                     query Human($id: String!){
+                                     human(id: $id) {
+                                             name
+                                         }
+                                     }
+                                     """);
+
+        var graphQLRequest = new GraphQLRequest(query, new { id = id.ToString() });
+
+        var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+
+        Assert.Null(response.Errors);
+        Assert.Equal(name, response.Data.Human.Name);
+        StarWarsClient.APQDisabledForSession.Should().BeFalse("if APQ has worked it won't get disabled");
+    }
+
+    [Theory]
+    [ClassData(typeof(StarWarsHumans))]
+    public async void After_querying_all_starwars_humans_using_websocket_transport_the_APQDisabledForSession_is_still_false_Async(int id, string name)
+    {
+        var query = new GraphQLQuery("""
+                                     query Human($id: String!){
+                                     human(id: $id) {
+                                             name
+                                         }
+                                     }
+                                     """);
+
+        var graphQLRequest = new GraphQLRequest(query, new { id = id.ToString() });
+
+        var response = await StarWarsWebsocketClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
+
+        Assert.Null(response.Errors);
+        Assert.Equal(name, response.Data.Human.Name);
+        StarWarsWebsocketClient.APQDisabledForSession.Should().BeFalse("if APQ has worked it won't get disabled");
+    }
+
+    [Fact]
+    public void Verify_the_persisted_query_extension_object()
+    {
+        var query = new GraphQLQuery("""
+                                     query Human($id: String!){
+                                     human(id: $id) {
+                                             name
+                                         }
+                                     }
+                                     """);
+        query.Sha256Hash.Should().NotBeNullOrEmpty();
+
+        var request = new GraphQLRequest(query);
+        request.Extensions.Should().BeNull();
+        request.GeneratePersistedQueryExtension();
+        request.Extensions.Should().NotBeNull();
+
+        string expectedKey = "persistedQuery";
+        var expectedExtensionValue = new Dictionary<string, object>
+        {
+            ["version"] = 1,
+            ["sha256Hash"] = query.Sha256Hash,
+        };
+
+        request.Extensions.Should().ContainKey(expectedKey);
+        request.Extensions![expectedKey].As<Dictionary<string, object>>()
+            .Should().NotBeNull().And.BeEquivalentTo(expectedExtensionValue);
+    }
+}
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index ee8526c1..a907d623 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -38,6 +38,7 @@ public void ConfigureServices(IServiceCollection services)
             })
             .AddErrorInfoProvider(opt => opt.ExposeExceptionDetails = Environment.IsDevelopment())
             .AddSystemTextJson()
+            .UseAutomaticPersistedQueries(options => options.TrackLinkedCacheEntries = true)
             .AddGraphTypes(typeof(ChatSchema).Assembly));
     }