public async void CanHandleQueryErrorInSubscription()
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
using (CreateServer(port)) {
var test = new GraphQLRequest("tset", new { test = "blaa" });
var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
await client.InitializeWebsocketConnection();
callbackMonitor.Should().HaveBeenInvokedWithPayload();
Debug.WriteLine("creating subscription stream");
IObservable <GraphQLResponse <object> > observable = client.CreateSubscriptionStream <object>(
new GraphQLRequest(@"
subscription {
fieldDoesNotExist {
content
}
}" )
);
Debug.WriteLine("subscribing...");
using (var tester = observable.Monitor()) {
tester.Should().HaveReceivedPayload()
.Which.Errors.Should().ContainSingle();
tester.Should().HaveCompleted();
client.Dispose();
}
}
}
public static TestServerSetup SetupTest <TStartup>(bool requestsViaWebsocket = false, IGraphQLWebsocketJsonSerializer serializer = null)
where TStartup : class
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
return(new TestServerSetup {
Server = CreateServer <TStartup>(port),
Client = GetGraphQLClient(port, requestsViaWebsocket, serializer)
});
}
public async void CanHandleRequestErrorViaWebsocket()
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
using (CreateServer(port)) {
var client = WebHostHelpers.GetGraphQLClient(port, true, Serializer);
var response = await client.SendQueryAsync <object>("this query is formatted quite badly").ConfigureAwait(false);
Assert.Single(response.Errors);
}
}
public async void CanSendRequestViaWebsocket()
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
using (CreateServer(port)) {
var client = WebHostHelpers.GetGraphQLClient(port, true, Serializer);
const string message = "some random testing message";
var response = await client.AddMessageAsync(message).ConfigureAwait(false);
Assert.Equal(message, response.Data.AddMessage.Content);
}
}
public async void CanConnectTwoSubscriptionsSimultaneously()
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
var callbackTester = new CallbackMonitor <Exception>();
var callbackTester2 = new CallbackMonitor <Exception>();
using (CreateServer(port)) {
var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
await client.InitializeWebsocketConnection();
callbackMonitor.Should().HaveBeenInvokedWithPayload();
Debug.WriteLine("creating subscription stream");
IObservable <GraphQLResponse <MessageAddedSubscriptionResult> > observable1 =
client.CreateSubscriptionStream <MessageAddedSubscriptionResult>(SubscriptionRequest, callbackTester.Invoke);
IObservable <GraphQLResponse <UserJoinedSubscriptionResult> > observable2 =
client.CreateSubscriptionStream <UserJoinedSubscriptionResult>(SubscriptionRequest2, callbackTester2.Invoke);
Debug.WriteLine("subscribing...");
var tester = observable1.Monitor();
var tester2 = observable2.Monitor();
const string message1 = "Hello World";
var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
response.Data.AddMessage.Content.Should().Be(message1);
tester.Should().HaveReceivedPayload()
.Which.Data.MessageAdded.Content.Should().Be(message1);
var joinResponse = await client.JoinDeveloperUser().ConfigureAwait(false);
joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
var payload = tester2.Should().HaveReceivedPayload().Subject;
payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
Debug.WriteLine("disposing subscription...");
tester2.Dispose();
const string message3 = "lorem ipsum dolor si amet";
response = await client.AddMessageAsync(message3).ConfigureAwait(false);
response.Data.AddMessage.Content.Should().Be(message3);
tester.Should().HaveReceivedPayload()
.Which.Data.MessageAdded.Content.Should().Be(message3);
// disposing the client should complete the subscription
client.Dispose();
tester.Should().HaveCompleted();
}
}
public async void CanReconnectWithSameObservable()
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
using (CreateServer(port)) {
var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
Debug.WriteLine("creating subscription stream");
var observable = client.CreateSubscriptionStream <MessageAddedSubscriptionResult>(SubscriptionRequest);
Debug.WriteLine("subscribing...");
var tester = observable.Monitor();
callbackMonitor.Should().HaveBeenInvokedWithPayload();
const string message1 = "Hello World";
var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
response.Data.AddMessage.Content.Should().Be(message1);
tester.Should().HaveReceivedPayload()
.Which.Data.MessageAdded.Content.Should().Be(message1);
const string message2 = "How are you?";
response = await client.AddMessageAsync(message2).ConfigureAwait(false);
response.Data.AddMessage.Content.Should().Be(message2);
tester.Should().HaveReceivedPayload()
.Which.Data.MessageAdded.Content.Should().Be(message2);
Debug.WriteLine("disposing subscription...");
tester.Dispose(); // does not close the websocket connection
Debug.WriteLine("creating new subscription...");
tester = observable.Monitor();
tester.Should().HaveReceivedPayload(TimeSpan.FromSeconds(10))
.Which.Data.MessageAdded.Content.Should().Be(message2);
const string message3 = "lorem ipsum dolor si amet";
response = await client.AddMessageAsync(message3).ConfigureAwait(false);
response.Data.AddMessage.Content.Should().Be(message3);
tester.Should().HaveReceivedPayload()
.Which.Data.MessageAdded.Content.Should().Be(message3);
// disposing the client should complete the subscription
client.Dispose();
tester.Should().HaveCompleted();
}
}
public TestServerSetup(IGraphQLWebsocketJsonSerializer serializer)
{
Serializer = serializer;
Port = NetworkHelpers.GetFreeTcpPortNumber();
}
public async void CanConnectTwoSubscriptionsSimultaneously()
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
var callbackTester = new CallbackMonitor <Exception>();
var callbackTester2 = new CallbackMonitor <Exception>();
var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
await ChatClient.InitializeWebsocketConnection();
callbackMonitor.Should().HaveBeenInvokedWithPayload();
Debug.WriteLine("creating subscription stream");
var observable1 = ChatClient.CreateSubscriptionStream <MessageAddedSubscriptionResult>(_subscriptionRequest, callbackTester.Invoke);
var observable2 = ChatClient.CreateSubscriptionStream <UserJoinedSubscriptionResult>(_subscriptionRequest2, callbackTester2.Invoke);
Debug.WriteLine("subscribing...");
var blocker = new ManualResetEventSlim(false);
FluentTestObserver <GraphQLResponse <MessageAddedSubscriptionResult> > messagesMonitor = null;
FluentTestObserver <GraphQLResponse <UserJoinedSubscriptionResult> > joinedMonitor = null;
var tasks = new List <Task>
{
Task.Run(() =>
{
blocker.Wait();
messagesMonitor = observable1.Observe();
}),
Task.Run(() =>
{
blocker.Wait();
joinedMonitor = observable2.Observe();
})
};
blocker.Set();
await Task.WhenAll(tasks);
await messagesMonitor.Should().PushAsync(1);
messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
const string message1 = "Hello World";
var response = await ChatClient.AddMessageAsync(message1);
response.Data.AddMessage.Content.Should().Be(message1);
await messagesMonitor.Should().PushAsync(2);
messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
joinedMonitor.Should().NotPush();
messagesMonitor.Clear();
joinedMonitor.Clear();
var joinResponse = await ChatClient.JoinDeveloperUser();
joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
var payload = await joinedMonitor.Should().PushAsync().GetLastMessageAsync();
using (new AssertionScope())
{
payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
}
messagesMonitor.Should().NotPush();
messagesMonitor.Clear();
joinedMonitor.Clear();
Debug.WriteLine("disposing subscription...");
joinedMonitor.Dispose();
const string message3 = "lorem ipsum dolor si amet";
response = await ChatClient.AddMessageAsync(message3);
response.Data.AddMessage.Content.Should().Be(message3);
var msg = await messagesMonitor.Should().PushAsync().GetLastMessageAsync();
msg.Data.MessageAdded.Content.Should().Be(message3);
// disposing the client should complete the subscription
ChatClient.Dispose();
await messagesMonitor.Should().CompleteAsync();
}
public IntegrationServerTestFixture()
{
Port = NetworkHelpers.GetFreeTcpPortNumber();
}
public async void CanHandleConnectionTimeout()
{
var port = NetworkHelpers.GetFreeTcpPortNumber();
var server = CreateServer(port);
var errorMonitor = new CallbackMonitor <Exception>();
var reconnectBlocker = new ManualResetEventSlim(false);
var client = WebHostHelpers.GetGraphQLClient(port, serializer: Serializer);
var callbackMonitor = client.ConfigureMonitorForOnWebsocketConnected();
// configure back-off strategy to allow it to be controlled from within the unit test
client.Options.BackOffStrategy = i => {
reconnectBlocker.Wait();
return(TimeSpan.Zero);
};
var websocketStates = new ConcurrentQueue <GraphQLWebsocketConnectionState>();
using (client.WebsocketConnectionState.Subscribe(websocketStates.Enqueue)) {
websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
Debug.WriteLine("creating subscription stream");
IObservable <GraphQLResponse <MessageAddedSubscriptionResult> > observable =
client.CreateSubscriptionStream <MessageAddedSubscriptionResult>(SubscriptionRequest,
errorMonitor.Invoke);
Debug.WriteLine("subscribing...");
var tester = observable.Monitor();
callbackMonitor.Should().HaveBeenInvokedWithPayload();
websocketStates.Should().ContainInOrder(
GraphQLWebsocketConnectionState.Disconnected,
GraphQLWebsocketConnectionState.Connecting,
GraphQLWebsocketConnectionState.Connected);
// clear the collection so the next tests on the collection work as expected
websocketStates.Clear();
const string message1 = "Hello World";
var response = await client.AddMessageAsync(message1).ConfigureAwait(false);
response.Data.AddMessage.Content.Should().Be(message1);
tester.Should().HaveReceivedPayload()
.Which.Data.MessageAdded.Content.Should().Be(message1);
Debug.WriteLine("stopping web host...");
await server.StopAsync(CancellationToken.None).ConfigureAwait(false);
server.Dispose();
Debug.WriteLine("web host stopped...");
errorMonitor.Should().HaveBeenInvokedWithPayload(TimeSpan.FromSeconds(10))
.Which.Should().BeOfType <WebSocketException>();
websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
server = CreateServer(port);
reconnectBlocker.Set();
callbackMonitor.Should().HaveBeenInvokedWithPayload();
websocketStates.Should().ContainInOrder(
GraphQLWebsocketConnectionState.Disconnected,
GraphQLWebsocketConnectionState.Connecting,
GraphQLWebsocketConnectionState.Connected);
// disposing the client should complete the subscription
client.Dispose();
tester.Should().HaveCompleted(TimeSpan.FromSeconds(5));
server.Dispose();
}
}