public async Task AsyncUnaryCall_AwaitMultipleTimes_SameMessageReturned()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest {
Name = "World"
});
var response1 = await call;
var response2 = await call;
var response3 = await call.ResponseAsync.DefaultTimeout();
var response4 = await call.ResponseAsync.DefaultTimeout();
// Assert
Assert.AreEqual("Hello world", response1.Message);
Assert.AreEqual(response1, response2);
Assert.AreEqual(response1, response3);
Assert.AreEqual(response1, response4);
}
public async Task AsyncUnaryCall_SendDeadlineHeaderAndDeadlineValue_DeadlineValueIsUsed()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
invoker.Clock = new TestSystemClock(new DateTime(2019, 11, 29, 1, 1, 1, DateTimeKind.Utc));
var headers = new Metadata();
headers.Add("grpc-timeout", "1D");
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(headers : headers, deadline : invoker.Clock.UtcNow.AddSeconds(1)), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual("1S", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.TimeoutHeader).Single());
}
public async Task AsyncUnaryCall_SuccessAndReadValuesAfterDeadline_ValuesReturned()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
invoker.Clock = new TestSystemClock(new DateTime(2019, 11, 29, 1, 1, 1, DateTimeKind.Utc));
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline: invoker.Clock.UtcNow.AddSeconds(0.5)), new HelloRequest());
// Assert
var result = await call;
Assert.IsNotNull(result);
// Wait for deadline to trigger
await Task.Delay(1000);
Assert.IsNotNull(await call.ResponseHeadersAsync);
Assert.IsNotNull(call.GetTrailers());
Assert.AreEqual(StatusCode.OK, call.GetStatus().StatusCode);
}
public async Task AsyncUnaryCall_Success_RequestContentSent()
{
// Arrange
HttpContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = request.Content;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest { Name = "World" });
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(content);
var requestContent = await content.ReadAsStreamAsync().DefaultTimeout();
var requestMessage = await requestContent.ReadSingleMessageAsync(TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("World", requestMessage.Name);
}
public void AsyncUnaryCall_PercentEncodedMessage_MessageDecoded()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent, grpcStatusCode: StatusCode.Aborted);
response.TrailingHeaders.Add(GrpcProtocolConstants.MessageTrailer, "%C2%A3");
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
// Assert
var ex = Assert.ThrowsAsync <RpcException>(async() => await call.ResponseAsync.DefaultTimeout());
Assert.AreEqual(StatusCode.Aborted, ex.StatusCode);
var status = call.GetStatus();
Assert.AreEqual(StatusCode.Aborted, status.StatusCode);
Assert.AreEqual("£", status.Detail);
}
public async Task AsyncUnaryCall_SendHeaders_RequestMessageContainsHeaders()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
var headers = new Metadata();
headers.Add("custom", "ascii");
headers.Add("custom-bin", Encoding.UTF8.GetBytes("Hello world"));
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(headers : headers), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual("ascii", httpRequestMessage.Headers.GetValues("custom").Single());
Assert.AreEqual("Hello world", Encoding.UTF8.GetString(Convert.FromBase64String(httpRequestMessage.Headers.GetValues("custom-bin").Single())));
}
public async Task AsyncUnaryCall_NoHeaders_RequestMessageHasNoHeaders()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
var headers = new Metadata();
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(headers : headers), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(httpRequestMessage);
// User-Agent is always sent
Assert.AreEqual(0, httpRequestMessage.Headers.Count(h => !string.Equals(h.Key, HeaderNames.UserAgent, StringComparison.OrdinalIgnoreCase)));
}
public async Task AsyncUnaryCall_DisposeAfterHeadersAndBeforeMessage_ThrowsError()
{
// Arrange
var stream = new SyncPointMemoryStream();
var httpClient = TestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream));
response.Headers.Add("custom", "value!");
return(Task.FromResult(response));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest {
Name = "World"
});
var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout();
call.Dispose();
// Assert
Assert.ThrowsAsync <ObjectDisposedException>(async() => await call.ResponseAsync.DefaultTimeout());
var header = responseHeaders.Single(h => h.Key == "custom");
Assert.AreEqual("value!", header.Value);
}
public void AsyncUnaryCall_NonOkStatusTrailer_ThrowRpcError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, new ByteArrayContent(Array.Empty <byte>()), StatusCode.Unimplemented);
return(Task.FromResult(response));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var ex = Assert.ThrowsAsync <RpcException>(async() => await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest()));
// Assert
Assert.AreEqual(StatusCode.Unimplemented, ex.StatusCode);
}
public void AsyncUnaryCall_ErrorSendingRequest_ThrowsError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(request =>
{
return(Task.FromException <HttpResponseMessage>(new Exception("An error!")));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var ex = Assert.CatchAsync <Exception>(() => call.ResponseAsync);
// Assert
Assert.AreEqual("An error!", ex.Message);
}
public void AsyncUnaryCall_UnfinishedCall_ThrowsError()
{
// Arrange
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = TestHelpers.CreateTestClient(async request =>
{
await tcs.Task.DefaultTimeout();
return(null);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Can't get the call trailers because the call is not complete.", ex.Message);
}
public void AsyncUnaryCall_ErrorCall_ThrowsError()
{
// Arrange
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var httpClient = TestHelpers.CreateTestClient(request =>
{
return(Task.FromException <HttpResponseMessage>(new Exception("An error!")));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetTrailers());
// Assert
Assert.AreEqual("Can't get the call trailers because an error occured when making the request.", ex.Message);
Assert.AreEqual("An error!", ex.InnerException.InnerException.Message);
}
public void AsyncUnaryCall_SetNonUtcDeadline_ThrowError()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var ex = Assert.ThrowsAsync <InvalidOperationException>(async() => await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline: new DateTime(2000, DateTimeKind.Local)), new HelloRequest()));
// Assert
Assert.AreEqual("Deadline must have a kind DateTimeKind.Utc or be equal to DateTime.MaxValue or DateTime.MinValue.", ex.Message);
}
public void AsyncUnaryCall_MultipleStatusHeaders_ThrowError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent, grpcStatusCode: StatusCode.Aborted);
response.TrailingHeaders.Add(GrpcProtocolConstants.MessageTrailer, "one");
response.TrailingHeaders.Add(GrpcProtocolConstants.MessageTrailer, "two");
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
// Assert
var ex = Assert.ThrowsAsync <InvalidOperationException>(async() => await call.ResponseAsync.DefaultTimeout());
Assert.AreEqual("Multiple grpc-message headers.", ex.Message);
}
public void AsyncUnaryCall_MissingStatus_ThrowError()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent, grpcStatusCode: null);
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
// Assert
Assert.ThrowsAsync <InvalidOperationException>(async() => await call.ResponseAsync.DefaultTimeout());
var ex = Assert.Throws <InvalidOperationException>(() => call.GetStatus());
Assert.AreEqual("Response did not have a grpc-status trailer.", ex.Message);
}
public async Task AsyncUnaryCall_SetMaxValueDeadline_RequestMessageHasNoDeadlineHeader()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline : DateTime.MaxValue), new HelloRequest());
// Assert
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual(0, httpRequestMessage.Headers.Count(h => string.Equals(h.Key, GrpcProtocolConstants.TimeoutHeader, StringComparison.OrdinalIgnoreCase)));
}
public async Task AsyncUnaryCall_HeadersReturned_ReturnsTrailers()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent);
response.Headers.Add("custom", "ABC");
response.TrailingHeaders.Add("custom-header", "value");
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var responseHeaders = await call.ResponseHeadersAsync.DefaultTimeout();
var trailers = call.GetTrailers();
// Assert
Assert.AreEqual("value", trailers.Single(t => t.Key == "custom-header").Value);
}
public async Task AsyncUnaryCall_Success_ResponseHeadersPopulated()
{
// Arrange
var httpClient = TestHelpers.CreateTestClient(async request =>
{
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
var response = ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent);
response.Headers.Server.Add(new ProductInfoHeaderValue("TestName", "1.0"));
response.Headers.Add("custom", "ABC");
response.Headers.Add("binary-bin", Convert.ToBase64String(Encoding.UTF8.GetBytes("Hello world")));
return(response);
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
var responseHeaders1 = await call.ResponseHeadersAsync.DefaultTimeout();
var responseHeaders2 = await call.ResponseHeadersAsync.DefaultTimeout();
// Assert
Assert.AreSame(responseHeaders1, responseHeaders2);
var header = responseHeaders1.Single(h => h.Key == "server");
Assert.AreEqual("TestName/1.0", header.Value);
header = responseHeaders1.Single(h => h.Key == "custom");
Assert.AreEqual("ABC", header.Value);
header = responseHeaders1.Single(h => h.Key == "binary-bin");
Assert.AreEqual(true, header.IsBinary);
CollectionAssert.AreEqual(Encoding.UTF8.GetBytes("Hello world"), header.ValueBytes);
}
public async Task AsyncUnaryCall_Success_HttpRequestMessagePopulated()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var rs = await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(), new HelloRequest());
// Assert
Assert.AreEqual("Hello world", rs.Message);
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual(new Version(2, 0), httpRequestMessage.Version);
Assert.AreEqual(HttpMethod.Post, httpRequestMessage.Method);
Assert.AreEqual(new Uri("https://localhost/ServiceName/MethodName"), httpRequestMessage.RequestUri);
Assert.AreEqual(new MediaTypeHeaderValue("application/grpc"), httpRequestMessage.Content.Headers.ContentType);
Assert.AreEqual(GrpcProtocolConstants.TEHeader, httpRequestMessage.Headers.TE.Single());
var userAgent = httpRequestMessage.Headers.UserAgent.Single();
Assert.AreEqual(GrpcProtocolConstants.UserAgentHeader, userAgent);
Assert.AreEqual("grpc-dotnet", userAgent.Product.Name);
Assert.IsTrue(!string.IsNullOrEmpty(userAgent.Product.Version));
}
public async Task AsyncUnaryCall_SetSecondDeadline_RequestMessageContainsDeadlineHeader()
{
// Arrange
HttpRequestMessage httpRequestMessage = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
httpRequestMessage = request;
var streamContent = await TestHelpers.CreateResponseContent(new HelloReply()).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = new HttpClientCallInvoker(httpClient);
invoker.Clock = new TestSystemClock(new DateTime(2019, 11, 29, 1, 1, 1, DateTimeKind.Utc));
// Act
await invoker.AsyncUnaryCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions(deadline : invoker.Clock.UtcNow.AddSeconds(1)), new HelloRequest());
// Assert
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual("1S", httpRequestMessage.Headers.GetValues(GrpcProtocolConstants.TimeoutHeader).Single());
}