public async Task Handle_InitializeMessage_Accepted()
{
// arrange
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(
new SocketSessionInterceptorMock());
var message = new InitializeConnectionMessage();
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
AcceptConnectionMessage.Default.Serialize()));
},
t =>
{
Assert.True(t.SequenceEqual(
KeepConnectionAliveMessage.Default.Serialize()));
});
}
public async Task Handle_InitializeMessage_Rejected()
{
// arrange
var interceptor = new Mock <IConnectMessageInterceptor>();
interceptor.Setup(t => t.OnReceiveAsync(
It.IsAny <ISocketConnection>(),
It.IsAny <InitializeConnectionMessage>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(ConnectionStatus.Reject());
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(
interceptor.Object);
var message = new InitializeConnectionMessage(null);
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new RejectConnectionMessage(
ConnectionStatus.Reject().Message)
.Serialize()));
});
}
public async Task Handle_InitializeMessage_Rejected_With_Extensions()
{
// arrange
var connectionStatus = ConnectionStatus.Reject(
"Foo",
new Dictionary <string, object> {
{ "bar", "baz" }
});
var interceptor = new SocketSessionInterceptorMock(connectionStatus);
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(interceptor);
var message = new InitializeConnectionMessage();
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new RejectConnectionMessage(
connectionStatus.Message,
connectionStatus.Extensions)
.Serialize()));
});
Assert.True(connection.Closed);
}
public async Task Handle_Stop_Subscription()
{
// arrange
var connection = new SocketConnectionMock();
IRequestExecutor executor = await new ServiceCollection()
.AddGraphQL()
.AddStarWarsTypes()
.AddStarWarsRepositories()
.AddInMemorySubscriptions()
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync();
var stream =
(IResponseStream)await executor.ExecuteAsync(
"subscription { onReview(episode: NEW_HOPE) { stars } }");
var subscription = new Subscription(connection, stream, "123");
connection.Subscriptions.Register(subscription);
var handler = new DataStopMessageHandler();
var message = new DataStopMessage("123");
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Empty(connection.Subscriptions);
}
public async Task Handle_Query_With_Inter_DataReceived_And_Completed()
{
// arrange
var interceptor = new Mock <ISocketQueryRequestInterceptor>();
interceptor.Setup(t => t.OnCreateAsync(
It.IsAny <ISocketConnection>(),
It.IsAny <IQueryRequestBuilder>(),
It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
var connection = new SocketConnectionMock();
IQueryExecutor executor = SchemaBuilder.New()
.AddStarWarsTypes()
.Create()
.MakeExecutable();
DocumentNode query = Utf8GraphQLParser.Parse("{ hero { name } }");
var handler = new DataStartMessageHandler(
executor,
new List <ISocketQueryRequestInterceptor> {
interceptor.Object
});
var message = new DataStartMessage(
"123",
new GraphQLRequest(query));
var result = (IReadOnlyQueryResult)await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(query)
.Create());
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new DataResultMessage(message.Id, result).Serialize()));
},
t =>
{
Assert.True(t.SequenceEqual(
new DataCompleteMessage(message.Id).Serialize()));
});
}
public async Task Handle_Query_With_Inter_DataReceived_And_Completed()
{
// arrange
var errorHandler = new Mock <IErrorHandler>();
IServiceProvider services = new ServiceCollection()
.AddGraphQL()
.AddStarWarsTypes()
.AddStarWarsRepositories()
.AddInMemorySubscriptions()
.Services
.BuildServiceProvider();
IRequestExecutor executor = await services
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync();
var interceptor = new SocketSessionInterceptorMock();
var connection = new SocketConnectionMock {
RequestServices = services
};
DocumentNode query = Utf8GraphQLParser.Parse("{ hero { name } }");
var handler = new DataStartMessageHandler(
executor,
interceptor,
errorHandler.Object,
new NoopExecutionDiagnosticEvents());
var message = new DataStartMessage("123", new GraphQLRequest(query));
var result = (IReadOnlyQueryResult)await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(query)
.SetServices(services)
.Create());
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new DataResultMessage(message.Id, result).Serialize()));
},
t =>
{
Assert.True(t.SequenceEqual(
new DataCompleteMessage(message.Id).Serialize()));
});
}
public void Register_Subscription_SubscriptionIsNull()
{
// arrange
var connection = new SocketConnectionMock();
var subscriptions = new SubscriptionManager(connection);
var subscription = new SubscriptionSessionMock();
// act
Action action = () => subscriptions.Register(null);
// assert
Assert.Throws <ArgumentNullException>(action);
}
public void Register_Subscription()
{
// arrange
var connection = new SocketConnectionMock();
var subscriptions = new SubscriptionManager(connection);
var subscription = new SubscriptionSessionMock();
// act
subscriptions.Register(subscription);
// assert
Assert.Collection(subscriptions,
t => Assert.Equal(subscription, t));
}
public void Unregister_Subscription_SubscriptionIdIsNull()
{
// arrange
var connection = new SocketConnectionMock();
var subscriptions = new SubscriptionManager(connection);
var subscription = new SubscriptionSessionMock();
subscriptions.Register(subscription);
Assert.Collection(subscriptions,
t => Assert.Equal(subscription, t));
// act
Action action = () => subscriptions.Unregister(null);
// assert
Assert.Throws <ArgumentNullException>(action);
}
public void Unregister_Subscription_ManagerAlreadyDisposed()
{
// arrange
var connection = new SocketConnectionMock();
var subscriptions = new SubscriptionManager(connection);
var subscription = new SubscriptionSessionMock {
Id = "abc"
};
subscriptions.Register(subscription);
subscriptions.Dispose();
// act
Action action = () => subscriptions.Unregister("abc");
// assert
Assert.Throws <ObjectDisposedException>(action);
}
public async Task Handle_TerminateMessage_ConnectionClosed()
{
// arrange
var connection = new SocketConnectionMock {
Closed = false
};
var handler = new TerminateConnectionMessageHandler();
var message = new TerminateConnectionMessage();
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.True(connection.Closed);
}
public void Dispose_Subscriptions()
{
// arrange
var connection = new SocketConnectionMock();
var subscriptions = new SubscriptionManager(connection);
var subscription_a = new SubscriptionSessionMock();
var subscription_b = new SubscriptionSessionMock();
subscriptions.Register(subscription_a);
subscriptions.Register(subscription_b);
// act
subscriptions.Dispose();
// assert
Assert.Empty(subscriptions);
Assert.True(subscription_a.IsDisposed);
Assert.True(subscription_a.IsDisposed);
}
public async Task Handle_InitializeMessage_Rejected_With_Extensions()
{
// arrange
var connectionStatus = ConnectionStatus.Reject(
"Foo",
new Dictionary <string, object> {
{ "bar", "baz" }
});
var interceptor = new Mock <IConnectMessageInterceptor>();
interceptor.Setup(t => t.OnReceiveAsync(
It.IsAny <ISocketConnection>(),
It.IsAny <InitializeConnectionMessage>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(connectionStatus);
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(
interceptor.Object);
var message = new InitializeConnectionMessage(null);
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new RejectConnectionMessage(
connectionStatus.Message,
connectionStatus.Extensions)
.Serialize()));
});
Assert.True(connection.Closed);
}
public async Task Handle_Stop_Subscription()
{
// arrange
var connection = new SocketConnectionMock();
var services = new ServiceCollection();
services.AddInMemorySubscriptionProvider();
services.AddStarWarsRepositories();
IQueryExecutor executor = SchemaBuilder.New()
.AddServices(services.BuildServiceProvider())
.AddStarWarsTypes()
.Create()
.MakeExecutable();
DocumentNode query = Utf8GraphQLParser.Parse(
"subscription { onReview(episode: NEWHOPE) { stars } }");
IResponseStream stream =
(IResponseStream)await executor.ExecuteAsync(
"subscription { onReview(episode: NEWHOPE) { stars } }");
var subscription = new Subscription(connection, stream, "123");
connection.Subscriptions.Register(subscription);
var handler = new DataStopMessageHandler();
var message = new DataStopMessage("123");
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Empty(connection.Subscriptions);
}
public async Task Handle_InitializeMessage_Rejected()
{
// arrange
var interceptor = new SocketSessionInterceptorMock(ConnectionStatus.Reject());
var connection = new SocketConnectionMock();
var handler = new InitializeConnectionMessageHandler(interceptor);
var message = new InitializeConnectionMessage();
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new RejectConnectionMessage(
ConnectionStatus.Reject().Message)
.Serialize()));
});
}
public async Task Handle_Subscription_DataReceived_And_Completed()
{
// arrange
var errorHandler = new Mock <IErrorHandler>();
IServiceProvider services = new ServiceCollection()
.AddGraphQL()
.AddStarWarsTypes()
.AddStarWarsRepositories()
.AddInMemorySubscriptions()
.Services
.BuildServiceProvider();
IRequestExecutor executor = await services
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync();
var interceptor = new SocketSessionInterceptorMock();
var connection = new SocketConnectionMock {
RequestServices = services
};
DocumentNode query = Utf8GraphQLParser.Parse(
"subscription { onReview(episode: NEW_HOPE) { stars } }");
var handler = new DataStartMessageHandler(
executor,
interceptor,
errorHandler.Object,
new NoopExecutionDiagnosticEvents());
var message = new DataStartMessage("123", new GraphQLRequest(query));
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Empty(connection.SentMessages);
Assert.NotEmpty(connection.Subscriptions);
var stream =
(IResponseStream)await executor.ExecuteAsync(
"subscription { onReview(episode: NEW_HOPE) { stars } }");
await executor.ExecuteAsync(@"
mutation {
createReview(episode:NEW_HOPE review:
{
commentary: ""foo""
stars: 5
}) {
stars
}
}");
using var cts = new CancellationTokenSource(15000);
ConfiguredCancelableAsyncEnumerable <IQueryResult> .Enumerator enumerator =
stream.ReadResultsAsync().WithCancellation(cts.Token).GetAsyncEnumerator();
Assert.True(await enumerator.MoveNextAsync());
await Task.Delay(2000, cts.Token);
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new DataResultMessage(message.Id, enumerator.Current).Serialize()));
});
}
public async Task Handle_Subscription_DataReceived_And_Completed()
{
// arrange
var connection = new SocketConnectionMock();
var services = new ServiceCollection();
services.AddInMemorySubscriptionProvider();
services.AddStarWarsRepositories();
IQueryExecutor executor = SchemaBuilder.New()
.AddServices(services.BuildServiceProvider())
.AddStarWarsTypes()
.Create()
.MakeExecutable();
DocumentNode query = Utf8GraphQLParser.Parse(
"subscription { onReview(episode: NEWHOPE) { stars } }");
var handler = new DataStartMessageHandler(executor, null);
var message = new DataStartMessage(
"123",
new GraphQLRequest(query));
// act
await handler.HandleAsync(
connection,
message,
CancellationToken.None);
// assert
Assert.Empty(connection.SentMessages);
Assert.NotEmpty(connection.Subscriptions);
IResponseStream stream =
(IResponseStream)await executor.ExecuteAsync(
"subscription { onReview(episode: NEWHOPE) { stars } }");
await executor.ExecuteAsync(@"
mutation {
createReview(episode:NEWHOPE review:
{
commentary: ""foo""
stars: 5
}) {
stars
}
}");
IReadOnlyQueryResult result = await stream.ReadAsync();
await Task.Delay(2000);
Assert.Collection(connection.SentMessages,
t =>
{
Assert.True(t.SequenceEqual(
new DataResultMessage(message.Id, result).Serialize()));
});
}
