public async void PreprocessHttpRequestMessageIsCalled()
{
var callbackTester = new CallbackMonitor <HttpRequestMessage>();
var graphQLRequest = new GraphQLHttpRequest($"{{ human(id: \"1\") {{ name }} }}")
{
PreprocessHttpRequestMessage = callbackTester.Invoke
};
var defaultHeaders = StarWarsClient.HttpClient.DefaultRequestHeaders;
var response = await StarWarsClient.SendQueryAsync(graphQLRequest, () => new { Human = new { Name = string.Empty } });
callbackTester.Should().HaveBeenInvokedWithPayload().Which.Headers.Should().BeEquivalentTo(defaultHeaders);
Assert.Null(response.Errors);
Assert.Equal("Luke", response.Data.Human.Name);
}
public async void CanHandleConnectionTimeout()
{
var errorMonitor = new CallbackMonitor <Exception>();
var reconnectBlocker = new ManualResetEventSlim(false);
var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
// configure back-off strategy to allow it to be controlled from within the unit test
ChatClient.Options.BackOffStrategy = i =>
{
Debug.WriteLine("back-off strategy: waiting on reconnect blocker");
reconnectBlocker.Wait();
Debug.WriteLine("back-off strategy: reconnecting...");
return(TimeSpan.Zero);
};
var websocketStates = new ConcurrentQueue <GraphQLWebsocketConnectionState>();
using (ChatClient.WebsocketConnectionState.Subscribe(websocketStates.Enqueue))
{
websocketStates.Should().ContainSingle(state => state == GraphQLWebsocketConnectionState.Disconnected);
Debug.WriteLine($"Test method thread id: {Thread.CurrentThread.ManagedThreadId}");
Debug.WriteLine("creating subscription stream");
var observable = ChatClient.CreateSubscriptionStream <MessageAddedSubscriptionResult>(_subscriptionRequest, errorMonitor.Invoke);
Debug.WriteLine("subscribing...");
var observer = observable.Observe();
callbackMonitor.Should().HaveBeenInvokedWithPayload();
websocketStates.Should().ContainInOrder(
GraphQLWebsocketConnectionState.Disconnected,
GraphQLWebsocketConnectionState.Connecting,
GraphQLWebsocketConnectionState.Connected);
// clear the collection so the next tests on the collection work as expected
websocketStates.Clear();
await observer.Should().PushAsync(1);
observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
const string message1 = "Hello World";
var response = await ChatClient.AddMessageAsync(message1);
response.Data.AddMessage.Content.Should().Be(message1);
await observer.Should().PushAsync(2);
observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);
Debug.WriteLine("stopping web host...");
await Fixture.ShutdownServer();
Debug.WriteLine("web host stopped");
errorMonitor.Should().HaveBeenInvokedWithPayload(10.Seconds())
.Which.Should().BeOfType <WebSocketException>();
websocketStates.Should().Contain(GraphQLWebsocketConnectionState.Disconnected);
Debug.WriteLine("restarting web host...");
await InitializeAsync();
Debug.WriteLine("web host started");
reconnectBlocker.Set();
callbackMonitor.Should().HaveBeenInvokedWithPayload(3.Seconds());
await observer.Should().PushAsync(3);
observer.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);
websocketStates.Should().ContainInOrder(
GraphQLWebsocketConnectionState.Disconnected,
GraphQLWebsocketConnectionState.Connecting,
GraphQLWebsocketConnectionState.Connected);
// disposing the client should complete the subscription
ChatClient.Dispose();
await observer.Should().CompleteAsync(5.Seconds());
}
}
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();
}
}
