public async Task ClientStreamingCall_CancelAfterBegin()
{
var barrier = new TaskCompletionSource <object>();
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
barrier.SetResult(null);
await requestStream.ToListAsync();
return("");
});
var cts = new CancellationTokenSource();
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(cancellationToken: cts.Token)));
await barrier.Task; // make sure the handler has started.
cts.Cancel();
try
{
// cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock.
await call.ResponseAsync;
Assert.Fail();
}
catch (RpcException ex)
{
Assert.AreEqual(StatusCode.Cancelled, ex.Status.StatusCode);
}
}
public async Task ClientStreamingCall()
{
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
string result = "";
await requestStream.ForEachAsync((request) =>
{
result += request;
return(TaskUtils.CompletedTask);
});
await Task.Delay(100);
return(result);
});
{
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall());
await call.RequestStream.WriteAllAsync(new string[] { "A", "B", "C" });
Assert.AreEqual("ABC", await call);
Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode);
Assert.IsNotNull(call.GetTrailers());
}
{
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall());
await call.RequestStream.WriteAllAsync(new string[] { "A", "B", "C" });
Assert.AreEqual("ABC", await call.ConfigureAwait(false));
Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode);
Assert.IsNotNull(call.GetTrailers());
}
}
public async Task RequestParsingError_StreamingRequest()
{
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
Assert.Throws <IOException>(async() => await requestStream.MoveNext());
return("RESPONSE");
});
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall());
await call.RequestStream.WriteAsync("UNPARSEABLE_VALUE");
Assert.AreEqual("RESPONSE", await call);
}
public async Task PropagateCancellation()
{
var readyToCancelTcs = new TaskCompletionSource <object>();
var successTcs = new TaskCompletionSource <string>();
helper.UnaryHandler = new UnaryServerMethod <string, string>(async(request, context) =>
{
readyToCancelTcs.SetResult(null); // child call running, ready to parent call
while (!context.CancellationToken.IsCancellationRequested)
{
await Task.Delay(10);
}
successTcs.SetResult("CHILD_CALL_CANCELLED");
return("");
});
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
var propagationToken = context.CreatePropagationToken();
Assert.IsNotNull(propagationToken.ParentCall);
var callOptions = new CallOptions(propagationToken: propagationToken);
try
{
await Calls.AsyncUnaryCall(helper.CreateUnaryCall(callOptions), "xyz");
}
catch (RpcException)
{
// Child call will get cancelled, eat the exception.
}
return("");
});
var cts = new CancellationTokenSource();
var parentCall = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(cancellationToken: cts.Token)));
await readyToCancelTcs.Task;
cts.Cancel();
try
{
// cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock.
await parentCall;
Assert.Fail();
}
catch (RpcException)
{
}
Assert.AreEqual("CHILD_CALL_CANCELLED", await successTcs.Task);
}
public async Task ClientStreamingCall()
{
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
string result = "";
await requestStream.ForEachAsync(async(request) =>
{
result += request;
});
await Task.Delay(100);
return(result);
});
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall());
await call.RequestStream.WriteAllAsync(new string[] { "A", "B", "C" });
Assert.AreEqual("ABC", await call.ResponseAsync);
}
public async Task RequestParsingError_StreamingRequest()
{
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
try
{
// cannot use Assert.ThrowsAsync because it uses Task.Wait and would deadlock.
await requestStream.MoveNext();
Assert.Fail();
}
catch (IOException)
{
}
return("RESPONSE");
});
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall());
await call.RequestStream.WriteAsync("UNPARSEABLE_VALUE");
Assert.AreEqual("RESPONSE", await call);
}
public async Task PropagateCancellation()
{
helper.UnaryHandler = new UnaryServerMethod <string, string>(async(request, context) =>
{
// check that we didn't obtain the default cancellation token.
Assert.IsTrue(context.CancellationToken.CanBeCanceled);
return("PASS");
});
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
var propagationToken = context.CreatePropagationToken();
Assert.IsNotNull(propagationToken.ParentCall);
var callOptions = new CallOptions(propagationToken: propagationToken);
return(await Calls.AsyncUnaryCall(helper.CreateUnaryCall(callOptions), "xyz"));
});
var cts = new CancellationTokenSource();
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall(new CallOptions(cancellationToken: cts.Token)));
await call.RequestStream.CompleteAsync();
Assert.AreEqual("PASS", await call);
}
public async Task ResponseHeadersAsync_ClientStreamingCall()
{
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
await context.WriteResponseHeadersAsync(headers);
return("PASS");
});
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall());
await call.RequestStream.CompleteAsync();
var responseHeaders = await call.ResponseHeadersAsync;
Assert.AreEqual("ascii-header", responseHeaders[0].Key);
Assert.AreEqual("PASS", await call.ResponseAsync);
}
public async Task HalfcloseAfterFullclose_ClientStreamingCall()
{
helper.ClientStreamingHandler = new ClientStreamingServerMethod <string, string>(async(requestStream, context) =>
{
return("PASS");
});
var call = Calls.AsyncClientStreamingCall(helper.CreateClientStreamingCall());
// make sure server has fullclosed on us
Assert.AreEqual("PASS", await call.ResponseAsync);
// sending close from client should be still fine because server can finish
// the call anytime and we cannot do anything about it on the client side.
await call.RequestStream.CompleteAsync();
// Second attempt to close from client is not allowed.
Assert.ThrowsAsync(typeof(InvalidOperationException), async() => await call.RequestStream.CompleteAsync());
}