public async Task LoadIntoBufferAsync_CallMultipleTimesWithCalculatedContentLength_CopyToAsyncMemoryStreamCalledOnce(bool readStreamAsync)
{
var content = new MockContent(MockOptions.CanCalculateLength);
await content.LoadIntoBufferAsync();
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Stream stream = await content.ReadAsStreamAsync(readStreamAsync);
Assert.False(stream.CanWrite);
}
public async Task LoadIntoBufferAsync_CallMultipleTimesWithNullContentLength_CopyToAsyncMemoryStreamCalledOnce()
{
var content = new MockContent();
await content.LoadIntoBufferAsync();
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Stream stream = await content.ReadAsStreamAsync();
Assert.False(stream.CanWrite);
}
public async Task CopyToAsync_UseStreamWriteByteWithBufferSizeSmallerThanContentSize_ThrowsHttpRequestException()
{
// MockContent uses stream.WriteByte() rather than stream.Write(): Verify that the max. buffer size
// is also checked when using WriteByte().
var content = new MockContent(MockOptions.UseWriteByteInCopyTo);
await Assert.ThrowsAsync <HttpRequestException>(() => content.LoadIntoBufferAsync(content.GetMockData().Length - 1));
}
public async Task LoadIntoBufferAsync_ThrowCustomExceptionInOverriddenMethod_ThrowsMockException()
{
var content = new MockContent(new MockException(), MockOptions.ThrowInSerializeMethods);
Task t = content.LoadIntoBufferAsync();
await Assert.ThrowsAsync <MockException>(() => t);
}
public async Task LoadIntoBufferAsync_ThrowObjectDisposedExceptionInOverriddenMethod_ThrowsWrappedHttpRequestException()
{
var content = new MockContent(new ObjectDisposedException(""), MockOptions.ThrowInSerializeMethods);
Task t = content.LoadIntoBufferAsync();
HttpRequestException ex = await Assert.ThrowsAsync <HttpRequestException>(() => t);
Assert.IsType <ObjectDisposedException>(ex.InnerException);
}
public async Task LoadIntoBufferAsync_ThrowIOExceptionInOverriddenAsyncMethod_ThrowsHttpRequestException()
{
var content = new MockContent(new IOException(), MockOptions.ThrowInAsyncSerializeMethods);
Task t = content.LoadIntoBufferAsync();
HttpRequestException ex = await Assert.ThrowsAsync <HttpRequestException>(() => t);
Assert.IsType <IOException>(ex.InnerException);
}
public async Task ReadAsStream_GetFromBufferedContent_ThrowsAfterReadAsStreamsAsync()
{
var content = new MockContent();
await content.LoadIntoBufferAsync();
var task = content.ReadAsStreamAsync();
AssertExtensions.Throws <HttpRequestException>(() => content.ReadAsStream());
}
public async Task TryComputeLength_RetrieveContentLengthFromBufferedContent_ComputeLengthIsNotCalled()
{
var content = new MockContent();
await content.LoadIntoBufferAsync();
Assert.Equal(content.GetMockData().Length, content.Headers.ContentLength);
// Called once to determine the size of the buffer.
Assert.Equal(1, content.TryComputeLengthCount);
}
public async Task LoadIntoBufferAsync_CallOnMockContentWithCalculatedContentLength_CopyToAsyncMemoryStreamCalled()
{
var content = new MockContent(MockOptions.CanCalculateLength);
Assert.NotNull(content.Headers.ContentLength);
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Stream stream = await content.ReadAsStreamAsync();
Assert.False(stream.CanWrite);
}
public async Task LoadIntoBufferAsync_CallOnMockContentWithNullContentLength_CopyToAsyncMemoryStreamCalled(bool readStreamAsync)
{
var content = new MockContent();
Assert.Null(content.Headers.ContentLength);
await content.LoadIntoBufferAsync();
Assert.NotNull(content.Headers.ContentLength);
Assert.Equal(content.MockData.Length, content.Headers.ContentLength);
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Stream stream = await content.ReadAsStreamAsync(readStreamAsync);
Assert.False(stream.CanWrite);
}
public async Task CopyToAsync_BufferContentFirst_UseBufferedStreamAsSource()
{
var data = new byte[10];
var content = new MockContent(data);
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
var destination = new MemoryStream();
await content.CopyToAsync(destination);
// Our MockContent should not be called for the CopyTo() operation since the buffered stream should be
// used.
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Assert.Equal(data.Length, destination.Length);
}
public async Task ReadAsStreamAsync_GetFromBufferedContent_CreateContentReadStreamCalled()
{
var content = new MockContent(MockOptions.CanCalculateLength);
await content.LoadIntoBufferAsync();
Stream stream = await content.ReadAsStreamAsync();
Assert.Equal(0, content.CreateContentReadStreamCount);
Assert.Equal(content.GetMockData().Length, stream.Length);
Stream stream2 = await content.ReadAsStreamAsync();
Assert.Same(stream, stream2);
Assert.Equal(0, stream.Position);
Assert.Equal((byte)'d', stream.ReadByte());
}
public async Task LoadIntoBufferAsync_CallOnMockContentWithLessLengthThanContentLengthHeader_BufferedStreamLengthMatchesActualLengthNotContentLengthHeaderValue()
{
byte[] data = Encoding.UTF8.GetBytes("16 bytes of data");
var content = new MockContent(data);
content.Headers.ContentLength = 32; // Set the Content-Length header to a value > actual data length.
Assert.Equal(32, content.Headers.ContentLength);
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Assert.NotNull(content.Headers.ContentLength);
Assert.Equal(32, content.Headers.ContentLength);
Stream stream = await content.ReadAsStreamAsync();
Assert.Equal(data.Length, stream.Length);
}
public async Task ReadAsStreamAsync_FirstGetFromUnbufferedContentThenGetFromBufferedContent_SameStream()
{
var content = new MockContent(MockOptions.CanCalculateLength);
Stream before = await content.ReadAsStreamAsync();
Assert.Equal(1, content.CreateContentReadStreamCount);
await content.LoadIntoBufferAsync();
Stream after = await content.ReadAsStreamAsync();
Assert.Equal(1, content.CreateContentReadStreamCount);
// Note that ContentReadStream returns always the same stream. If the user gets the stream, buffers content,
// and gets the stream again, the same instance is returned. Returning a different instance could be
// confusing, even though there shouldn't be any real world scenario for retrieving the read stream both
// before and after buffering content.
Assert.Equal(before, after);
}
public void Dispose_DisposedObjectThenAccessMembers_ThrowsObjectDisposedException()
{
var content = new MockContent();
content.Dispose();
var m = new MemoryStream();
Assert.Throws <ObjectDisposedException>(() => { content.CopyToAsync(m); });
Assert.Throws <ObjectDisposedException>(() => { content.ReadAsByteArrayAsync(); });
Assert.Throws <ObjectDisposedException>(() => { content.ReadAsStringAsync(); });
Assert.Throws <ObjectDisposedException>(() => { content.ReadAsStreamAsync(); });
Assert.Throws <ObjectDisposedException>(() => { content.LoadIntoBufferAsync(); });
// Note that we don't throw when users access the Headers property. This is useful e.g. to be able to
// read the headers of a content, even though the content is already disposed. Note that the .NET guidelines
// only require members to throw ObjectDisposedExcpetion for members "that cannot be used after the object
// has been disposed of".
_output.WriteLine(content.Headers.ToString());
}
public async Task CopyToAsync_Buffered_CanBeCanceled()
{
// Buffered CopyToAsync will pass the CT to the Stream.WriteAsync
var content = new MockContent();
Assert.Equal(0, content.SerializeToStreamAsyncCount);
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
var cts = new CancellationTokenSource();
cts.Cancel();
using var ms = new MemoryStream();
await Assert.ThrowsAsync <TaskCanceledException>(() => content.CopyToAsync(ms, cts.Token));
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Assert.Equal(0, content.CreateContentReadStreamCount);
}
public async Task ReadAsStreamAsync_GetFromBufferedContent_SucceedsAfterReadAsStream()
{
var content = new MockContent(MockOptions.CanCalculateLength);
await content.LoadIntoBufferAsync();
// Call multiple times: CreateContentReadStream() should be called only once.
Stream stream = content.ReadAsStream();
stream = content.ReadAsStream();
Assert.Equal(0, content.CreateContentReadStreamCount);
stream = await content.ReadAsStreamAsync();
stream = await content.ReadAsStreamAsync();
Assert.Equal(0, content.CreateContentReadStreamCount);
Assert.Equal(content.GetMockData().Length, stream.Length);
Stream stream2 = await content.ReadAsStreamAsync();
Assert.Same(stream, stream2);
}
public async Task LoadIntoBufferAsync_CallMultipleTimesWithNullContentLength_CopyToAsyncMemoryStreamCalledOnce()
{
var content = new MockContent();
await content.LoadIntoBufferAsync();
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Stream stream = await content.ReadAsStreamAsync();
Assert.False(stream.CanWrite);
}
public async Task CopyToAsync_BufferContentFirst_UseBufferedStreamAsSource()
{
var data = new byte[10];
var content = new MockContent(data);
content.LoadIntoBufferAsync().Wait();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
var destination = new MemoryStream();
await content.CopyToAsync(destination);
// Our MockContent should not be called for the CopyTo() operation since the buffered stream should be
// used.
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Assert.Equal(data.Length, destination.Length);
}
public async Task Dispose_DisposedObjectThenAccessMembers_ThrowsObjectDisposedException()
{
var content = new MockContent();
content.Dispose();
var m = new MemoryStream();
await Assert.ThrowsAsync<ObjectDisposedException>(() => content.CopyToAsync(m));
await Assert.ThrowsAsync<ObjectDisposedException>(() => content.ReadAsByteArrayAsync());
await Assert.ThrowsAsync<ObjectDisposedException>(() => content.ReadAsStringAsync());
await Assert.ThrowsAsync<ObjectDisposedException>(() => content.ReadAsStreamAsync());
await Assert.ThrowsAsync<ObjectDisposedException>(() => content.LoadIntoBufferAsync());
// Note that we don't throw when users access the Headers property. This is useful e.g. to be able to
// read the headers of a content, even though the content is already disposed. Note that the .NET guidelines
// only require members to throw ObjectDisposedExcpetion for members "that cannot be used after the object
// has been disposed of".
_output.WriteLine(content.Headers.ToString());
}
public async Task CopyToAsync_UseStreamWriteByteWithBufferSizeSmallerThanContentSize_ThrowsHttpRequestException()
{
// MockContent uses stream.WriteByte() rather than stream.Write(): Verify that the max. buffer size
// is also checked when using WriteByte().
var content = new MockContent(MockOptions.UseWriteByteInCopyTo);
await Assert.ThrowsAsync<HttpRequestException>(() => content.LoadIntoBufferAsync(content.GetMockData().Length - 1));
}
public async Task LoadIntoBufferAsync_ThrowIOExceptionInOverriddenAsyncMethod_ThrowsHttpRequestException()
{
var content = new MockContent(new IOException(), MockOptions.ThrowInAsyncSerializeMethods);
HttpRequestException ex = await Assert.ThrowsAsync<HttpRequestException>(() => content.LoadIntoBufferAsync());
Assert.IsType<IOException>(ex.InnerException);
}
public async Task LoadIntoBufferAsync_ThrowCustomExceptionInOverriddenAsyncMethod_ExceptionBubblesUpToCaller()
{
var content = new MockContent(new MockException(), MockOptions.ThrowInAsyncSerializeMethods);
await Assert.ThrowsAsync<MockException>(() => content.LoadIntoBufferAsync());
}
public async Task LoadIntoBufferAsync_BufferSizeSmallerThanContentSizeWithCalculatedContentLength_ThrowsHttpRequestException()
{
var content = new MockContent(MockOptions.CanCalculateLength);
Task t = content.LoadIntoBufferAsync(content.GetMockData().Length - 1);
await Assert.ThrowsAsync <HttpRequestException>(() => t);
}
public async Task LoadIntoBufferAsync_BufferSizeSmallerThanContentSizeWithNullContentLength_ThrowsHttpRequestException()
{
var content = new MockContent();
await Assert.ThrowsAsync <HttpRequestException>(() => content.LoadIntoBufferAsync(content.GetMockData().Length - 1));
}
public async Task LoadIntoBufferAsync_CallOnMockContentWithLessLengthThanContentLengthHeader_BufferedStreamLengthMatchesActualLengthNotContentLengthHeaderValue()
{
byte[] data = Encoding.UTF8.GetBytes("16 bytes of data");
var content = new MockContent(data);
content.Headers.ContentLength = 32; // Set the Content-Length header to a value > actual data length.
Assert.Equal(32, content.Headers.ContentLength);
await content.LoadIntoBufferAsync();
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Assert.NotNull(content.Headers.ContentLength);
Assert.Equal(32, content.Headers.ContentLength);
Stream stream = await content.ReadAsStreamAsync();
Assert.Equal(data.Length, stream.Length);
}
public async Task TryComputeLength_RetrieveContentLengthFromBufferedContent_ComputeLengthIsNotCalled()
{
var content = new MockContent();
await content.LoadIntoBufferAsync();
Assert.Equal(content.GetMockData().Length, content.Headers.ContentLength);
// Called once to determine the size of the buffer.
Assert.Equal(1, content.TryComputeLengthCount);
}
public async Task LoadIntoBufferAsync_ThrowCustomExceptionInOverriddenAsyncMethod_ExceptionBubblesUpToCaller()
{
var content = new MockContent(new MockException(), MockOptions.ThrowInAsyncSerializeMethods);
await Assert.ThrowsAsync <MockException>(() => content.LoadIntoBufferAsync());
}
public async Task ReadAsStreamAsync_GetFromBufferedContent_CreateContentReadStreamCalled()
{
var content = new MockContent(MockOptions.CanCalculateLength);
await content.LoadIntoBufferAsync();
Stream stream = await content.ReadAsStreamAsync();
Assert.Equal(0, content.CreateContentReadStreamCount);
Assert.Equal(content.GetMockData().Length, stream.Length);
Stream stream2 = await content.ReadAsStreamAsync();
Assert.Same(stream, stream2);
Assert.Equal(0, stream.Position);
Assert.Equal((byte)'d', stream.ReadByte());
}
public async Task LoadIntoBufferAsync_ThrowCustomExceptionInOverriddenMethod_ThrowsMockException()
{
var content = new MockContent(new MockException(), MockOptions.ThrowInSerializeMethods);
Task t = content.LoadIntoBufferAsync();
await Assert.ThrowsAsync<MockException>(() => t);
}
public async Task LoadIntoBufferAsync_ThrowObjectDisposedExceptionInOverriddenMethod_ThrowsWrappedHttpRequestException()
{
var content = new MockContent(new ObjectDisposedException(""), MockOptions.ThrowInSerializeMethods);
HttpRequestException ex = await Assert.ThrowsAsync<HttpRequestException>(() => content.LoadIntoBufferAsync());
Assert.IsType<ObjectDisposedException>(ex.InnerException);
}
public async Task ReadAsStreamAsync_FirstGetFromUnbufferedContentThenGetFromBufferedContent_SameStream()
{
var content = new MockContent(MockOptions.CanCalculateLength);
Stream before = await content.ReadAsStreamAsync();
Assert.Equal(1, content.CreateContentReadStreamCount);
await content.LoadIntoBufferAsync();
Stream after = await content.ReadAsStreamAsync();
Assert.Equal(1, content.CreateContentReadStreamCount);
// Note that ContentReadStream returns always the same stream. If the user gets the stream, buffers content,
// and gets the stream again, the same instance is returned. Returning a different instance could be
// confusing, even though there shouldn't be any real world scenario for retrieving the read stream both
// before and after buffering content.
Assert.Equal(before, after);
}
public async Task LoadIntoBufferAsync_CallOnMockContentWithNullContentLength_CopyToAsyncMemoryStreamCalled()
{
var content = new MockContent();
Assert.Null(content.Headers.ContentLength);
await content.LoadIntoBufferAsync();
Assert.NotNull(content.Headers.ContentLength);
Assert.Equal(content.MockData.Length, content.Headers.ContentLength);
Assert.Equal(1, content.SerializeToStreamAsyncCount);
Stream stream = await content.ReadAsStreamAsync();
Assert.False(stream.CanWrite);
}
public async Task LoadIntoBufferAsync_BufferSizeSmallerThanContentSizeWithNullContentLength_ThrowsHttpRequestException()
{
var content = new MockContent();
await Assert.ThrowsAsync<HttpRequestException>(() => content.LoadIntoBufferAsync(content.GetMockData().Length - 1));
}
public async Task LoadIntoBufferAsync_BufferSizeSmallerThanContentSizeWithCalculatedContentLength_ThrowsHttpRequestException()
{
var content = new MockContent(MockOptions.CanCalculateLength);
Task t = content.LoadIntoBufferAsync(content.GetMockData().Length - 1);
await Assert.ThrowsAsync<HttpRequestException>(() => t);
}
