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 01/23] 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 02/23] 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 03/23] 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 04/23] 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 05/23] 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 06/23] 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 07/23] 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 08/23] 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 09/23] 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 10/23] 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 11/23] 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 12/23] 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 13/23] 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 14/23] 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 15/23] 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 16/23] 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 17/23] 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 18/23] 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 19/23] 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 20/23] 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 8680d2500b12307ef02a51553fd23dcafa66bc3c Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 2 Mar 2019 18:41:54 +0100
Subject: [PATCH 21/23] clean up stuff

---
 ...iptionIntegrationTest.ConsoleClient.csproj |  2 +-
 .../GraphQL.Common.Benchmark.csproj           |  6 +-
 samples/GraphQL.Client.Sample/Program.cs      |  6 +-
 src/GraphQL.Client/GraphQL.Client.csproj      |  2 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 44 ++-------
 .../Http/GraphQLHttpSubscriptionResult.cs     | 90 -------------------
 src/GraphQL.Client/IGraphQLClient.cs          | 15 +---
 .../IGraphQLSubscriptionResult.cs             | 24 -----
 .../GraphQL.Client.Tests.csproj               |  6 +-
 .../GraphQL.Common.Tests.csproj               |  4 +
 .../GraphQL.Integration.Tests.csproj          | 12 +--
 .../SubscriptionsTest.cs                      |  2 -
 .../IntegrationTestServer.csproj              | 10 +--
 13 files changed, 37 insertions(+), 186 deletions(-)
 delete mode 100644 src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
 delete mode 100644 src/GraphQL.Client/IGraphQLSubscriptionResult.cs

diff --git a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
index 83d4884b..bd35758f 100644
--- a/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
+++ b/SubscriptionIntegrationTest.ConsoleClient/SubscriptionIntegrationTest.ConsoleClient.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Reactive" Version="4.1.2" />
+    <PackageReference Include="System.Reactive" Version="4.1.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
index d5ccaa33..657b4f77 100644
--- a/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
+++ b/benchmarks/GraphQL.Common.Benchmark/GraphQL.Common.Benchmark.csproj
@@ -1,12 +1,12 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
-		<TargetFramework>netcoreapp2.2</TargetFramework>
+		<TargetFramework>netcoreapp3.0</TargetFramework>
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="BenchmarkDotNet" Version="0.11.3" />
+		<PackageReference Include="BenchmarkDotNet" Version="0.11.4" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/samples/GraphQL.Client.Sample/Program.cs b/samples/GraphQL.Client.Sample/Program.cs
index b3c9e601..db19a4e3 100644
--- a/samples/GraphQL.Client.Sample/Program.cs
+++ b/samples/GraphQL.Client.Sample/Program.cs
@@ -1,5 +1,6 @@
 using System;
 using GraphQL.Client.Http;
+using GraphQL.Common.Request;
 
 namespace GraphQL.Client.Sample {
 
@@ -7,9 +8,8 @@ public class Program {
 
 		public static void Main(string[] args) {
 			using (var graphQLHttpClient = new GraphQLHttpClient("http://localhost:60341/graphql")) {
-				var subscriptionResult = graphQLHttpClient.SendSubscribeAsync(@"subscription { messageAdded{content}}").Result;
-				subscriptionResult.OnReceive += (res) => { Console.WriteLine(res.Data.messageAdded.content); };
-				Console.ReadKey();
+				var subscription = graphQLHttpClient.CreateSubscriptionStream(new GraphQLRequest(@"subscription { messageAdded{content}}"));
+				subscription.Subscribe(res => Console.WriteLine(res.Data.messageAdded.content));
 			}
 		}
 
diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 8043bf35..514ee0cd 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -15,7 +15,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" />
+		<PackageReference Include="System.Reactive" Version="4.1.3" />
 	</ItemGroup>
 
 	<ItemGroup>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index d242569b..ae284506 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -41,7 +41,6 @@ public GraphQLHttpClientOptions Options {
 		}
 
 		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL")]
 		public IObservable<Exception> WebSocketReceiveErrors => graphQlHttpWebSocket.ReceiveErrors;
 
 		#endregion
@@ -49,6 +48,7 @@ public GraphQLHttpClientOptions Options {
 		internal readonly GraphQLHttpHandler graphQLHttpHandler;
 		internal readonly GraphQLHttpWebSocket graphQlHttpWebSocket;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+		private readonly ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> _subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
 
 		/// <summary>
 		/// Initializes a new instance
@@ -133,27 +133,6 @@ public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, Cancellat
 				: 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";
@@ -161,23 +140,21 @@ private Uri _getWebSocketUri()
 		}
 
 		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
 			if (_disposed)
 				throw new ObjectDisposedException(nameof(GraphQLHttpClient));
 
-			if (subscriptionStreams.ContainsKey(request))
-				return subscriptionStreams[request];
+			if (_subscriptionStreams.ContainsKey(request))
+				return _subscriptionStreams[request];
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
 
-			subscriptionStreams.TryAdd(request, observable);
+			_subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
 
 		/// <inheritdoc />
-		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request, Action<WebSocketException> webSocketExceptionHandler)
 		{
 			if (_disposed)
@@ -193,22 +170,19 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 		}
 
 		/// <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];
+			if(_subscriptionStreams.ContainsKey(request))
+				return _subscriptionStreams[request];
 
 			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
-			subscriptionStreams.TryAdd(request, observable);
+			_subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
-
-		private ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>> subscriptionStreams = new ConcurrentDictionary<GraphQLRequest, IObservable<GraphQLResponse>>();
-
+		
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
@@ -224,7 +198,7 @@ public void Dispose()
 		}
 
 		private bool _disposed = false;
-		private object _disposeLocker = new object();
+		private readonly object _disposeLocker = new object();
 
 		private void _dispose()
 		{
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
deleted file mode 100644
index 34ab6f0a..00000000
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-using System;
-using System.Net.WebSockets;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using GraphQL.Common;
-using GraphQL.Common.Request;
-using GraphQL.Common.Response;
-using Newtonsoft.Json;
-
-namespace GraphQL.Client.Http {
-
-	/// <summary>
-	/// Represents the result of a subscription query
-	/// </summary>
-	[Obsolete("EXPERIMENTAL API")]
-	public class GraphQLHttpSubscriptionResult : IGraphQLSubscriptionResult {
-
-		public event Action<GraphQLResponse> OnReceive;
-
-		public GraphQLResponse LastResponse { get; private set; }
-
-		private readonly ClientWebSocket clientWebSocket = new ClientWebSocket();
-		private readonly Uri webSocketUri;
-		private readonly GraphQLRequest graphQLRequest;
-		private readonly byte[] buffer = new byte[1024 * 1024];
-
-		internal GraphQLHttpSubscriptionResult(Uri webSocketUri, GraphQLRequest graphQLRequest) {
-			this.webSocketUri = webSocketUri;
-			this.graphQLRequest = graphQLRequest;
-			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
-		}
-
-		public async void StartAsync(CancellationToken cancellationToken = default) {
-			await this.clientWebSocket.ConnectAsync(this.webSocketUri, cancellationToken).ConfigureAwait(false);
-			if (this.clientWebSocket.State == WebSocketState.Open) {
-				var arraySegment = new ArraySegment<byte>(this.buffer);
-				await this.SendInitialMessageAsync(cancellationToken).ConfigureAwait(false);
-				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<GraphQLWebSocketResponse>(stringResult);
-					if (webSocketResponse != null)
-					{
-						var response = (GraphQLResponse) webSocketResponse.Payload;
-						this.LastResponse = response;
-						this.OnReceive?.Invoke(response);
-					}
-				}
-			}
-		}
-
-		public async Task StopAsync(CancellationToken cancellationToken = default) {
-			if (this.clientWebSocket.State == WebSocketState.Open) {
-				await this.SendCloseMessageAsync(cancellationToken);
-			}
-			await this.clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken);
-		}
-
-		public void Dispose() {
-			this.StopAsync().Wait();
-			this.clientWebSocket.Dispose();
-		}
-
-		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLWebSocketRequest {
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_START,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
-		}
-
-		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default) {
-			var webSocketRequest = new GraphQLWebSocketRequest {
-				Id = "1",
-				Type = GQLWebSocketMessageType.GQL_STOP,
-				Payload = this.graphQLRequest
-			};
-			return this.SendGraphQLSubscriptionRequest(webSocketRequest);
-		}
-
-		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);
-		}
-	}
-
-}
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 098d0524..204da12b 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -27,16 +27,7 @@ public interface IGraphQLClient : IDisposable {
 		/// <param name="cancellationToken">The Cancellation Token</param>
 		/// <returns>The Response</returns>
 		Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
-
-		/// <summary>
-		/// Send a Subscription async
-		/// </summary>
-		/// <param name="request">The Request</param>
-		/// <param name="cancellationToken">The Cancellation Token</param>
-		/// <returns>The Subscription Response</returns>
-		[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/>
@@ -44,7 +35,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>
@@ -57,7 +47,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>
@@ -70,13 +59,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.Client/IGraphQLSubscriptionResult.cs b/src/GraphQL.Client/IGraphQLSubscriptionResult.cs
deleted file mode 100644
index cb0626ee..00000000
--- a/src/GraphQL.Client/IGraphQLSubscriptionResult.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-using GraphQL.Common.Response;
-
-namespace GraphQL.Client {
-
-	/// <summary>
-	/// Represents the Result of a subscription
-	/// </summary>
-	[Obsolete("EXPERIMENTAL")]
-	public interface IGraphQLSubscriptionResult : IDisposable {
-
-		/// <summary>
-		/// Event triggered when a new Response is received
-		/// </summary>
-		event Action<GraphQLResponse> OnReceive;
-
-		/// <summary>
-		/// Last Response Received
-		/// </summary>
-		GraphQLResponse LastResponse { get; }
-
-	}
-
-}
diff --git a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
index 1c9a24d9..c49723ea 100644
--- a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
+++ b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
@@ -9,7 +9,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="1.1.2" />
+		<PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="2.2.0" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -17,4 +17,8 @@
 		<ProjectReference Include="..\GraphQL.Common.Tests\GraphQL.Common.Tests.csproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <PackageReference Update="Microsoft.NET.Test.Sdk" Version="16.0.0" />
+	</ItemGroup>
+
 </Project>
diff --git a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj b/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
index 4aae0487..dbcbc5d4 100644
--- a/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
+++ b/tests/GraphQL.Common.Tests/GraphQL.Common.Tests.csproj
@@ -11,5 +11,9 @@
 	<ItemGroup>
 		<ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
 	</ItemGroup>
+	
+	<ItemGroup>
+	  <PackageReference Update="Microsoft.NET.Test.Sdk" Version="16.0.0" />
+	</ItemGroup>
 
 </Project>
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
index 5fc195bc..2fb41339 100644
--- a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -1,17 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp3.0</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="Microsoft.AspNetCore.Mvc.Testing" Version="2.2.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="2.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.0.0" />
+    <PackageReference Include="System.Reactive" Version="4.1.3" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.3" />
     <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/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 635a0d1c..a70301a6 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -37,8 +37,6 @@ public static IWebHost CreateServer(int port)
 			return host;
 		}
 
-		private readonly IWebHost _server;
-
 		public SubscriptionsTest()
 		{
 		}
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
index cfba48cd..18a9fc43 100644
--- a/tests/IntegrationTestServer/IntegrationTestServer.csproj
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>netcoreapp3.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -15,10 +15,8 @@
     <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" />
+    <PackageReference Include="System.Reactive" Version="4.1.3" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.3" />
   </ItemGroup>
 
 </Project>

From 95138b15cd872733c05bc4ba3b30023a4ac8e066 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 2 Mar 2019 18:56:15 +0100
Subject: [PATCH 22/23] clean up and reorganize GraphQLHttpWebSocket

---
 .../Http/GraphQLHttpWebSocket.cs              | 137 +++++++++---------
 1 file changed, 67 insertions(+), 70 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
index 28ae1e7b..f21f4876 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebSocket.cs
@@ -15,39 +15,34 @@
 
 namespace GraphQL.Client.Http
 {
+	// ReSharper disable once InconsistentNaming
 	internal class GraphQLHttpWebSocket: IDisposable
 	{
-		private readonly Uri webSocketUri;
+		private readonly Uri _webSocketUri;
 		private readonly GraphQLHttpClientOptions _options;
-		private readonly ArraySegment<byte> buffer;
+		private readonly ArraySegment<byte> _buffer;
 		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+		private readonly Subject<GraphQLWebSocketRequest> _requestSubject = new Subject<GraphQLWebSocketRequest>();
+		private readonly Subject<Exception> _exceptionSubject = new Subject<Exception>();
 
 		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 WebSocket clientWebSocket = null;
+		private WebSocket _clientWebSocket = null;
 		private int _connectionAttempt = 0;
 
+		public IObservable<Exception> ReceiveErrors => _exceptionSubject.AsObservable();
+		public IObservable<GraphQLWebSocketResponse> ResponseStream { get; }
+		public WebSocketState WebSocketState => _clientWebSocket?.State ?? WebSocketState.None;
+
 		public GraphQLHttpWebSocket(Uri webSocketUri, GraphQLHttpClientOptions options)
 		{
-			this.webSocketUri = webSocketUri;
+			this._webSocketUri = webSocketUri;
 			_options = options;
-			buffer = new ArraySegment<byte>(new byte[8192]);
-			_responseStream = _createResponseStream();
+			_buffer = new ArraySegment<byte>(new byte[8192]);
+			ResponseStream = _createResponseStream();
 
-			_requestSubscription = _requestSubject.Select(request => Observable.FromAsync(() => _sendWebSocketRequest(request))).Concat().Subscribe();
+			_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;
-
 		public Task SendWebSocketRequest(GraphQLWebSocketRequest request)
 		{
 			_requestSubject.OnNext(request);
@@ -66,7 +61,7 @@ private async Task _sendWebSocketRequest(GraphQLWebSocketRequest request)
 
 				await InitializeWebSocket().ConfigureAwait(false);
 				var webSocketRequestString = JsonConvert.SerializeObject(request);
-				await this.clientWebSocket.SendAsync(
+				await this._clientWebSocket.SendAsync(
 					new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString)),
 					WebSocketMessageType.Text,
 					true,
@@ -79,49 +74,39 @@ await this.clientWebSocket.SendAsync(
 			}
 		}
 
-		public Task InitializeWebSocketTask { get; private set; } = Task.CompletedTask;
-
-		private object _initializeLock = new object();
-
-		#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);
-		}
+		private Task _initializeWebSocketTask = Task.CompletedTask;
+		private readonly object _initializeLock = new object();
 
+		/// <summary>
+		/// Initializes the websocket. If the initialization process is already running, returns the running task.
+		/// If a healthy websocket connection is already established, a completed task is returned
+		/// </summary>
+		/// <returns>the async task initializing the websocket</returns>
 		public Task InitializeWebSocket()
 		{
 			// do not attempt to initialize if cancellation is requested
-			if(_disposed != null)
+			if (_disposed != 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 (_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
-				//_responseStreamConnection?.Dispose();
-				clientWebSocket?.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)
+				_clientWebSocket = SystemClientWebSocket.CreateClientWebSocket();
+				switch (_clientWebSocket)
 				{
 					case ClientWebSocket nativeWebSocket:
 						nativeWebSocket.Options.AddSubProtocol("graphql-ws");
@@ -130,12 +115,14 @@ public Task InitializeWebSocket()
 						managedWebSocket.Options.AddSubProtocol("graphql-ws");
 						break;
 					default:
-						throw new NotSupportedException($"unknown websocket type {clientWebSocket.GetType().Name}");
+						throw new NotSupportedException($"unknown websocket type {_clientWebSocket.GetType().Name}");
 				}
 
-				return InitializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
+				return _initializeWebSocketTask = _connectAsync(_cancellationTokenSource.Token);
 			}
 		}
+
+		#region Private Methods
 		
 		private IObservable<GraphQLWebSocketResponse> _createResponseStream()
 		{
@@ -186,10 +173,9 @@ 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()}");
-				//_responseStreamConnection = _responseStream.Connect();
+				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)
@@ -199,9 +185,20 @@ private async Task _connectAsync(CancellationToken token)
 			}
 		}
 
+		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);
+		}
 
 		private Task<GraphQLWebSocketResponse> _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>
@@ -223,16 +220,16 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 		{
 			try
 			{
-				Debug.WriteLine($"receiving data on websocket {clientWebSocket.GetHashCode()} ...");
-				WebSocketReceiveResult webSocketReceiveResult = null;
+				Debug.WriteLine($"receiving data on websocket {_clientWebSocket.GetHashCode()} ...");
 
 				using (var ms = new MemoryStream())
 				{
+					WebSocketReceiveResult webSocketReceiveResult = null;
 					do
 					{
 						_cancellationTokenSource.Token.ThrowIfCancellationRequested();
-						webSocketReceiveResult = await clientWebSocket.ReceiveAsync(buffer, CancellationToken.None);
-						ms.Write(buffer.Array, buffer.Offset, webSocketReceiveResult.Count);
+						webSocketReceiveResult = await _clientWebSocket.ReceiveAsync(_buffer, CancellationToken.None).ConfigureAwait(false);
+						ms.Write(_buffer.Array, _buffer.Offset, webSocketReceiveResult.Count);
 					}
 					while (!webSocketReceiveResult.EndOfMessage);
 
@@ -243,8 +240,8 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 					{
 						using (var reader = new StreamReader(ms, Encoding.UTF8))
 						{
-							var stringResult = await reader.ReadToEndAsync();
-							Debug.WriteLine($"data received on websocket {clientWebSocket.GetHashCode()}: {stringResult}");
+							var stringResult = await reader.ReadToEndAsync().ConfigureAwait(false);
+							Debug.WriteLine($"data received on websocket {_clientWebSocket.GetHashCode()}: {stringResult}");
 							return JsonConvert.DeserializeObject<GraphQLWebSocketResponse>(stringResult);
 						}
 					}
@@ -263,20 +260,20 @@ private async Task<GraphQLWebSocketResponse> _receiveResultAsync()
 
 		private async Task _closeAsync(CancellationToken cancellationToken = default)
 		{
-			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 (this._clientWebSocket.State != WebSocketState.Open &&
+			    this._clientWebSocket.State != WebSocketState.CloseReceived &&
+			    this._clientWebSocket.State != WebSocketState.CloseSent)
 			{
-				Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} state = {this.clientWebSocket.State}");
+				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);
+			Debug.WriteLine($"closing websocket {_clientWebSocket.GetHashCode()}");
+			await this._clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", cancellationToken).ConfigureAwait(false);
 		}
 
 		#endregion
@@ -284,7 +281,7 @@ private async Task _closeAsync(CancellationToken cancellationToken = default)
 		#region IDisposable
 
 		private Task _disposed;
-		private object _disposedLocker = new object();
+		private readonly 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)
@@ -296,13 +293,13 @@ public void Dispose()
 
 		private async Task DisposeAsync()
 		{
-			Debug.WriteLine($"disposing websocket {clientWebSocket.GetHashCode()}...");
+			Debug.WriteLine($"disposing websocket {_clientWebSocket?.GetHashCode()}...");
 			if (!_cancellationTokenSource.IsCancellationRequested)
 				_cancellationTokenSource.Cancel();
 			await _closeAsync().ConfigureAwait(false);
-			clientWebSocket?.Dispose();
+			_clientWebSocket?.Dispose();
 			_cancellationTokenSource.Dispose();
-			Debug.WriteLine($"websocket {clientWebSocket.GetHashCode()} disposed");
+			Debug.WriteLine($"websocket {_clientWebSocket?.GetHashCode()} disposed");
 		}
 		#endregion
 	}

From f446491cff1c4f999c73aa874f350d58ddbc8efb Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Sat, 2 Mar 2019 19:16:01 +0100
Subject: [PATCH 23/23] refactor GraphQLWebsocketHelpers, add test for Queries
 via websocket

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |   9 +-
 ...pers.cs => GraphQLHttpWebsocketHelpers.cs} | 122 +++++++++---------
 .../{ => Helpers}/CallbackTester.cs           |   0
 .../{ => Helpers}/GraphQLClientExtensions.cs  |   0
 .../{ => Helpers}/NetworkHelpers.cs           |   0
 .../{ => Helpers}/ObservableTester.cs         |   0
 .../WebApplicationFactoryExtensions.cs        |   0
 ...SubscriptionsTest.cs => WebsocketTests.cs} |  22 +++-
 8 files changed, 83 insertions(+), 70 deletions(-)
 rename src/GraphQL.Client/Http/{GraphQLHttpSubscriptionHelpers.cs => GraphQLHttpWebsocketHelpers.cs} (68%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/CallbackTester.cs (100%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/GraphQLClientExtensions.cs (100%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/NetworkHelpers.cs (100%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/ObservableTester.cs (100%)
 rename tests/GraphQL.Integration.Tests/{ => Helpers}/WebApplicationFactoryExtensions.cs (100%)
 rename tests/GraphQL.Integration.Tests/{SubscriptionsTest.cs => WebsocketTests.cs} (93%)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index ae284506..f0c03452 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.WebSockets;
@@ -119,7 +118,7 @@ public Task<GraphQLResponse> SendQueryAsync(string query, CancellationToken canc
 		public Task<GraphQLResponse> SendQueryAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
 		{
 			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				? this.graphQlHttpWebSocket.SendRequest(request, cancellationToken)
 				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
 		}
 
@@ -129,7 +128,7 @@ public Task<GraphQLResponse> SendMutationAsync(string query, CancellationToken c
 		public Task<GraphQLResponse> SendMutationAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
 		{
 			return Options.UseWebSocketForQueriesAndMutations
-				? this.graphQlHttpWebSocket.Request(request, cancellationToken)
+				? this.graphQlHttpWebSocket.SendRequest(request, cancellationToken)
 				: this.graphQLHttpHandler.PostAsync(request, cancellationToken);
 		}
 
@@ -148,7 +147,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if (_subscriptionStreams.ContainsKey(request))
 				return _subscriptionStreams[request];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, cancellationToken: _cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, cancellationToken: _cancellationTokenSource.Token);
 
 			_subscriptionStreams.TryAdd(request, observable);
 			return observable;
@@ -178,7 +177,7 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			if(_subscriptionStreams.ContainsKey(request))
 				return _subscriptionStreams[request];
 
-			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, Options, exceptionHandler, _cancellationTokenSource.Token);
+			var observable = graphQlHttpWebSocket.CreateSubscriptionStream(request, exceptionHandler, _cancellationTokenSource.Token);
 			_subscriptionStreams.TryAdd(request, observable);
 			return observable;
 		}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs b/src/GraphQL.Client/Http/GraphQLHttpWebsocketHelpers.cs
similarity index 68%
rename from src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
rename to src/GraphQL.Client/Http/GraphQLHttpWebsocketHelpers.cs
index ef71a0ce..1eee72bd 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionHelpers.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpWebsocketHelpers.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;
@@ -12,12 +13,12 @@
 
 namespace GraphQL.Client.Http
 {
-	public static class GraphQLHttpSubscriptionHelpers
+	// ReSharper disable once InconsistentNaming
+	public static class GraphQLHttpWebsocketHelpers
 	{
 		internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
-			GraphQLHttpClientOptions options,
 			Action<Exception> exceptionHandler = null,
 			CancellationToken cancellationToken = default)
 		{
@@ -36,9 +37,7 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 						Type = GQLWebSocketMessageType.GQL_STOP
 					};
 					var observable = graphQlHttpWebSocket.ResponseStream
-						.Where(response => {
-							return response != null && response.Id == startRequest.Id;
-						})
+						.Where(response => response != null && response.Id == startRequest.Id)
 						.SelectMany(response =>
 						{
 							switch (response.Type)
@@ -148,74 +147,73 @@ internal static IObservable<GraphQLResponse> CreateSubscriptionStream(
 				.Publish().RefCount();
 		}
 
-		internal static async Task<GraphQLResponse> Request(
+		internal static Task<GraphQLResponse> SendRequest(
 			this GraphQLHttpWebSocket graphQlHttpWebSocket,
 			GraphQLRequest request,
 			CancellationToken cancellationToken = default)
 		{
-			return await Observable.Create<GraphQLResponse>(async observer =>
-			{
-				var websocketRequest = new GraphQLWebSocketRequest
+			return Observable.Create<GraphQLResponse>(async observer =>
 				{
-					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 =>
+					var websocketRequest = new GraphQLWebSocketRequest
 					{
-						switch (response.Type)
+						Id = Guid.NewGuid().ToString("N"),
+						Type = GQLWebSocketMessageType.GQL_START,
+						Payload = request
+					};
+					var observable = graphQlHttpWebSocket.ResponseStream
+						.Where(response => response != null && response.Id == websocketRequest.Id)
+						.SelectMany(response =>
 						{
-							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>());
-						}
-					});
+							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);
-				}
+					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)
-				);
+					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;
-				}
+					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();
+					return disposable;
+				})
+				// complete sequence on OperationCanceledException, this is triggered by the cancellation token
+				.Catch<GraphQLResponse, OperationCanceledException>(exception =>
+					Observable.Empty<GraphQLResponse>())
+				.FirstOrDefaultAsync()
+				.ToTask(cancellationToken);
 		}
 	}
 }
diff --git a/tests/GraphQL.Integration.Tests/CallbackTester.cs b/tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs
similarity index 100%
rename from tests/GraphQL.Integration.Tests/CallbackTester.cs
rename to tests/GraphQL.Integration.Tests/Helpers/CallbackTester.cs
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/Helpers/GraphQLClientExtensions.cs
similarity index 100%
rename from tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
rename to tests/GraphQL.Integration.Tests/Helpers/GraphQLClientExtensions.cs
diff --git a/tests/GraphQL.Integration.Tests/NetworkHelpers.cs b/tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs
similarity index 100%
rename from tests/GraphQL.Integration.Tests/NetworkHelpers.cs
rename to tests/GraphQL.Integration.Tests/Helpers/NetworkHelpers.cs
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
similarity index 100%
rename from tests/GraphQL.Integration.Tests/ObservableTester.cs
rename to tests/GraphQL.Integration.Tests/Helpers/ObservableTester.cs
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/Helpers/WebApplicationFactoryExtensions.cs
similarity index 100%
rename from tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
rename to tests/GraphQL.Integration.Tests/Helpers/WebApplicationFactoryExtensions.cs
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/WebsocketTests.cs
similarity index 93%
rename from tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
rename to tests/GraphQL.Integration.Tests/WebsocketTests.cs
index a70301a6..955506e9 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/WebsocketTests.cs
@@ -13,7 +13,7 @@
 
 namespace GraphQL.Integration.Tests
 {
-	public class SubscriptionsTest
+	public class WebsocketTests
 	{
 		public static IWebHost CreateServer(int port)
 		{
@@ -37,14 +37,15 @@ public static IWebHost CreateServer(int port)
 			return host;
 		}
 
-		public SubscriptionsTest()
+		public WebsocketTests()
 		{
 		}
 
-		private GraphQLHttpClient GetGraphQLClient(int port)
+		private GraphQLHttpClient GetGraphQLClient(int port, bool queriesViaWebsocket = false)
 			=> new GraphQLHttpClient(new GraphQLHttpClientOptions
 			{
 				EndPoint = new Uri($"http://localhost:{port}/graphql"),
+				UseWebSocketForQueriesAndMutations = queriesViaWebsocket
 			});
 
 
@@ -63,6 +64,21 @@ public async void AssertTestingHarness()
 			}
 		}
 
+		[Fact]
+		public async void CanSendQueryViaWebsocket()
+		{
+			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);
+			}
+		}
+
 		private const string SubscriptionQuery = @"
 			subscription {
 			  messageAdded{