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