public void WriteByte_ReportsBytesWritten()
{
// Arrange
HttpRequestMessage request = CreateRequest();
Stream innerStream = new MemoryStream();
byte[] buffer = CreateBufferContent();
long? expectedLength = request.Content.Headers.ContentLength;
MockProgressEventHandler mockProgressEventHandler;
ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true);
ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request);
// Act/Assert
int totalBytesWritten = 0;
while (totalBytesWritten < expectedLength)
{
progressStream.WriteByte(buffer[totalBytesWritten]);
totalBytesWritten += 1;
Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred);
Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
public async Task WriteAsync_ReportsBytesWritten()
{
// Arrange
using (ManualResetEvent writeComplete = new ManualResetEvent(false))
{
HttpRequestMessage request = CreateRequest();
Stream innerStream = new MemoryStream();
byte[] buffer = CreateBufferContent();
long?expectedLength = request.Content.Headers.ContentLength;
MockProgressEventHandler mockProgressEventHandler;
ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true);
ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request);
object userState = new object();
// Act/Assert
int totalBytesWritten = 0;
int bytesWritten = 0;
while (totalBytesWritten < expectedLength)
{
bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten);
await progressStream.WriteAsync(buffer, totalBytesWritten, bytesWritten);
totalBytesWritten += bytesWritten;
Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred);
Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
}
public void Constructor_ReportsBytesWritten(int offset, int count)
{
// Arrange
Mock <Stream> mockInnerStream = new Mock <Stream>();
object userState = new object();
IAsyncResult mockIAsyncResult = CreateMockCompletedAsyncResult(true, userState);
mockInnerStream.Setup(s => s.BeginWrite(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <AsyncCallback>(), It.IsAny <object>()))
.Returns(mockIAsyncResult);
MockProgressEventHandler mockProgressHandler;
ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressHandler, sendProgress: true);
HttpRequestMessage request = new HttpRequestMessage();
ProgressStream progressStream = ProgressStreamTest.CreateProgressStream(progressMessageHandler: progressMessageHandler, request: request);
// Act
IAsyncResult result = new ProgressWriteAsyncResult(
mockInnerStream.Object, progressStream, sampleData, offset, count, null, userState);
// Assert
Assert.True(mockProgressHandler.WasInvoked);
Assert.Same(request, mockProgressHandler.Sender);
Assert.Equal(count, mockProgressHandler.EventArgs.BytesTransferred);
Assert.Same(userState, mockProgressHandler.EventArgs.UserState);
}
public async Task ReadByte_ReportsBytesRead()
{
// Arrange
HttpResponseMessage response = CreateResponse();
Stream innerStream = await response.Content.ReadAsStreamAsync();
long?expectedLength = response.Content.Headers.ContentLength;
MockProgressEventHandler mockProgressEventHandler;
ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false);
ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response);
// Act/Assert
int totalBytesRead = 0;
while (progressStream.ReadByte() != -1)
{
totalBytesRead += 1;
Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred);
Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
public async Task BeginEndRead_ReportsBytesRead()
{
// Arrange
HttpResponseMessage response = CreateResponse();
Stream innerStream = await response.Content.ReadAsStreamAsync();
long?expectedLength = response.Content.Headers.ContentLength;
MockProgressEventHandler mockProgressEventHandler;
ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false);
ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response);
object userState = new object();
// Act/Assert
int totalBytesRead = 0;
int bytesRead = 0;
do
{
byte[] buffer = new byte[8];
IAsyncResult result = progressStream.BeginRead(buffer, 0, buffer.Length, null, userState);
bytesRead = progressStream.EndRead(result);
totalBytesRead += bytesRead;
Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState);
Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred);
Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
}while (bytesRead > 0);
Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
public void BeginEndWrite_ReportsBytesWritten()
{
// Arrange
HttpRequestMessage request = CreateRequest();
Stream innerStream = new MemoryStream();
byte[] buffer = CreateBufferContent();
long? expectedLength = request.Content.Headers.ContentLength;
MockProgressEventHandler mockProgressEventHandler;
ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true);
ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request);
object userState = new object();
// Act/Assert
int totalBytesWritten = 0;
int bytesWritten = 0;
while (totalBytesWritten < expectedLength)
{
bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten);
IAsyncResult result = progressStream.BeginWrite(buffer, totalBytesWritten, bytesWritten, null, userState);
progressStream.EndWrite(result);
totalBytesWritten += bytesWritten;
Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState);
Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred);
Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
}
public void Constructor_CompletesWithExceptionIfInnerStreamThrows()
{
// Arrange
Mock <Stream> mockInnerStream = new Mock <Stream>();
mockInnerStream
.Setup(
s =>
s.BeginWrite(
It.IsAny <byte[]>(),
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <AsyncCallback>(),
It.IsAny <object>()
)
)
.Throws <ApplicationException>();
ProgressStream progressStream = ProgressStreamTest.CreateProgressStream();
// Act
IAsyncResult result = new ProgressWriteAsyncResult(
mockInnerStream.Object,
progressStream,
sampleData,
2,
2,
null,
null
);
// Assert
Assert.True(result.IsCompleted);
Assert.Throws <ApplicationException>(() => ProgressWriteAsyncResult.End(result));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
ProgressStream progressStream = new ProgressStream(
stream,
_handler,
_request,
response: null
);
return(_innerContent.CopyToAsync(progressStream));
}
private async Task <HttpResponseMessage> AddResponseProgressAsync(HttpRequestMessage request, HttpResponseMessage response)
{
Stream stream = await response.Content.ReadAsStreamAsync();
ProgressStream progressStream = new ProgressStream(stream, this, request, response);
HttpContent progressContent = new StreamContent(progressStream);
response.Content.Headers.CopyTo(progressContent.Headers);
response.Content = progressContent;
return(response);
}
public void Constructor_BeginWriteOnInnerStream()
{
// Arrange
Mock <Stream> mockInnerStream = new Mock <Stream>();
ProgressStream progressStream = ProgressStreamTest.CreateProgressStream();
// Act
IAsyncResult result = new ProgressWriteAsyncResult(
mockInnerStream.Object, progressStream, sampleData, 2, 4, null, null);
// Assert
mockInnerStream.Verify(s => s.BeginWrite(sampleData, 2, 4, It.IsAny <AsyncCallback>(), It.IsAny <object>()),
Times.Once());
}
public void Constructor_CompletesSynchronouslyIfInnerStreamCompletesSynchronously()
{
// Arrange
Mock <Stream> mockInnerStream = new Mock <Stream>();
object userState = new object();
IAsyncResult mockIAsyncResult = CreateMockCompletedAsyncResult(true, userState);
mockInnerStream.Setup(s => s.BeginWrite(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <AsyncCallback>(), It.IsAny <object>()))
.Returns(mockIAsyncResult);
ProgressStream progressStream = ProgressStreamTest.CreateProgressStream();
// Act
IAsyncResult result = new ProgressWriteAsyncResult(
mockInnerStream.Object, progressStream, sampleData, 2, 4, null, userState);
// Assert
Assert.True(result.IsCompleted);
Assert.True(result.CompletedSynchronously);
Assert.Same(userState, result.AsyncState);
}
private Task <HttpResponseMessage> AddResponseProgress(HttpRequestMessage request, HttpResponseMessage response)
{
Task <HttpResponseMessage> responseTask;
if (HttpReceiveProgress != null && response != null && response.Content != null)
{
responseTask = response.Content.ReadAsStreamAsync().Then(
stream =>
{
ProgressStream progressStream = new ProgressStream(stream, this, request, response);
HttpContent progressContent = new StreamContent(progressStream);
response.Content.Headers.CopyTo(progressContent.Headers);
response.Content = progressContent;
return(response);
}, runSynchronously: true);
}
else
{
responseTask = TaskHelpers.FromResult(response);
}
return(responseTask);
}
public ProgressWriteAsyncResult(
Stream innerStream,
ProgressStream progressStream,
byte[] buffer,
int offset,
int count,
AsyncCallback callback,
object state
) : base(callback, state)
{
Contract.Assert(innerStream != null);
Contract.Assert(progressStream != null);
Contract.Assert(buffer != null);
_innerStream = innerStream;
_progressStream = progressStream;
_count = count;
try
{
IAsyncResult result = innerStream.BeginWrite(
buffer,
offset,
count,
_writeCompletedCallback,
this
);
if (result.CompletedSynchronously)
{
WriteCompleted(result);
}
}
catch (Exception e)
{
Complete(true, e);
}
}
public ProgressWriteAsyncResult(Stream innerStream, ProgressStream progressStream, byte[] buffer, int offset, int count, AsyncCallback callback, object state)
: base(callback, state)
{
Contract.Assert(innerStream != null);
Contract.Assert(progressStream != null);
Contract.Assert(buffer != null);
_innerStream = innerStream;
_progressStream = progressStream;
_count = count;
try
{
IAsyncResult result = innerStream.BeginWrite(buffer, offset, count, _writeCompletedCallback, this);
if (result.CompletedSynchronously)
{
WriteCompleted(result);
}
}
catch (Exception e)
{
Complete(true, e);
}
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
ProgressStream progressStream = new ProgressStream(stream, _handler, _request, response: null);
return _innerContent.CopyToAsync(progressStream);
}
private async Task<HttpResponseMessage> AddResponseProgressAsync(HttpRequestMessage request, HttpResponseMessage response)
{
Stream stream = await response.Content.ReadAsStreamAsync();
ProgressStream progressStream = new ProgressStream(stream, this, request, response);
HttpContent progressContent = new StreamContent(progressStream);
response.Content.Headers.CopyTo(progressContent.Headers);
response.Content = progressContent;
return response;
}
private Task<HttpResponseMessage> AddResponseProgress(HttpRequestMessage request, HttpResponseMessage response)
{
Task<HttpResponseMessage> responseTask;
if (HttpReceiveProgress != null && response != null && response.Content != null)
{
responseTask = response.Content.ReadAsStreamAsync().Then(
stream =>
{
ProgressStream progressStream = new ProgressStream(stream, this, request, response);
HttpContent progressContent = new StreamContent(progressStream);
response.Content.Headers.CopyTo(progressContent.Headers);
response.Content = progressContent;
return response;
}, runSynchronously: true);
}
else
{
responseTask = TaskHelpers.FromResult(response);
}
return responseTask;
}
