public async Task Read_File_Chunks_Success()
{
// This tests reading file chunks and pushing them to the output stream
// Arrange
var moqFilesRepo = new Mock <IFilesRepository>();
var moqConfigRepo = new Mock <IConfigRepository>();
int fileChunkSize = 125;
var contentString = GetRandomString(125);
// set the size of the content to force two loops to retrieve total of 250 bytes
byte[] fileStreamContent = Encoding.UTF8.GetBytes(contentString + contentString);
var file = new File
{
FileId = new Guid("22222222-2222-2222-2222-222222222222"),
FileName = "Test2.txt",
StoredTime = I18NHelper.DateTimeParseExactInvariant("2015-09-05T22:57:31.7824054-04:00", "o"),
FileType = "application/octet-stream",
FileSize = fileStreamContent.Length,
ChunkCount = 2
};
var moqDbConnection = new Mock <DbConnection>();
moqFilesRepo.Setup(t => t.CreateConnection()).Returns(moqDbConnection.Object);
moqFilesRepo.Setup(t => t.GetFileHead(It.IsAny <Guid>())).ReturnsAsync(file);
moqFilesRepo.Setup(t => t.ReadChunkContent(moqDbConnection.Object, It.IsAny <Guid>(), It.IsAny <int>())).Returns(fileStreamContent.Take <byte>(125).ToArray <byte>());
moqConfigRepo.Setup(t => t.LegacyFileChunkSize).Returns(fileChunkSize);
moqFilesRepo.Setup(t => t.GetFileInfo(It.IsAny <Guid>())).Returns(file);
// Act
SqlPushStream sqlPushStream = new SqlPushStream();
sqlPushStream.Initialize(moqFilesRepo.Object, file.FileId);
HttpContent responseContent = new PushStreamContent(sqlPushStream.WriteToStream, new MediaTypeHeaderValue(file.ContentType));
Stream response = await responseContent.ReadAsStreamAsync();
string originalContent = Encoding.UTF8.GetString(fileStreamContent);
string resultContent = string.Empty;
using (var memoryStream = new MemoryStream())
{
response.CopyTo(memoryStream);
resultContent = Encoding.UTF8.GetString(memoryStream.ToArray());
}
// Assert
Assert.IsTrue(originalContent.Equals(resultContent));
}
public async Task AsyncClientStreamingCall_Success_RequestContentSent()
{
// Arrange
PushStreamContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await TestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(httpClient);
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
// Assert
Assert.IsNotNull(call);
Assert.IsNotNull(content);
var responseTask = call.ResponseAsync;
Assert.IsFalse(responseTask.IsCompleted, "Response not returned until client stream is complete.");
var streamTask = content.ReadAsStreamAsync();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var requestContent = await streamTask.DefaultTimeout();
var requestMessage = await requestContent.ReadStreamedMessageAsync(NullLogger.Instance, TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage.Name);
requestMessage = await requestContent.ReadStreamedMessageAsync(NullLogger.Instance, TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage.Name);
var responseMessage = await responseTask.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
}
public async Task AsyncDuplexStreamingCall_MessagesStreamed_MessagesReceived()
{
// Arrange
var streamContent = new SyncPointMemoryStream();
var requestContentTcs = new TaskCompletionSource <Task <Stream> >(TaskCreationOptions.RunContinuationsAsynchronously);
PushStreamContent <HelloRequest, HelloReply>?content = null;
var handler = TestHttpMessageHandler.Create(async request =>
{
content = (PushStreamContent <HelloRequest, HelloReply>)request.Content !;
var streamTask = content.ReadAsStreamAsync();
requestContentTcs.SetResult(streamTask);
// Wait for RequestStream.CompleteAsync()
await streamTask;
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)));
});
var invoker = HttpClientCallInvokerFactory.Create(handler, "https://localhost");
// Act
var call = invoker.AsyncDuplexStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var requestStream = call.RequestStream;
var responseStream = call.ResponseStream;
// Assert
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var deserializationContext = new DefaultDeserializationContext();
Assert.IsNotNull(content);
var requestContent = await await requestContentTcs.Task.DefaultTimeout();
var requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage !.Name);
requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage !.Name);
Assert.IsNull(responseStream.Current);
var moveNextTask1 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask1.IsCompleted);
await streamContent.AddDataAndWait(await ClientTestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 1"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask1.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 1", responseStream.Current.Message);
var moveNextTask2 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask2.IsCompleted);
await streamContent.AddDataAndWait(await ClientTestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask2.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 2", responseStream.Current.Message);
var moveNextTask3 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask3.IsCompleted);
await streamContent.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout();
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
var moveNextTask4 = responseStream.MoveNext(CancellationToken.None);
Assert.IsTrue(moveNextTask4.IsCompleted);
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
}
public async Task AsyncClientStreamingCall_Success_RequestContentSent()
{
// Arrange
var requestContentTcs = new TaskCompletionSource <Task <Stream> >(TaskCreationOptions.RunContinuationsAsynchronously);
PushStreamContent <HelloRequest, HelloReply>?content = null;
var handler = TestHttpMessageHandler.Create(async request =>
{
content = (PushStreamContent <HelloRequest, HelloReply>)request.Content !;
var streamTask = content.ReadAsStreamAsync();
requestContentTcs.SetResult(streamTask);
// Wait for RequestStream.CompleteAsync()
await streamTask;
HelloReply reply = new HelloReply
{
Message = "Hello world"
};
var streamContent = await ClientTestHelpers.CreateResponseContent(reply).DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, streamContent));
});
var invoker = HttpClientCallInvokerFactory.Create(handler, "http://localhost");
// Act
var call = invoker.AsyncClientStreamingCall <HelloRequest, HelloReply>(ClientTestHelpers.ServiceMethod, string.Empty, new CallOptions());
var requestContentTask = await requestContentTcs.Task.DefaultTimeout();
// Assert
Assert.IsNotNull(call);
Assert.IsNotNull(content);
var responseTask = call.ResponseAsync;
Assert.IsFalse(responseTask.IsCompleted, "Response not returned until client stream is complete.");
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var requestContent = await requestContentTask.DefaultTimeout();
var requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage !.Name);
requestMessage = await StreamSerializationHelper.ReadMessageAsync(
requestContent,
ClientTestHelpers.ServiceMethod.RequestMarshaller.ContextualDeserializer,
GrpcProtocolConstants.IdentityGrpcEncoding,
maximumMessageSize : null,
GrpcProtocolConstants.DefaultCompressionProviders,
singleMessage : false,
CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage !.Name);
var responseMessage = await responseTask.DefaultTimeout();
Assert.AreEqual("Hello world", responseMessage.Message);
}
public async Task AsyncDuplexStreamingCall_MessagesStreamed_MessagesReceived()
{
// Arrange
var streamContent = new SyncPointMemoryStream();
PushStreamContent content = null;
var httpClient = TestHelpers.CreateTestClient(async request =>
{
content = (PushStreamContent)request.Content;
await content.PushComplete.DefaultTimeout();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(streamContent)));
});
var invoker = new HttpClientCallInvoker(httpClient);
// Act
var call = invoker.AsyncDuplexStreamingCall <HelloRequest, HelloReply>(TestHelpers.ServiceMethod, null, new CallOptions());
var requestStream = call.RequestStream;
var responseStream = call.ResponseStream;
// Assert
await call.RequestStream.WriteAsync(new HelloRequest { Name = "1" }).DefaultTimeout();
await call.RequestStream.WriteAsync(new HelloRequest { Name = "2" }).DefaultTimeout();
await call.RequestStream.CompleteAsync().DefaultTimeout();
var requestContent = await content.ReadAsStreamAsync().DefaultTimeout();
var requestMessage = await requestContent.ReadStreamedMessageAsync(TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("1", requestMessage.Name);
requestMessage = await requestContent.ReadStreamedMessageAsync(TestHelpers.ServiceMethod.RequestMarshaller.Deserializer, CancellationToken.None).DefaultTimeout();
Assert.AreEqual("2", requestMessage.Name);
Assert.IsNull(responseStream.Current);
var moveNextTask1 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask1.IsCompleted);
await streamContent.AddDataAndWait(await TestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 1"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask1.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 1", responseStream.Current.Message);
var moveNextTask2 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask2.IsCompleted);
await streamContent.AddDataAndWait(await TestHelpers.GetResponseDataAsync(new HelloReply
{
Message = "Hello world 2"
}).DefaultTimeout()).DefaultTimeout();
Assert.IsTrue(await moveNextTask2.DefaultTimeout());
Assert.IsNotNull(responseStream.Current);
Assert.AreEqual("Hello world 2", responseStream.Current.Message);
var moveNextTask3 = responseStream.MoveNext(CancellationToken.None);
Assert.IsFalse(moveNextTask3.IsCompleted);
await streamContent.AddDataAndWait(Array.Empty <byte>()).DefaultTimeout();
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
var moveNextTask4 = responseStream.MoveNext(CancellationToken.None);
Assert.IsTrue(moveNextTask4.IsCompleted);
Assert.IsFalse(await moveNextTask3.DefaultTimeout());
}