From 1a09c813aa7a1b347397e4055785584a65fd40dd Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Thu, 1 Nov 2018 18:09:02 +0100
Subject: [PATCH 1/8] create observable subscription

---
 src/GraphQL.Client/GraphQL.Client.csproj      |  14 +-
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |  30 +-
 .../Http/GraphQLHttpObservableSubscription.cs | 260 ++++++++++++++++++
 .../Http/GraphQLHttpSubscriptionResult.cs     |   8 +-
 src/GraphQL.Client/IGraphQLClient.cs          |   2 +
 .../Response/GraphQLSubscriptionResponse.cs   |   2 +-
 .../GraphQL.Client.Tests.csproj               |   4 +-
 .../GraphQLHttpObservableSubscriptionTest.cs  |  11 +
 8 files changed, 317 insertions(+), 14 deletions(-)
 create mode 100644 src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
 create mode 100644 tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 99a24460..0884c0a4 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -1,11 +1,11 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../src.props" />
 
 	<PropertyGroup>
 		<Description>A GraphQL Client</Description>
-		<TargetFrameworks>netstandard1.3;netstandard2.0</TargetFrameworks>
+		<TargetFrameworks>netstandard2.0</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -16,6 +16,16 @@
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
 	</ItemGroup>
 
+	<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+	  <PackageReference Include="System.Reactive">
+	    <Version>4.1.2</Version>
+	  </PackageReference>
+	</ItemGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+		<DefineConstants>DEBUG;TRACE</DefineConstants>
+	</PropertyGroup>
+
 	<!-- 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 58da72ee..7cdad08b 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using GraphQL.Client.Http.Internal;
@@ -117,23 +118,40 @@ public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(string query, Cancell
 			this.SendSubscribeAsync(new GraphQLRequest { Query = query }, cancellationToken);
 
 		[Obsolete("EXPERIMENTAL API")]
-		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default) {
+		public Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default)
+		{
+			GraphQLHttpSubscriptionResult graphQLSubscriptionResult = _createSubscription(request, cancellationToken);
+			return Task.FromResult<IGraphQLSubscriptionResult>(graphQLSubscriptionResult);
+		}
+
+		private GraphQLHttpSubscriptionResult _createSubscription(GraphQLRequest request, CancellationToken cancellationToken)
+		{
 			if (request == null) { throw new ArgumentNullException(nameof(request)); }
 			if (request.Query == null) { throw new ArgumentNullException(nameof(request.Query)); }
 
-			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
-			var webSocketUri = new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
-			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(webSocketUri, request);
+			var graphQLSubscriptionResult = new GraphQLHttpSubscriptionResult(_getWebSocketUri(), request);
 			graphQLSubscriptionResult.StartAsync(cancellationToken);
-			return Task.FromResult<IGraphQLSubscriptionResult>(graphQLSubscriptionResult);
+			return graphQLSubscriptionResult;
 		}
 
+		private Uri _getWebSocketUri()
+		{
+			var webSocketSchema = this.EndPoint.Scheme == "https" ? "wss" : "ws";
+			return new Uri($"{webSocketSchema}://{this.EndPoint.Host}:{this.EndPoint.Port}{this.EndPoint.AbsolutePath}");
+		}
+
+		[Obsolete("EXPERIMENTAL API")]
+		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
+		{
+			return GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request);
+		}
+
+
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
 		public void Dispose() =>
 			this.graphQLHttpHandler.Dispose();
-
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
new file mode 100644
index 00000000..089ac6d9
--- /dev/null
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -0,0 +1,260 @@
+using System;
+using System.Diagnostics;
+using System.Net.WebSockets;
+using System.Reactive.Linq;
+using System.Reactive.Threading.Tasks;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Newtonsoft.Json;
+
+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 GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest) {
+			this.webSocketUri = webSocketUri;
+			this.graphQLRequest = graphQLRequest;
+			this.clientWebSocket.Options.AddSubProtocol("graphql-ws");
+			arraySegment = new ArraySegment<byte>(buffer);
+		}
+		
+		public async Task ConnectAsync(CancellationToken token)
+		{
+			Debug.Print($"opening websocket on subscription {this.GetHashCode()}");
+			await clientWebSocket.ConnectAsync(webSocketUri, token).ConfigureAwait(false);
+		}
+
+		public async Task<GraphQLResponse> ReceiveResultAsync(CancellationToken token)
+		{
+			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, token).ConfigureAwait(false);
+			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
+			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
+			switch (webSocketResponse.Type)
+			{
+				case GQLWebSocketMessageType.GQL_COMPLETE:
+					Debug.Print($"received 'complete' message on subscription {this.GetHashCode()}");
+					Dispose();
+					break;
+				case GQLWebSocketMessageType.GQL_ERROR:
+					Debug.Print($"received 'error' message on subscription {this.GetHashCode()}");
+					throw new GQLSubscriptionException(webSocketResponse.Payload);
+				default:
+					Debug.Print($"received payload on subscription {this.GetHashCode()}");
+					break;
+			}
+
+			return (GraphQLResponse) webSocketResponse?.Payload;
+		}
+
+		public async Task CloseAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.Print($"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.Print($"sending initial message on subscription {this.GetHashCode()}");
+			var webSocketRequest = new GraphQLSubscriptionRequest
+			{
+				Id = "1",
+				Type = GQLWebSocketMessageType.GQL_START,
+				Payload = this.graphQLRequest
+			};
+			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
+		}
+
+		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
+		{
+			Debug.Print($"sending close message on subscription {this.GetHashCode()}");
+			var webSocketRequest = new GraphQLSubscriptionRequest
+			{
+				Id = "1",
+				Type = GQLWebSocketMessageType.GQL_STOP,
+				Payload = this.graphQLRequest
+			};
+			return this.SendGraphQLSubscriptionRequest(webSocketRequest, cancellationToken);
+		}
+
+		private Task SendGraphQLSubscriptionRequest(GraphQLSubscriptionRequest graphQLSubscriptionRequest, CancellationToken cancellationToken = default)
+		{
+			var webSocketRequestString = JsonConvert.SerializeObject(graphQLSubscriptionRequest);
+			var arraySegmentWebSocketRequest = new ArraySegment<byte>(Encoding.UTF8.GetBytes(webSocketRequestString));
+			return this.clientWebSocket.SendAsync(arraySegmentWebSocketRequest, WebSocketMessageType.Text, true, cancellationToken);
+		}
+
+		#region IDisposable
+
+		public void Dispose()
+		{
+			// Async disposal as recommended by Stephen Cleary (https://blog.stephencleary.com/2013/03/async-oop-6-disposal.html)
+			if(Disposed == null) Disposed = DisposeAsync();
+		}
+
+		public Task Disposed { get; private set; }
+
+		private async Task DisposeAsync()
+		{
+			Debug.Print($"disposing subscription {this.GetHashCode()}...");
+			await CloseAsync().ConfigureAwait(false);
+			clientWebSocket?.Dispose();
+			Debug.Print($"subscription {this.GetHashCode()} disposed");
+		}
+
+		#endregion
+
+		#region Static Factories
+
+		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest)
+		{
+			return Observable.Using(
+				token => CreateSubscription(webSocketUri, graphQLRequest),
+				InitializeSubscription
+				).Publish().RefCount();
+		}
+
+
+		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest)
+		{
+			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest);
+			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(cancelToken).ToObservable()).Repeat();
+		}
+
+		#endregion
+
+		[Serializable]
+		public class GQLSubscriptionException : Exception
+		{
+			//
+			// For guidelines regarding the creation of new exception types, see
+			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconerrorraisinghandlingguidelines.asp
+			// and
+			//    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp07192001.asp
+			//
+
+			public GQLSubscriptionException()
+			{
+			}
+
+			public GQLSubscriptionException(object error) : base(error.ToString())
+			{
+			}
+
+			protected GQLSubscriptionException(
+				SerializationInfo info,
+				StreamingContext context) : base(info, context)
+			{
+			}
+		}
+
+		public static class GQLWebSocketMessageType
+		{
+
+			/// <summary>
+			///     Client sends this message after plain websocket connection to start the communication with the server
+			///     The server will response only with GQL_CONNECTION_ACK + GQL_CONNECTION_KEEP_ALIVE(if used) or GQL_CONNECTION_ERROR
+			///     to this message.
+			///     payload: Object : optional parameters that the client specifies in connectionParams
+			/// </summary>
+			public const string GQL_CONNECTION_INIT = "connection_init";
+
+			/// <summary>
+			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server accepted
+			///     the connection.
+			/// </summary>
+			public const string GQL_CONNECTION_ACK = "connection_ack"; // Server -> Client
+
+			/// <summary>
+			///     The server may responses with this message to the GQL_CONNECTION_INIT from client, indicates the server rejected
+			///     the connection.
+			///     It server also respond with this message in case of a parsing errors of the message (which does not disconnect the
+			///     client, just ignore the message).
+			///     payload: Object: the server side error
+			/// </summary>
+			public const string GQL_CONNECTION_ERROR = "connection_error"; // Server -> Client
+
+			/// <summary>
+			///     Server message that should be sent right after each GQL_CONNECTION_ACK processed and then periodically to keep the
+			///     client connection alive.
+			///     The client starts to consider the keep alive message only upon the first received keep alive message from the
+			///     server.
+			///     <remarks>
+			///         NOTE: This one here don't follow the standard due to connection optimization
+			///     </remarks>
+			/// </summary>
+			public const string GQL_CONNECTION_KEEP_ALIVE = "ka"; // Server -> Client
+
+			/// <summary>
+			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+			///     id: string : operation id
+			/// </summary>
+			public const string GQL_CONNECTION_TERMINATE = "connection_terminate"; // Client -> Server
+
+			/// <summary>
+			///     Client sends this message to execute GraphQL operation
+			///     id: string : The id of the GraphQL operation to start
+			///     payload: Object:
+			///     query: string : GraphQL operation as string or parsed GraphQL document node
+			///     variables?: Object : Object with GraphQL variables
+			///     operationName?: string : GraphQL operation name
+			/// </summary>
+			public const string GQL_START = "start";
+
+			/// <summary>
+			///     The server sends this message to transfer the GraphQL execution result from the server to the client, this message
+			///     is a response for GQL_START message.
+			///     For each GraphQL operation send with GQL_START, the server will respond with at least one GQL_DATA message.
+			///     id: string : ID of the operation that was successfully set up
+			///     payload: Object :
+			///     data: any: Execution result
+			///     errors?: Error[] : Array of resolvers errors
+			/// </summary>
+			public const string GQL_DATA = "data"; // Server -> Client
+
+			/// <summary>
+			///     Server sends this message upon a failing operation, before the GraphQL execution, usually due to GraphQL validation
+			///     errors (resolver errors are part of GQL_DATA message, and will be added as errors array)
+			///     payload: Error : payload with the error attributed to the operation failing on the server
+			///     id: string : operation ID of the operation that failed on the server
+			/// </summary>
+			public const string GQL_ERROR = "error"; // Server -> Client
+
+			/// <summary>
+			///     Server sends this message to indicate that a GraphQL operation is done, and no more data will arrive for the
+			///     specific operation.
+			///     id: string : operation ID of the operation that completed
+			/// </summary>
+			public const string GQL_COMPLETE = "complete"; // Server -> Client
+
+			/// <summary>
+			///     Client sends this message in order to stop a running GraphQL operation execution (for example: unsubscribe)
+			///     id: string : operation id
+			/// </summary>
+			public const string GQL_STOP = "stop"; // Client -> Server
+		}
+	}
+}
diff --git a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
index 3f467af8..84f59a84 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpSubscriptionResult.cs
@@ -39,9 +39,11 @@ public async void StartAsync(CancellationToken cancellationToken = default) {
 					var webSocketReceiveResult = await this.clientWebSocket.ReceiveAsync(arraySegment, cancellationToken);
 					var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
 					var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
-					if (webSocketResponse != null) {
-						this.LastResponse = webSocketResponse.Payload;
-						this.OnReceive?.Invoke(webSocketResponse.Payload);
+					if (webSocketResponse != null)
+					{
+						var response = (GraphQLResponse) webSocketResponse.Payload;
+						this.LastResponse = response;
+						this.OnReceive?.Invoke(response);
 					}
 				}
 			}
diff --git a/src/GraphQL.Client/IGraphQLClient.cs b/src/GraphQL.Client/IGraphQLClient.cs
index 108762f7..3343da14 100644
--- a/src/GraphQL.Client/IGraphQLClient.cs
+++ b/src/GraphQL.Client/IGraphQLClient.cs
@@ -36,6 +36,8 @@ public interface IGraphQLClient : IDisposable {
 		[Obsolete("EXPERIMENTAL")]
 		Task<IGraphQLSubscriptionResult> SendSubscribeAsync(GraphQLRequest request, CancellationToken cancellationToken = default);
 
+		[Obsolete("EXPERIMENTAL")]
+		IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request);
 	}
 
 }
diff --git a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs b/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
index 3ba69331..71c47c72 100644
--- a/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
+++ b/src/GraphQL.Common/Response/GraphQLSubscriptionResponse.cs
@@ -22,7 +22,7 @@ public class GraphQLSubscriptionResponse : IEquatable<GraphQLSubscriptionRespons
 		/// <summary>
 		/// The Payload of the Response
 		/// </summary>
-		public GraphQLResponse Payload { get; set; }
+		public dynamic Payload { get; set; }
 
 		/// <inheritdoc />
 		public override bool Equals(object obj) => this.Equals(obj as GraphQLSubscriptionResponse);
diff --git a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
index e8584d6d..cef55529 100644
--- a/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
+++ b/tests/GraphQL.Client.Tests/GraphQL.Client.Tests.csproj
@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="../tests.props" />
 
 	<PropertyGroup>
-		<TargetFrameworks>netcoreapp1.0;netcoreapp1.1;netcoreapp2.0;netcoreapp2.1</TargetFrameworks>
+		<TargetFrameworks>netcoreapp2.0;netcoreapp2.1</TargetFrameworks>
 	</PropertyGroup>
 
 	<ItemGroup>
diff --git a/tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs b/tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs
new file mode 100644
index 00000000..010b8e01
--- /dev/null
+++ b/tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL.Client.Tests.Http
+{
+	public class GraphQLHttpObservableSubscriptionTest
+	{
+
+	}
+}

From 6ff70609c79516058ca8539464821ee7a0bc8457 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 2 Nov 2018 00:07:17 +0100
Subject: [PATCH 2/8] create integration test server and test project

---
 GraphQL.Client.sln                            | 16 +++-
 .../Http/HttpClientExtensions.cs              | 10 +++
 .../GraphQLHttpObservableSubscriptionTest.cs  | 11 ---
 .../GraphQL.Integration.Tests.csproj          | 28 +++++++
 .../GraphQLClientExtensions.cs                | 34 ++++++++
 .../Properties/launchSettings.json            | 27 +++++++
 .../SubscriptionsTest.cs                      | 69 ++++++++++++++++
 .../WebApplicationFactoryExtensions.cs        | 18 +++++
 .../ChatSchema/ChatMutation.cs                | 31 ++++++++
 .../ChatSchema/ChatQuery.cs                   | 13 +++
 .../ChatSchema/ChatSchema.cs                  | 14 ++++
 .../ChatSchema/ChatSubscriptions.cs           | 74 +++++++++++++++++
 .../IntegrationTestServer/ChatSchema/IChat.cs | 79 +++++++++++++++++++
 .../ChatSchema/Message.cs                     | 15 ++++
 .../ChatSchema/MessageFrom.cs                 |  9 +++
 .../ChatSchema/MessageFromType.cs             | 13 +++
 .../ChatSchema/MessageType.cs                 | 21 +++++
 .../ChatSchema/ReceivedMessage.cs             | 13 +++
 .../IntegrationTestServer.csproj              | 22 ++++++
 tests/IntegrationTestServer/Program.cs        | 17 ++++
 .../Properties/launchSettings.json            | 27 +++++++
 tests/IntegrationTestServer/Startup.cs        | 70 ++++++++++++++++
 22 files changed, 619 insertions(+), 12 deletions(-)
 delete mode 100644 tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs
 create mode 100644 tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
 create mode 100644 tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
 create mode 100644 tests/GraphQL.Integration.Tests/Properties/launchSettings.json
 create mode 100644 tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
 create mode 100644 tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/IChat.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/Message.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/MessageType.cs
 create mode 100644 tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
 create mode 100644 tests/IntegrationTestServer/IntegrationTestServer.csproj
 create mode 100644 tests/IntegrationTestServer/Program.cs
 create mode 100644 tests/IntegrationTestServer/Properties/launchSettings.json
 create mode 100644 tests/IntegrationTestServer/Startup.cs

diff --git a/GraphQL.Client.sln b/GraphQL.Client.sln
index 45a422a5..722a7d85 100644
--- a/GraphQL.Client.sln
+++ b/GraphQL.Client.sln
@@ -43,7 +43,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".circleci", ".circleci", "{
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{9413EC62-CDDE-4E77-9784-E1136EA5D1EE}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Client.Sample", "samples\GraphQL.Client.Sample\GraphQL.Client.Sample.csproj", "{B21E97C3-F328-473F-A054-A4BF272B63F0}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphQL.Integration.Tests", "tests\GraphQL.Integration.Tests\GraphQL.Integration.Tests.csproj", "{86BC3878-6549-4EF1-9672-B7C15A3FDF46}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IntegrationTestServer", "tests\IntegrationTestServer\IntegrationTestServer.csproj", "{618653E5-41C2-4F17-BE4F-F904267500D4}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -71,6 +75,14 @@ Global
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B21E97C3-F328-473F-A054-A4BF272B63F0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46}.Release|Any CPU.Build.0 = Release|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{618653E5-41C2-4F17-BE4F-F904267500D4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -83,6 +95,8 @@ Global
 		{6326E0E2-3F48-4BAF-80D3-47AED5EB647C} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 		{C1406F03-650F-4633-887D-312943251919} = {63F75859-4698-4EDE-8B70-4ACBB8BC425A}
 		{B21E97C3-F328-473F-A054-A4BF272B63F0} = {9413EC62-CDDE-4E77-9784-E1136EA5D1EE}
+		{86BC3878-6549-4EF1-9672-B7C15A3FDF46} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
+		{618653E5-41C2-4F17-BE4F-F904267500D4} = {0B0EDB0F-FF67-4B78-A8DB-B5C23E1FEE8C}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {387AC1AC-F90C-4EF8-955A-04D495C75AF4}
diff --git a/src/GraphQL.Client/Http/HttpClientExtensions.cs b/src/GraphQL.Client/Http/HttpClientExtensions.cs
index c0fb4b49..1d7ca0e4 100644
--- a/src/GraphQL.Client/Http/HttpClientExtensions.cs
+++ b/src/GraphQL.Client/Http/HttpClientExtensions.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Net.Http;
 
 namespace GraphQL.Client.Http {
@@ -16,6 +17,15 @@ public static class HttpClientExtensions {
 		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, GraphQLHttpClientOptions graphQLHttpClientOptions) =>
 			new GraphQLHttpClient(graphQLHttpClientOptions, httpClient);
 
+		/// <summary>
+		/// Creates a <see cref="GraphQLHttpClient"/> from a <see cref="HttpClient"/>
+		/// </summary>
+		/// <param name="httpClient"></param>
+		/// <param name="endPoint"></param>
+		/// <returns></returns>
+		public static GraphQLHttpClient AsGraphQLClient(this HttpClient httpClient, Uri endPoint) =>
+			new GraphQLHttpClient(new GraphQLHttpClientOptions { EndPoint = endPoint }, httpClient);
+
 	}
 
 }
diff --git a/tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs b/tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs
deleted file mode 100644
index 010b8e01..00000000
--- a/tests/GraphQL.Client.Tests/Http/GraphQLHttpObservableSubscriptionTest.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace GraphQL.Client.Tests.Http
-{
-	public class GraphQLHttpObservableSubscriptionTest
-	{
-
-	}
-}
diff --git a/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
new file mode 100644
index 00000000..5fc195bc
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/GraphQL.Integration.Tests.csproj
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.5" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="2.1.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\GraphQL.Client\GraphQL.Client.csproj" />
+    <ProjectReference Include="..\..\src\GraphQL.Common\GraphQL.Common.csproj" />
+    <ProjectReference Include="..\IntegrationTestServer\IntegrationTestServer.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
new file mode 100644
index 00000000..ba1e600d
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class GraphQLClientExtensions
+	{
+		public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient client, string message)
+		{
+			var graphQLRequest = new GraphQLRequest
+			{
+				Query = @"
+				mutation($input: MessageInputType){
+				  addMessage(message: $input){
+				    content
+				  }
+				}",
+				Variables = new
+				{
+					input = new
+					{
+						fromId = "me",
+						content = "Lorem ipsum dolor si amet",
+						sentAt = DateTime.Now
+					}
+				}
+			};
+			return await client.SendMutationAsync(graphQLRequest).ConfigureAwait(false);
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/Properties/launchSettings.json b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
new file mode 100644
index 00000000..f8fea71b
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/Properties/launchSettings.json
@@ -0,0 +1,27 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:51432/",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "GraphQL.Integration.Tests": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:51433/"
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
new file mode 100644
index 00000000..71438e01
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using GraphQL.Client.Http;
+using GraphQL.Common.Request;
+using GraphQL.Common.Response;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+
+namespace GraphQL.Integration.Tests
+{
+	public class SubscriptionsTest: IClassFixture<WebApplicationFactory<IntegrationTestServer.Startup>>
+	{
+
+		private readonly WebApplicationFactory<IntegrationTestServer.Startup> _factory;
+
+		public SubscriptionsTest(WebApplicationFactory<IntegrationTestServer.Startup> factory)
+		{
+			_factory = factory;
+		}
+
+		private GraphQLHttpClient GetGraphQLClient()
+			=> _factory.CreateGraphQlHttpClient("graphql");
+
+
+		[Fact]
+		public async void AssertTestingHarness()
+		{
+			var client = GetGraphQLClient();
+			var datetime = DateTime.Now;
+
+			var response = await client.AddMessageAsync("Lorem ipsum dolor si amet").ConfigureAwait(false);
+
+			Assert.Equal("Lorem ipsum dolor si amet", (string) response.Data.addMessage.content);
+		}
+
+		[Fact]
+		public async void CanCreateObservableSubscription()
+		{
+			var client = GetGraphQLClient();
+
+			var graphQLRequest = new GraphQLRequest
+			{
+				Query = @"
+				subscription {
+				  messageAdded{
+				    content
+				  }
+				}"
+			};
+
+			Debug.Write("creating subscription stream");
+			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+			string message = null;
+
+			await Task.Delay(1000).ConfigureAwait(false);
+
+			Debug.Write("subscribing...");
+			using (observable.Subscribe(response => message = (string) response.Data.messageAdded.content, ex => throw ex))
+			{
+				await Task.Delay(1000).ConfigureAwait(false);
+				Assert.Null(message);
+				var response = await client.AddMessageAsync("Lorem ipsum dolor si amet").ConfigureAwait(false);
+				Assert.Equal("Lorem ipsum dolor si amet", message);
+			}
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
new file mode 100644
index 00000000..de7adfc5
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -0,0 +1,18 @@
+using System;
+using GraphQL.Client.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace GraphQL.Integration.Tests
+{
+	public static class WebApplicationFactoryExtensions
+	{
+		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
+			this WebApplicationFactory<TEntryPoint> factory, string schemaPath) where TEntryPoint: class
+		{
+			var httpClient = factory.CreateClient();
+			var uriBuilder = new UriBuilder(httpClient.BaseAddress);
+			uriBuilder.Path = schemaPath;
+			return httpClient.AsGraphQLClient(uriBuilder.Uri);
+		}
+	}
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
new file mode 100644
index 00000000..7c2a2333
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatMutation.cs
@@ -0,0 +1,31 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatMutation : ObjectGraphType<object>
+    {
+        public ChatMutation(IChat chat)
+        {
+            Field<MessageType>("addMessage",
+                arguments: new QueryArguments(
+                    new QueryArgument<MessageInputType> {Name = "message"}
+                ),
+                resolve: context =>
+                {
+                    var receivedMessage = context.GetArgument<ReceivedMessage>("message");
+                    var message = chat.AddMessage(receivedMessage);
+                    return message;
+                });
+        }
+    }
+
+    public class MessageInputType : InputObjectGraphType
+    {
+        public MessageInputType()
+        {
+            Field<StringGraphType>("fromId");
+            Field<StringGraphType>("content");
+            Field<DateGraphType>("sentAt");
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
new file mode 100644
index 00000000..579c364f
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatQuery.cs
@@ -0,0 +1,13 @@
+using System.Linq;
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatQuery : ObjectGraphType
+    {
+        public ChatQuery(IChat chat)
+        {
+            Field<ListGraphType<MessageType>>("messages", resolve: context => chat.AllMessages.Take(100));
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
new file mode 100644
index 00000000..904623a2
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSchema.cs
@@ -0,0 +1,14 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatSchema : Schema
+    {
+        public ChatSchema(IChat chat) 
+        {
+            Query = new ChatQuery(chat);
+            Mutation = new ChatMutation(chat);
+            Subscription = new ChatSubscriptions(chat);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
new file mode 100644
index 00000000..3c8c9624
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ChatSubscriptions.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Security.Claims;
+using GraphQL;
+using GraphQL.Resolvers;
+using GraphQL.Server.Transports.Subscriptions.Abstractions;
+using GraphQL.Subscription;
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ChatSubscriptions : ObjectGraphType<object>
+    {
+        private readonly IChat _chat;
+
+        public ChatSubscriptions(IChat chat)
+        {
+            _chat = chat;
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAdded",
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(Subscribe)
+            });
+
+            AddField(new EventStreamFieldType
+            {
+                Name = "messageAddedByUser",
+                Arguments = new QueryArguments(
+                    new QueryArgument<NonNullGraphType<StringGraphType>> {Name = "id"}
+                ),
+                Type = typeof(MessageType),
+                Resolver = new FuncFieldResolver<Message>(ResolveMessage),
+                Subscriber = new EventStreamResolver<Message>(SubscribeById)
+            });
+        }
+
+        private IObservable<Message> SubscribeById(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            var messages = _chat.Messages(sub);
+
+            var id = context.GetArgument<string>("id");
+            return messages.Where(message => message.From.Id == id);
+        }
+
+        private Message ResolveMessage(ResolveFieldContext context)
+        {
+            var message = context.Source as Message;
+
+            return message;
+        }
+
+        private IObservable<Message> Subscribe(ResolveEventStreamContext context)
+        {
+            var messageContext = context.UserContext.As<MessageHandlingContext>();
+            var user = messageContext.Get<ClaimsPrincipal>("user");
+
+            var sub = "Anonymous";
+            if (user != null)
+                sub = user.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
+
+            return _chat.Messages(sub);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/IChat.cs b/tests/IntegrationTestServer/ChatSchema/IChat.cs
new file mode 100644
index 00000000..68c8e86b
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/IChat.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Concurrent;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public interface IChat
+    {
+        ConcurrentStack<Message> AllMessages { get; }
+
+        Message AddMessage(Message message);
+
+        IObservable<Message> Messages(string user);
+
+        Message AddMessage(ReceivedMessage message);
+    }
+
+    public class Chat : IChat
+    {
+        private readonly ISubject<Message> _messageStream = new ReplaySubject<Message>(1);
+
+        public Chat()
+        {
+            AllMessages = new ConcurrentStack<Message>();
+            Users = new ConcurrentDictionary<string, string>
+            {
+                ["1"] = "developer",
+                ["2"] = "tester"
+            };
+        }
+
+        public ConcurrentDictionary<string, string> Users { get; set; }
+
+        public ConcurrentStack<Message> AllMessages { get; }
+
+        public Message AddMessage(ReceivedMessage message)
+        {
+            if (!Users.TryGetValue(message.FromId, out var displayName))
+            {
+                displayName = "(unknown)";
+            }
+
+            return AddMessage(new Message
+            {
+                Content = message.Content,
+                SentAt = message.SentAt,
+                From = new MessageFrom
+                {
+                    DisplayName = displayName,
+                    Id = message.FromId
+                }
+            });
+        }
+
+        public Message AddMessage(Message message)
+        {
+            AllMessages.Push(message);
+            _messageStream.OnNext(message);
+            return message;
+        }
+
+        public IObservable<Message> Messages(string user)
+        {
+            return _messageStream
+                .Select(message =>
+                {
+                    message.Sub = user;
+                    return message;
+                })
+                .AsObservable();
+        }
+
+        public void AddError(Exception exception)
+        {
+            _messageStream.OnError(exception);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/Message.cs b/tests/IntegrationTestServer/ChatSchema/Message.cs
new file mode 100644
index 00000000..f3b90cb1
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/Message.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class Message
+    {
+        public MessageFrom From { get; set; }
+
+        public string Sub { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime SentAt { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
new file mode 100644
index 00000000..5346cb6b
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFrom.cs
@@ -0,0 +1,9 @@
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageFrom
+    {
+        public string Id { get; set; }
+
+        public string DisplayName { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
new file mode 100644
index 00000000..98830475
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageFromType.cs
@@ -0,0 +1,13 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageFromType : ObjectGraphType<MessageFrom>
+    {
+        public MessageFromType()
+        {
+            Field(o => o.Id);
+            Field(o => o.DisplayName);
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/MessageType.cs b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
new file mode 100644
index 00000000..320f5b55
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/MessageType.cs
@@ -0,0 +1,21 @@
+using GraphQL.Types;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class MessageType : ObjectGraphType<Message>
+    {
+        public MessageType()
+        {
+            Field(o => o.Content);
+            Field(o => o.SentAt);
+            Field(o => o.Sub);
+            Field(o => o.From, false, typeof(MessageFromType)).Resolve(ResolveFrom);
+        }
+
+        private MessageFrom ResolveFrom(ResolveFieldContext<Message> context)
+        {
+            var message = context.Source;
+            return message.From;
+        }
+    }
+}
diff --git a/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
new file mode 100644
index 00000000..0f1a409a
--- /dev/null
+++ b/tests/IntegrationTestServer/ChatSchema/ReceivedMessage.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace IntegrationTestServer.ChatSchema
+{
+    public class ReceivedMessage
+    {
+        public string FromId { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime SentAt { get; set; }
+    }
+}
diff --git a/tests/IntegrationTestServer/IntegrationTestServer.csproj b/tests/IntegrationTestServer/IntegrationTestServer.csproj
new file mode 100644
index 00000000..179554ff
--- /dev/null
+++ b/tests/IntegrationTestServer/IntegrationTestServer.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GraphQL.Server.Transports.AspNetCore" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Transports.WebSockets" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" Version="3.2.0" />
+    <PackageReference Include="GraphQL.Server.Ui.Voyager" Version="3.2.0" />
+    <PackageReference Include="Microsoft.AspNetCore.App" />
+    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.1.2" PrivateAssets="All" />
+    <PackageReference Include="System.Reactive" Version="4.1.2" />
+    <PackageReference Include="System.Reactive.Compatibility" Version="4.1.2" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/IntegrationTestServer/Program.cs b/tests/IntegrationTestServer/Program.cs
new file mode 100644
index 00000000..fd8448a8
--- /dev/null
+++ b/tests/IntegrationTestServer/Program.cs
@@ -0,0 +1,17 @@
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+
+namespace IntegrationTestServer
+{
+	public class Program
+	{
+		public static void Main(string[] args)
+		{
+			CreateWebHostBuilder(args).Build().Run();
+		}
+
+		public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
+			WebHost.CreateDefaultBuilder(args)
+				.UseStartup<Startup>();
+	}
+}
diff --git a/tests/IntegrationTestServer/Properties/launchSettings.json b/tests/IntegrationTestServer/Properties/launchSettings.json
new file mode 100644
index 00000000..e6bdf925
--- /dev/null
+++ b/tests/IntegrationTestServer/Properties/launchSettings.json
@@ -0,0 +1,27 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false, 
+    "anonymousAuthentication": true,
+		"iisExpress": {
+			"applicationUrl": "http://localhost:55069/ui/graphiql/",
+			"sslPort": 0
+		}
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+	"ImplementationTestServer": {
+		"commandName": "ImplementationTestServer",
+		"launchBrowser": true,
+		"applicationUrl": "http://localhost:5000/ui/graphiql/",
+		"environmentVariables": {
+			"ASPNETCORE_ENVIRONMENT": "Development"
+		}
+	}
+  }
+}
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
new file mode 100644
index 00000000..7e86a45a
--- /dev/null
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -0,0 +1,70 @@
+using GraphQL.Server;
+using GraphQL.Server.Ui.GraphiQL;
+using GraphQL.Server.Ui.Voyager;
+using IntegrationTestServer.ChatSchema;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace IntegrationTestServer
+{
+	public class Startup
+	{
+		public Startup(IConfiguration configuration, IHostingEnvironment environment)
+		{
+			Configuration = configuration;
+			Environment = environment;
+		}
+
+		public IConfiguration Configuration { get; }
+		public IHostingEnvironment Environment { get; }
+
+		// This method gets called by the runtime. Use this method to add services to the container.
+		// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
+		public void ConfigureServices(IServiceCollection services)
+		{
+			services.AddSingleton<IChat, Chat>();
+			services.AddSingleton<ChatSchema.ChatSchema>();
+			services.AddSingleton<ChatQuery>();
+			services.AddSingleton<ChatMutation>();
+			services.AddSingleton<ChatSubscriptions>();
+			services.AddSingleton<MessageType>();
+			services.AddSingleton<MessageInputType>();
+
+			services.AddGraphQL(options =>
+				{
+					options.EnableMetrics = true;
+					options.ExposeExceptions = Environment.IsDevelopment();
+				})
+				.AddWebSockets()
+				.AddDataLoader();
+
+			services.AddMvc();
+		}
+
+		// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+		public void Configure(IApplicationBuilder app, IHostingEnvironment env)
+		{
+			if (env.IsDevelopment())
+			{
+				app.UseDeveloperExceptionPage();
+			}
+
+			app.UseWebSockets();
+			app.UseGraphQLWebSockets<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphQL<ChatSchema.ChatSchema>("/graphql");
+			app.UseGraphiQLServer(new GraphiQLOptions
+			{
+				GraphiQLPath = "/ui/graphiql",
+				GraphQLEndPoint = "/graphql"
+			});
+			app.UseGraphQLVoyager(new GraphQLVoyagerOptions()
+			{
+				GraphQLEndPoint = "/graphql",
+				Path = "/ui/voyager"
+			});
+			app.UseMvc();
+		}
+	}
+}

From 16fde6d64af5c0f31c1d5e148792c2acbb77fb18 Mon Sep 17 00:00:00 2001
From: Alexander Rose <alex@rose-a.de>
Date: Fri, 2 Nov 2018 00:40:30 +0100
Subject: [PATCH 3/8] fix debug output

---
 .../Http/GraphQLHttpObservableSubscription.cs | 19 ++++++++++---------
 .../SubscriptionsTest.cs                      |  6 +++---
 .../WebApplicationFactoryExtensions.cs        |  5 +++--
 3 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 089ac6d9..a6632995 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -34,8 +34,9 @@ private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graph
 		
 		public async Task ConnectAsync(CancellationToken token)
 		{
-			Debug.Print($"opening websocket on subscription {this.GetHashCode()}");
+			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(CancellationToken token)
@@ -46,14 +47,14 @@ public async Task<GraphQLResponse> ReceiveResultAsync(CancellationToken token)
 			switch (webSocketResponse.Type)
 			{
 				case GQLWebSocketMessageType.GQL_COMPLETE:
-					Debug.Print($"received 'complete' message on subscription {this.GetHashCode()}");
+					Debug.WriteLine($"received 'complete' message on subscription {this.GetHashCode()}");
 					Dispose();
 					break;
 				case GQLWebSocketMessageType.GQL_ERROR:
-					Debug.Print($"received 'error' message on subscription {this.GetHashCode()}");
+					Debug.WriteLine($"received 'error' message on subscription {this.GetHashCode()}");
 					throw new GQLSubscriptionException(webSocketResponse.Payload);
 				default:
-					Debug.Print($"received payload on subscription {this.GetHashCode()}");
+					Debug.WriteLine($"received payload on subscription {this.GetHashCode()}");
 					break;
 			}
 
@@ -62,7 +63,7 @@ public async Task<GraphQLResponse> ReceiveResultAsync(CancellationToken token)
 
 		public async Task CloseAsync(CancellationToken cancellationToken = default)
 		{
-			Debug.Print($"closing websocket on subscription {this.GetHashCode()}");
+			Debug.WriteLine($"closing websocket on subscription {this.GetHashCode()}");
 			if (this.clientWebSocket.State == WebSocketState.Open) {
 				await SendCloseMessageAsync(cancellationToken).ConfigureAwait(false);
 			}
@@ -71,7 +72,7 @@ public async Task CloseAsync(CancellationToken cancellationToken = default)
 
 		private Task SendInitialMessageAsync(CancellationToken cancellationToken = default)
 		{
-			Debug.Print($"sending initial message on subscription {this.GetHashCode()}");
+			Debug.WriteLine($"sending initial message on subscription {this.GetHashCode()}");
 			var webSocketRequest = new GraphQLSubscriptionRequest
 			{
 				Id = "1",
@@ -83,7 +84,7 @@ private Task SendInitialMessageAsync(CancellationToken cancellationToken = defau
 
 		private Task SendCloseMessageAsync(CancellationToken cancellationToken = default)
 		{
-			Debug.Print($"sending close message on subscription {this.GetHashCode()}");
+			Debug.WriteLine($"sending close message on subscription {this.GetHashCode()}");
 			var webSocketRequest = new GraphQLSubscriptionRequest
 			{
 				Id = "1",
@@ -112,10 +113,10 @@ public void Dispose()
 
 		private async Task DisposeAsync()
 		{
-			Debug.Print($"disposing subscription {this.GetHashCode()}...");
+			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
 			await CloseAsync().ConfigureAwait(false);
 			clientWebSocket?.Dispose();
-			Debug.Print($"subscription {this.GetHashCode()} disposed");
+			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
 		}
 
 		#endregion
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 71438e01..155419ba 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -50,16 +50,16 @@ public async void CanCreateObservableSubscription()
 				}"
 			};
 
-			Debug.Write("creating subscription stream");
+			Debug.WriteLine("creating subscription stream");
 			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
 			string message = null;
 
 			await Task.Delay(1000).ConfigureAwait(false);
 
-			Debug.Write("subscribing...");
+			Debug.WriteLine("subscribing...");
 			using (observable.Subscribe(response => message = (string) response.Data.messageAdded.content, ex => throw ex))
 			{
-				await Task.Delay(1000).ConfigureAwait(false);
+				await Task.Delay(10000).ConfigureAwait(false);
 				Assert.Null(message);
 				var response = await client.AddMessageAsync("Lorem ipsum dolor si amet").ConfigureAwait(false);
 				Assert.Equal("Lorem ipsum dolor si amet", message);
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
index de7adfc5..9998e6cf 100644
--- a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -7,11 +7,12 @@ namespace GraphQL.Integration.Tests
 	public static class WebApplicationFactoryExtensions
 	{
 		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
-			this WebApplicationFactory<TEntryPoint> factory, string schemaPath) where TEntryPoint: class
+			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchema, string urlScheme = "http://") where TEntryPoint: class
 		{
 			var httpClient = factory.CreateClient();
 			var uriBuilder = new UriBuilder(httpClient.BaseAddress);
-			uriBuilder.Path = schemaPath;
+			uriBuilder.Path = graphQlSchema;
+			uriBuilder.Scheme = urlScheme;
 			return httpClient.AsGraphQLClient(uriBuilder.Uri);
 		}
 	}

From 15723616a96721a4ccfc3adc9d25bc60205051e4 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 7 Nov 2018 08:34:11 +0100
Subject: [PATCH 4/8] create basic unit test for subscription

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  |   1 -
 .../Http/GraphQLHttpObservableSubscription.cs |  23 +++-
 .../GraphQLClientExtensions.cs                |   2 +-
 .../ObservableTester.cs                       | 102 ++++++++++++++++
 .../SubscriptionsTest.cs                      | 112 ++++++++++++------
 .../WebApplicationFactoryExtensions.cs        |   4 +-
 .../Properties/launchSettings.json            |  29 ++---
 tests/IntegrationTestServer/Startup.cs        |   3 +-
 8 files changed, 215 insertions(+), 61 deletions(-)
 create mode 100644 tests/GraphQL.Integration.Tests/ObservableTester.cs

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index 7cdad08b..b1a7b37b 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpClient.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
@@ -146,7 +146,6 @@ public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest requ
 			return GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request);
 		}
 
-
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index a6632995..78c9dfa6 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -10,6 +10,7 @@
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace GraphQL.Client.Http {
 
@@ -18,12 +19,13 @@ namespace GraphQL.Client.Http {
 	/// </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 = new CancellationTokenSource();
 
 		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest) {
 			this.webSocketUri = webSocketUri;
@@ -31,7 +33,7 @@ private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graph
 			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()}");
@@ -39,9 +41,9 @@ public async Task ConnectAsync(CancellationToken token)
 			Debug.WriteLine($"connection established on subscription {this.GetHashCode()}");
 		}
 
-		public async Task<GraphQLResponse> ReceiveResultAsync(CancellationToken token)
+		public async Task<GraphQLResponse> ReceiveResultAsync()
 		{
-			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, token).ConfigureAwait(false);
+			var webSocketReceiveResult = await clientWebSocket.ReceiveAsync(arraySegment, _cancellationTokenSource.Token).ConfigureAwait(false);
 			var stringResult = Encoding.UTF8.GetString(arraySegment.Array, 0, webSocketReceiveResult.Count);
 			var webSocketResponse = JsonConvert.DeserializeObject<GraphQLSubscriptionResponse>(stringResult);
 			switch (webSocketResponse.Type)
@@ -58,7 +60,15 @@ public async Task<GraphQLResponse> ReceiveResultAsync(CancellationToken token)
 					break;
 			}
 
-			return (GraphQLResponse) webSocketResponse?.Payload;
+			try
+			{
+				return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
+			}
+			catch (Exception e)
+			{
+				Console.WriteLine(e);
+				throw;
+			}
 		}
 
 		public async Task CloseAsync(CancellationToken cancellationToken = default)
@@ -114,6 +124,7 @@ public void Dispose()
 		private async Task DisposeAsync()
 		{
 			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
+			_cancellationTokenSource.Cancel();
 			await CloseAsync().ConfigureAwait(false);
 			clientWebSocket?.Dispose();
 			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
@@ -142,7 +153,7 @@ private static async Task<IObservable<GraphQLResponse>> InitializeSubscription(G
 		{
 			await observableSubscription.ConnectAsync(cancelToken).ConfigureAwait(false);
 			await observableSubscription.SendInitialMessageAsync(cancelToken).ConfigureAwait(false);
-			return Observable.Defer(() => observableSubscription.ReceiveResultAsync(cancelToken).ToObservable()).Repeat();
+			return Observable.Defer(() => observableSubscription.ReceiveResultAsync().ToObservable()).Repeat();
 		}
 
 		#endregion
diff --git a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
index ba1e600d..e8b4babf 100644
--- a/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/GraphQLClientExtensions.cs
@@ -23,7 +23,7 @@ public static async Task<GraphQLResponse> AddMessageAsync(this GraphQLHttpClient
 					input = new
 					{
 						fromId = "me",
-						content = "Lorem ipsum dolor si amet",
+						content = message,
 						sentAt = DateTime.Now
 					}
 				}
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
new file mode 100644
index 00000000..f5fa19da
--- /dev/null
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace GraphQL.Integration.Tests
+{
+	public class ObservableTester<T> : IDisposable
+	{
+		private readonly IDisposable _subscription;
+		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
+
+		/// <summary>
+		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
+		/// </summary>
+		public TimeSpan Timeout { get; set; } = TimeSpan.FromSeconds(1);
+
+		/// <summary>
+		/// Indicates that an update has been received since the last <see cref="Reset"/>
+		/// </summary>
+		public bool UpdateReceived => _updateReceived.IsSet;
+		/// <summary>
+		/// The last payload which was received.
+		/// </summary>
+		public T LastPayload { get; private set; }
+
+		/// <summary>
+		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
+		/// </summary>
+		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
+		public ObservableTester(IObservable<T> observable)
+		{
+			_subscription = observable.Subscribe(obj =>
+			{
+				LastPayload = obj;
+				_updateReceived.Set();
+			});
+		}
+
+		/// <summary>
+		/// Asserts that a new update has been pushed to the <see cref="IObservable{T}"/> within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>.
+		/// If supplied, the <paramref name="assertPayload"/> action is executed on the submitted payload.
+		/// </summary>
+		/// <param name="assertPayload">action to assert the contents of the payload</param>
+		public void ShouldHaveReceivedUpdate(Action<T> assertPayload = null)
+		{
+			try
+			{
+				if (!_updateReceived.Wait(Timeout))
+					Assert.True(false, "no update received!");
+
+				assertPayload?.Invoke(LastPayload);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that no new update has been pushed within the given <paramref name="millisecondsTimeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		/// <param name="millisecondsTimeout">the time in ms in which no new update must be pushed to the <see cref="IObservable{T}"/>. defaults to 100</param>
+		public void ShouldNotHaveReceivedUpdate(int millisecondsTimeout = 100)
+		{
+			try
+			{
+				if (_updateReceived.Wait(100))
+					Assert.True(false, "update was inadvertently pushed!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Resets the tester class. Should be called before triggering the potential update
+		/// </summary>
+		public void Reset()
+		{
+			LastPayload = default(T);
+			_updateReceived.Reset();
+		}
+
+		/// <inheritdoc />
+		public void Dispose()
+		{
+			_subscription?.Dispose();
+		}
+	}
+
+	public static class ObservableExtensions
+	{
+		public static ObservableTester<T> SubscribeTester<T>(this IObservable<T> observable)
+		{
+			return new ObservableTester<T>(observable);
+		}
+	}
+}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 155419ba..f2c2e003 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -4,65 +4,107 @@
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
+using IntegrationTestServer;
+using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Xunit;
 
 
 namespace GraphQL.Integration.Tests
 {
-	public class SubscriptionsTest: IClassFixture<WebApplicationFactory<IntegrationTestServer.Startup>>
+	public class SubscriptionsTest
 	{
+		private readonly WebApplicationFactory<Startup> _factory;
 
-		private readonly WebApplicationFactory<IntegrationTestServer.Startup> _factory;
-
-		public SubscriptionsTest(WebApplicationFactory<IntegrationTestServer.Startup> factory)
+		public static IWebHost CreateServer(int port)
 		{
-			_factory = factory;
+			var configBuilder = new ConfigurationBuilder();
+			configBuilder.AddInMemoryCollection();
+			var config = configBuilder.Build();
+			config["server.urls"] = $"http://localhost:{port}";
+
+			var host = new WebHostBuilder()
+				.ConfigureLogging((ctx, logging) => logging.AddDebug())
+				.UseConfiguration(config)
+				.UseKestrel()
+				.UseStartup<IntegrationTestServer.Startup>()
+				.Build();
+
+			host.Start();
+
+			return host;
 		}
 
-		private GraphQLHttpClient GetGraphQLClient()
-			=> _factory.CreateGraphQlHttpClient("graphql");
+		private readonly IWebHost _server;
+
+		public SubscriptionsTest()
+		{}
+
+		private GraphQLHttpClient GetGraphQLClient(int port)
+			=> new GraphQLHttpClient($"http://localhost:{port}/graphql");
 
 
 		[Fact]
 		public async void AssertTestingHarness()
 		{
-			var client = GetGraphQLClient();
-			var datetime = DateTime.Now;
+			var port = 5001;
+			using (CreateServer(port))
+			{
+				var client = GetGraphQLClient(port);
+				var datetime = DateTime.Now;
 
-			var response = await client.AddMessageAsync("Lorem ipsum dolor si amet").ConfigureAwait(false);
+				const string message = "some random testing message";
+				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
 
-			Assert.Equal("Lorem ipsum dolor si amet", (string) response.Data.addMessage.content);
+				Assert.Equal(message, (string)response.Data.addMessage.content);
+			}
 		}
 
 		[Fact]
 		public async void CanCreateObservableSubscription()
 		{
-			var client = GetGraphQLClient();
-
-			var graphQLRequest = new GraphQLRequest
-			{
-				Query = @"
-				subscription {
-				  messageAdded{
-				    content
-				  }
-				}"
-			};
-
-			Debug.WriteLine("creating subscription stream");
-			IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
-			string message = null;
-
-			await Task.Delay(1000).ConfigureAwait(false);
-
-			Debug.WriteLine("subscribing...");
-			using (observable.Subscribe(response => message = (string) response.Data.messageAdded.content, ex => throw ex))
+			var port = 5002;
+			using (CreateServer(port))
 			{
-				await Task.Delay(10000).ConfigureAwait(false);
-				Assert.Null(message);
-				var response = await client.AddMessageAsync("Lorem ipsum dolor si amet").ConfigureAwait(false);
-				Assert.Equal("Lorem ipsum dolor si amet", message);
+				var client = GetGraphQLClient(port);
+				var graphQLRequest = new GraphQLRequest
+				{
+					Query = @"
+					subscription {
+					  messageAdded{
+					    content
+					  }
+					}"
+				};
+
+				Debug.WriteLine("creating subscription stream");
+				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
+
+				Debug.WriteLine("subscribing...");
+				using (var tester = observable.SubscribeTester())
+				{
+					const string message1 = "Hello World";
+
+					var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+					Assert.Equal(message1, (string) response.Data.addMessage.content);
+
+					tester.ShouldHaveReceivedUpdate(gqlResponse =>
+					{
+						Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+					});
+
+					tester.Reset();
+
+					const string message2 = "What the ****?";
+					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);
+					});
+				}
 			}
 		}
 	}
diff --git a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
index 9998e6cf..32b32e61 100644
--- a/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
+++ b/tests/GraphQL.Integration.Tests/WebApplicationFactoryExtensions.cs
@@ -7,11 +7,11 @@ namespace GraphQL.Integration.Tests
 	public static class WebApplicationFactoryExtensions
 	{
 		public static GraphQLHttpClient CreateGraphQlHttpClient<TEntryPoint>(
-			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchema, string urlScheme = "http://") where TEntryPoint: class
+			this WebApplicationFactory<TEntryPoint> factory, string graphQlSchemaUrl, string urlScheme = "http://") where TEntryPoint: class
 		{
 			var httpClient = factory.CreateClient();
 			var uriBuilder = new UriBuilder(httpClient.BaseAddress);
-			uriBuilder.Path = graphQlSchema;
+			uriBuilder.Path = graphQlSchemaUrl;
 			uriBuilder.Scheme = urlScheme;
 			return httpClient.AsGraphQLClient(uriBuilder.Uri);
 		}
diff --git a/tests/IntegrationTestServer/Properties/launchSettings.json b/tests/IntegrationTestServer/Properties/launchSettings.json
index e6bdf925..cd6aedd6 100644
--- a/tests/IntegrationTestServer/Properties/launchSettings.json
+++ b/tests/IntegrationTestServer/Properties/launchSettings.json
@@ -1,11 +1,11 @@
 {
   "iisSettings": {
-    "windowsAuthentication": false, 
+    "windowsAuthentication": false,
     "anonymousAuthentication": true,
-		"iisExpress": {
-			"applicationUrl": "http://localhost:55069/ui/graphiql/",
-			"sslPort": 0
-		}
+    "iisExpress": {
+      "applicationUrl": "http://localhost:55069/ui/graphiql/",
+      "sslPort": 0
+    }
   },
   "profiles": {
     "IIS Express": {
@@ -15,13 +15,14 @@
         "ASPNETCORE_ENVIRONMENT": "Development"
       }
     },
-	"ImplementationTestServer": {
-		"commandName": "ImplementationTestServer",
-		"launchBrowser": true,
-		"applicationUrl": "http://localhost:5000/ui/graphiql/",
-		"environmentVariables": {
-			"ASPNETCORE_ENVIRONMENT": "Development"
-		}
-	}
+    "IntegrationTestServer": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "ui/graphiql",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:5005/"
+    }
   }
-}
+}
\ No newline at end of file
diff --git a/tests/IntegrationTestServer/Startup.cs b/tests/IntegrationTestServer/Startup.cs
index 7e86a45a..0161c739 100644
--- a/tests/IntegrationTestServer/Startup.cs
+++ b/tests/IntegrationTestServer/Startup.cs
@@ -37,8 +37,7 @@ public void ConfigureServices(IServiceCollection services)
 					options.EnableMetrics = true;
 					options.ExposeExceptions = Environment.IsDevelopment();
 				})
-				.AddWebSockets()
-				.AddDataLoader();
+				.AddWebSockets();
 
 			services.AddMvc();
 		}

From 0a4e4e68d3cb82df8503afbf535e92eb65bce9c6 Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 7 Nov 2018 08:34:46 +0100
Subject: [PATCH 5/8] make unit test politically correct

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

diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index f2c2e003..3bc9d009 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -97,7 +97,7 @@ public async void CanCreateObservableSubscription()
 
 					tester.Reset();
 
-					const string message2 = "What the ****?";
+					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 =>

From 91c11983c6494503b4e97d05059b7dfbc4a6876b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 7 Nov 2018 09:17:20 +0100
Subject: [PATCH 6/8] make sure all ClientWebSockets are disposed on disposing
 the GraphQlHttpClient

---
 src/GraphQL.Client/Http/GraphQLHttpClient.cs  | 10 +++-
 .../Http/GraphQLHttpObservableSubscription.cs | 28 ++++-----
 .../ObservableTester.cs                       | 59 +++++++++++++++++--
 .../SubscriptionsTest.cs                      | 55 +++++++++--------
 4 files changed, 103 insertions(+), 49 deletions(-)

diff --git a/src/GraphQL.Client/Http/GraphQLHttpClient.cs b/src/GraphQL.Client/Http/GraphQLHttpClient.cs
index b1a7b37b..fe8f4710 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;
+		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
 
 		/// <summary>
 		/// Initializes a new instance
@@ -143,14 +144,19 @@ private Uri _getWebSocketUri()
 		[Obsolete("EXPERIMENTAL API")]
 		public IObservable<GraphQLResponse> CreateSubscriptionStream(GraphQLRequest request)
 		{
-			return GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request);
+			var observable = GraphQLHttpObservableSubscription.GetSubscriptionStream(_getWebSocketUri(), request, _cancellationTokenSource.Token);
+			return observable;
 		}
 
 		/// <summary>
 		/// Releases unmanaged resources
 		/// </summary>
-		public void Dispose() =>
+		public void Dispose()
+		{
 			this.graphQLHttpHandler.Dispose();
+			_cancellationTokenSource.Cancel();
+			_cancellationTokenSource.Dispose();
+		}
 	}
 
 }
diff --git a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
index 78c9dfa6..d3f71990 100644
--- a/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
+++ b/src/GraphQL.Client/Http/GraphQLHttpObservableSubscription.cs
@@ -25,9 +25,11 @@ public class GraphQLHttpObservableSubscription : IDisposable {
 		private readonly GraphQLRequest graphQLRequest;
 		private readonly byte[] buffer = new byte[1024 * 1024];
 		private readonly ArraySegment<byte> arraySegment;
-		private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+		private readonly CancellationTokenSource _cancellationTokenSource;
 
-		private GraphQLHttpObservableSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest) {
+		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");
@@ -60,15 +62,7 @@ public async Task<GraphQLResponse> ReceiveResultAsync()
 					break;
 			}
 
-			try
-			{
-				return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
-			}
-			catch (Exception e)
-			{
-				Console.WriteLine(e);
-				throw;
-			}
+			return ((JObject)webSocketResponse?.Payload).ToObject<GraphQLResponse>();
 		}
 
 		public async Task CloseAsync(CancellationToken cancellationToken = default)
@@ -124,9 +118,11 @@ public void Dispose()
 		private async Task DisposeAsync()
 		{
 			Debug.WriteLine($"disposing subscription {this.GetHashCode()}...");
-			_cancellationTokenSource.Cancel();
+			if(!_cancellationTokenSource.IsCancellationRequested)
+				_cancellationTokenSource.Cancel();
 			await CloseAsync().ConfigureAwait(false);
 			clientWebSocket?.Dispose();
+			_cancellationTokenSource.Dispose();
 			Debug.WriteLine($"subscription {this.GetHashCode()} disposed");
 		}
 
@@ -134,18 +130,18 @@ private async Task DisposeAsync()
 
 		#region Static Factories
 
-		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest)
+		public static IObservable<GraphQLResponse> GetSubscriptionStream(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
 		{
 			return Observable.Using(
-				token => CreateSubscription(webSocketUri, graphQLRequest),
+				token => CreateSubscription(webSocketUri, graphQLRequest, cancellationToken),
 				InitializeSubscription
 				).Publish().RefCount();
 		}
 
 
-		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest)
+		private static Task<GraphQLHttpObservableSubscription> CreateSubscription(Uri webSocketUri, GraphQLRequest graphQLRequest, CancellationToken cancellationToken = default)
 		{
-			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest);
+			var subscription = new GraphQLHttpObservableSubscription(webSocketUri, graphQLRequest, cancellationToken);
 			return Task.FromResult(subscription);
 		}
 
diff --git a/tests/GraphQL.Integration.Tests/ObservableTester.cs b/tests/GraphQL.Integration.Tests/ObservableTester.cs
index f5fa19da..e7993a36 100644
--- a/tests/GraphQL.Integration.Tests/ObservableTester.cs
+++ b/tests/GraphQL.Integration.Tests/ObservableTester.cs
@@ -11,6 +11,8 @@ public class ObservableTester<T> : IDisposable
 	{
 		private readonly IDisposable _subscription;
 		private ManualResetEventSlim _updateReceived { get; } = new ManualResetEventSlim();
+		private ManualResetEventSlim _completed { get; } = new ManualResetEventSlim();
+		private ManualResetEventSlim _error { get; } = new ManualResetEventSlim();
 
 		/// <summary>
 		/// The timeout for <see cref="ShouldHaveReceivedUpdate"/>. Defaults to 1 s
@@ -26,17 +28,26 @@ public class ObservableTester<T> : IDisposable
 		/// </summary>
 		public T LastPayload { get; private set; }
 
+		public Exception Error { get; private set; }
+
 		/// <summary>
 		/// Creates a new <see cref="ObservableTester{T}"/> which subscribes to the supplied <see cref="IObservable{T}"/>
 		/// </summary>
 		/// <param name="observable">the <see cref="IObservable{T}"/> under test</param>
 		public ObservableTester(IObservable<T> observable)
 		{
-			_subscription = observable.Subscribe(obj =>
-			{
-				LastPayload = obj;
-				_updateReceived.Set();
-			});
+			_subscription = observable.Subscribe(
+				obj => {
+					LastPayload = obj;
+					_updateReceived.Set();
+				},
+				ex =>
+				{
+					Error = ex;
+					_error.Set();
+				},
+				() => _completed.Set()
+			);
 		}
 
 		/// <summary>
@@ -76,11 +87,49 @@ 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()
+		{
+			try
+			{
+				if (!_completed.Wait(Timeout))
+					Assert.True(false, "subscription did not complete!");
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
+		/// <summary>
+		/// Asserts that the subscription has completed within the configured <see cref="Timeout"/> since the last <see cref="Reset"/>
+		/// </summary>
+		public void ShouldHaveThrownError(Action<Exception> assertError = null)
+		{
+			try
+			{
+				if (!_error.Wait(Timeout))
+					Assert.True(false, "subscription did not throw an error!");
+
+				assertError?.Invoke(Error);
+			}
+			finally
+			{
+				Reset();
+			}
+		}
+
 		/// <summary>
 		/// Resets the tester class. Should be called before triggering the potential update
 		/// </summary>
 		public void Reset()
 		{
+			if (_completed.IsSet)
+				throw new InvalidOperationException(
+					"the subscription sequence has completed. this tester instance cannot be reused");
+
 			LastPayload = default(T);
 			_updateReceived.Reset();
 		}
diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index 3bc9d009..cb326999 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -4,9 +4,7 @@
 using GraphQL.Client.Http;
 using GraphQL.Common.Request;
 using GraphQL.Common.Response;
-using IntegrationTestServer;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.AspNetCore.Mvc.Testing;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using Xunit;
@@ -16,8 +14,6 @@ namespace GraphQL.Integration.Tests
 {
 	public class SubscriptionsTest
 	{
-		private readonly WebApplicationFactory<Startup> _factory;
-
 		public static IWebHost CreateServer(int port)
 		{
 			var configBuilder = new ConfigurationBuilder();
@@ -53,7 +49,6 @@ public async void AssertTestingHarness()
 			using (CreateServer(port))
 			{
 				var client = GetGraphQLClient(port);
-				var datetime = DateTime.Now;
 
 				const string message = "some random testing message";
 				var response = await client.AddMessageAsync(message).ConfigureAwait(false);
@@ -83,28 +78,36 @@ public async void CanCreateObservableSubscription()
 				IObservable<GraphQLResponse> observable = client.CreateSubscriptionStream(graphQLRequest);
 
 				Debug.WriteLine("subscribing...");
-				using (var tester = observable.SubscribeTester())
+				var tester = observable.SubscribeTester();
+				const string message1 = "Hello World";
+
+				var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
+				Assert.Equal(message1, (string) response.Data.addMessage.content);
+
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				tester.Reset();
+
+				const string message2 = "lorem ipsum dolor si amet";
+				response = await client.AddMessageAsync(message2).ConfigureAwait(false);
+				Assert.Equal(message2, (string)response.Data.addMessage.content);
+				tester.ShouldHaveReceivedUpdate(gqlResponse =>
+				{
+					Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
+				});
+
+				tester.Reset();
+
+				// disposing the client should thro the sequence
+				client.Dispose();
+				tester.ShouldHaveThrownError(exception =>
 				{
-					const string message1 = "Hello World";
-
-					var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
-					Assert.Equal(message1, (string) response.Data.addMessage.content);
-
-					tester.ShouldHaveReceivedUpdate(gqlResponse =>
-					{
-						Assert.Equal(message1, (string) gqlResponse.Data.messageAdded.content.Value);
-					});
-
-					tester.Reset();
-
-					const string message2 = "lorem ipsum dolor si amet";
-					response = await client.AddMessageAsync(message2).ConfigureAwait(false);
-					Assert.Equal(message2, (string)response.Data.addMessage.content);
-					tester.ShouldHaveReceivedUpdate(gqlResponse =>
-					{
-						Assert.Equal(message2, (string)gqlResponse.Data.messageAdded.content.Value);
-					});
-				}
+					Assert.True(exception is TaskCanceledException,
+							$"exception is of unexpected type {exception.GetType().Name}");
+				});
 			}
 		}
 	}

From a6fa18e3565d604dceca433e4cfe8af0296cb69b Mon Sep 17 00:00:00 2001
From: Alexander Rose <arose@haprotec.de>
Date: Wed, 7 Nov 2018 09:18:00 +0100
Subject: [PATCH 7/8] fix comment

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

diff --git a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
index cb326999..f8a66760 100644
--- a/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
+++ b/tests/GraphQL.Integration.Tests/SubscriptionsTest.cs
@@ -101,7 +101,7 @@ public async void CanCreateObservableSubscription()
 
 				tester.Reset();
 
-				// disposing the client should thro the sequence
+				// disposing the client should throw a TaskCanceledException on the subscription
 				client.Dispose();
 				tester.ShouldHaveThrownError(exception =>
 				{

From 2d3326bb62827e2daefa7de7b0230f28a2202e00 Mon Sep 17 00:00:00 2001
From: Raul Hidalgo Caballero <raul.hidalgo.sopa@gmail.com>
Date: Tue, 20 Nov 2018 21:18:14 +0100
Subject: [PATCH 8/8] Modified GraphQL.Client.csproj

---
 src/GraphQL.Client/GraphQL.Client.csproj | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/src/GraphQL.Client/GraphQL.Client.csproj b/src/GraphQL.Client/GraphQL.Client.csproj
index 0884c0a4..200758df 100644
--- a/src/GraphQL.Client/GraphQL.Client.csproj
+++ b/src/GraphQL.Client/GraphQL.Client.csproj
@@ -14,18 +14,9 @@
 
 	<ItemGroup>
 		<PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+		<PackageReference Include="System.Reactive" Version="4.1.2" />
 	</ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
-	  <PackageReference Include="System.Reactive">
-	    <Version>4.1.2</Version>
-	  </PackageReference>
-	</ItemGroup>
-
-	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-		<DefineConstants>DEBUG;TRACE</DefineConstants>
-	</PropertyGroup>
-
 	<!-- Allow method ReadAsAsync<T>
 	<ItemGroup>
 		<PackageReference Include="Microsoft.AspNet.WebApi.Client" Version="5.2.4" />