public async Task CancelDuplexStreaming(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var cts = new CancellationTokenSource();
var call = ctx.Client.DelayedDuplexStreaming(cancellationToken: cts.Token);
cts.CancelAfter(100);
await call.RequestStream.WriteAsync(new RequestMessage { Value = 1 });
Assert.True(await call.ResponseStream.MoveNext());
Assert.Equal(1, call.ResponseStream.Current.Value);
var exception = await Assert.ThrowsAsync <RpcException>(async() => await call.ResponseStream.MoveNext());
Assert.Equal(StatusCode.Cancelled, exception.StatusCode);
}
public async Task ServerStreaming(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var call = ctx.Client.ServerStreaming(new RequestMessage {
Value = 3
});
Assert.True(await call.ResponseStream.MoveNext());
Assert.Equal(3, call.ResponseStream.Current.Value);
Assert.True(await call.ResponseStream.MoveNext());
Assert.Equal(2, call.ResponseStream.Current.Value);
Assert.True(await call.ResponseStream.MoveNext());
Assert.Equal(1, call.ResponseStream.Current.Value);
Assert.False(await call.ResponseStream.MoveNext());
}
public async Task CancelUnaryBeforeCall(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var cts = new CancellationTokenSource();
cts.Cancel();
var responseTask =
ctx.Client.SimpleUnaryAsync(new RequestMessage {
Value = 10
}, cancellationToken: cts.Token);
var exception = await Assert.ThrowsAsync <RpcException>(async() => await responseTask);
Assert.Equal(StatusCode.Cancelled, exception.StatusCode);
Assert.False(ctx.Impl.SimplyUnaryCalled);
}
public async Task CancelClientStreamingBeforeCall(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var cts = new CancellationTokenSource();
cts.Cancel();
var call = ctx.Client.ClientStreaming(cancellationToken: cts.Token);
await Assert.ThrowsAsync <TaskCanceledException>(async() =>
await call.RequestStream.WriteAsync(new RequestMessage {
Value = 1
}));
var exception = await Assert.ThrowsAsync <RpcException>(async() => await call.ResponseAsync);
Assert.Equal(StatusCode.Cancelled, exception.StatusCode);
}
public async Task ClientStreaming(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var call = ctx.Client.ClientStreaming();
await call.RequestStream.WriteAsync(new RequestMessage { Value = 3 });
await call.RequestStream.WriteAsync(new RequestMessage { Value = 2 });
await call.RequestStream.WriteAsync(new RequestMessage { Value = 1 });
await call.RequestStream.CompleteAsync();
var response = await call.ResponseAsync;
Assert.Equal(6, response.Value);
}
public async Task ClientStreamWriteAfterCompletion(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var call = ctx.Client.ClientStreaming();
await call.RequestStream.WriteAsync(new RequestMessage { Value = 1 });
await call.RequestStream.CompleteAsync();
void WriteAction() => call.RequestStream.WriteAsync(new RequestMessage {
Value = 1
});
var exception = Assert.Throws <InvalidOperationException>(WriteAction);
Assert.Equal("Request stream has already been completed.", exception.Message);
}
public async Task ServerStreamWriteAfterCompletion(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var call = ctx.Client.ServerStreaming(new RequestMessage {
Value = 1
});
Assert.True(await call.ResponseStream.MoveNext());
Assert.False(await call.ResponseStream.MoveNext());
void WriteAction() => ctx.Impl.ServerStream.WriteAsync(new ResponseMessage {
Value = 1
});
var exception = Assert.Throws <InvalidOperationException>(WriteAction);
Assert.Equal("Response stream has already been completed.", exception.Message);
}
public async Task HeadersAndTrailers(ChannelContextFactory factory)
{
using var ctx = factory.Create();
var requestHeaders = new Metadata
{
{ "A1", "1" },
{ "A2-bin", new[] { (byte)2 } },
};
var responseHeaders = new Metadata
{
{ "B1", "1" },
{ "B2-bin", new[] { (byte)2 } },
};
var responseTrailers = new Metadata
{
{ "C1", "1" },
{ "C2-bin", new[] { (byte)2 } },
};
ctx.Impl.ResponseHeaders = responseHeaders;
ctx.Impl.ResponseTrailers = responseTrailers;
var call = ctx.Client.HeadersTrailersAsync(new RequestMessage {
Value = 1
}, requestHeaders);
var actualResponseHeaders = await call.ResponseHeadersAsync;
await call.ResponseAsync;
var actualResponseTrailers = call.GetTrailers();
var actualStatus = call.GetStatus();
var actualRequestHeaders = ctx.Impl.RequestHeaders;
AssertHasMetadata(requestHeaders, actualRequestHeaders);
AssertHasMetadata(responseHeaders, actualResponseHeaders);
AssertHasMetadata(responseTrailers, actualResponseTrailers);
Assert.Equal(StatusCode.OK, actualStatus.StatusCode);
}
public ChannelsService()
{
this._channelContextFactory = new ChannelContextFactory();
}
