public async Task DoesNotClose_UnderlyingStream_OnDisposingWriter()
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
await writer.WriteAsync("Hello");
writer.Close();
// Assert
Assert.Equal(0, stream.CloseCallCount);
}
public async Task DoesNotDispose_UnderlyingStream_OnDisposingWriter()
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
await writer.WriteAsync("Hello world");
writer.Dispose();
// Assert
Assert.Equal(0, stream.DisposeCallCount);
}
public async Task WriteCharArrayAsync_WritesToStream(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
using (writer)
{
await writer.WriteAsync((new string('a', byteLength)).ToCharArray());
}
// Assert
Assert.Equal(byteLength, stream.Length);
}
public async Task DoesNotFlush_UnderlyingStream_OnClosingWriter()
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
await writer.WriteAsync("Hello");
writer.Close();
// Assert
Assert.Equal(0, stream.FlushCallCount);
Assert.Equal(0, stream.FlushAsyncCallCount);
}
public async Task WriteReadOnlyMemoryAsync_TokenCanceled_ReturnsCanceledTask()
{
// Arrange
var stream = new TestMemoryStream();
using var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
var memory = new ReadOnlyMemory <char>(new char[] { 'a' });
var cancellationToken = new CancellationToken(true);
// Act
await Assert.ThrowsAsync <TaskCanceledException>(async() => await writer.WriteAsync(memory, cancellationToken));
// Assert
Assert.Equal(0, stream.Length);
}
public async Task FlushesBuffer_OnDispose(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
await writer.WriteAsync(new string('a', byteLength));
// Act
writer.Dispose();
// Assert
Assert.Equal(0, stream.FlushCallCount);
Assert.Equal(0, stream.FlushAsyncCallCount);
Assert.Equal(byteLength, stream.Length);
}
/// <inheritdoc />
public override async Task ExecuteAsync(ApiOperationContext context)
{
await base.ExecuteAsync(context);
var httpContext = context.GetHttpContext();
var response = httpContext.Response;
response.ContentType = this.ContentType;
using var httpResponseStreamWriter = new HttpResponseStreamWriter(response.Body, Encoding.UTF8);
await httpResponseStreamWriter.WriteAsync(this._content);
await httpResponseStreamWriter.FlushAsync();
}
public async Task FlushesBuffer_ButNotStream_OnFlushAsync(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
await writer.WriteAsync(new string('a', byteLength));
var expectedWriteCount = Math.Ceiling((double)byteLength / HttpResponseStreamWriter.DefaultBufferSize);
// Act
await writer.FlushAsync();
// Assert
Assert.Equal(0, stream.FlushAsyncCallCount);
Assert.Equal(expectedWriteCount, stream.WriteAsyncCallCount);
Assert.Equal(byteLength, stream.Length);
}
public async Task WriteReadOnlyMemoryAsync_WritesToStream(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
using (writer)
{
var array = new string('a', byteLength).ToCharArray();
var memory = new ReadOnlyMemory <char>(array);
await writer.WriteAsync(memory);
}
// Assert
Assert.Equal(byteLength, stream.Length);
}
public async Task WritesData_InExpectedEncoding(string data, string encodingName)
{
// Arrange
var encoding = Encoding.GetEncoding(encodingName);
var expectedBytes = encoding.GetBytes(data);
var stream = new MemoryStream();
var writer = new HttpResponseStreamWriter(stream, encoding);
// Act
using (writer)
{
await writer.WriteAsync(data);
}
// Assert
Assert.Equal(expectedBytes, stream.ToArray());
}
public async Task DoesNotWriteBOM()
{
// Arrange
var memoryStream = new MemoryStream();
var encodingWithBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);
var writer = new HttpResponseStreamWriter(memoryStream, encodingWithBOM);
var expectedData = new byte[] { 97, 98, 99, 100 }; // without BOM
// Act
using (writer)
{
await writer.WriteAsync("abcd");
}
// Assert
Assert.Equal(expectedData, memoryStream.ToArray());
}
public async Task DoesNotWriteBOM()
{
// Arrange
var memoryStream = new MemoryStream();
var encodingWithBOM = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true);
var writer = new HttpResponseStreamWriter(memoryStream, encodingWithBOM);
var expectedData = new byte[] { 97, 98, 99, 100 }; // without BOM
// Act
using (writer)
{
await writer.WriteAsync("abcd");
}
// Assert
Assert.Equal(expectedData, memoryStream.ToArray());
}
public async Task WriteCharAsync_WritesToStream(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
using (writer)
{
for (var i = 0; i < byteLength; i++)
{
await writer.WriteAsync('a');
}
}
// Assert
Assert.Equal(byteLength, stream.Length);
}
/// <summary>
/// Writes the content to the HTTP response.
/// </summary>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current request.</param>
/// <returns>A task that represents the asynchronous execute operation.</returns>
async Task IResult.ExecuteAsync(HttpContext httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var response = httpContext.Response;
ResponseContentTypeHelper.ResolveContentTypeAndEncoding(
ContentType,
response.ContentType,
DefaultContentType,
out var resolvedContentType,
out var resolvedContentTypeEncoding);
response.ContentType = resolvedContentType;
if (StatusCode != null)
{
response.StatusCode = StatusCode.Value;
}
var factory = httpContext.RequestServices.GetRequiredService <ILoggerFactory>();
var logger = factory.CreateLogger <ContentResult>();
logger.ContentResultExecuting(resolvedContentType);
if (Content != null)
{
response.ContentLength = resolvedContentTypeEncoding.GetByteCount(Content);
await using (var textWriter = new HttpResponseStreamWriter(response.Body, resolvedContentTypeEncoding))
{
await textWriter.WriteAsync(Content);
// Flushing the HttpResponseStreamWriter does not flush the underlying stream. This just flushes
// the buffered text in the writer.
// We do this rather than letting dispose handle it because dispose would call Write and we want
// to call WriteAsync.
await textWriter.FlushAsync();
}
}
}
public async Task WritesData_OfDifferentLength_InExpectedEncoding(
char character,
int charCount,
string encodingName)
{
// Arrange
var encoding = Encoding.GetEncoding(encodingName);
string data = new string(character, charCount);
var expectedBytes = encoding.GetBytes(data);
var stream = new MemoryStream();
var writer = new HttpResponseStreamWriter(stream, encoding);
// Act
using (writer)
{
await writer.WriteAsync(data);
}
// Assert
Assert.Equal(expectedBytes, stream.ToArray());
}
public async Task HttpResponseStreamWriter_WritesDataCorrectly_ForCharactersHavingSurrogatePairs(int characterSize)
{
// Arrange
// Here "𐐀" (called Deseret Long I) actually represents 2 characters. Try to make this character split across
// the boundary
var content = new string('a', characterSize - 1) + "𐐀";
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.Unicode);
// Act
await writer.WriteAsync(content);
await writer.FlushAsync();
// Assert
stream.Seek(0, SeekOrigin.Begin);
var streamReader = new StreamReader(stream, Encoding.Unicode);
var actualContent = await streamReader.ReadToEndAsync();
Assert.Equal(content, actualContent);
}
public async Task FlushWriteThrows_DontFlushInDispose(int byteLength)
{
// Arrange
var stream = new TestMemoryStream()
{
ThrowOnWrite = true
};
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
await writer.WriteAsync(new string('a', byteLength));
await Assert.ThrowsAsync <IOException>(() => writer.FlushAsync());
// Act
writer.Dispose();
// Assert
Assert.Equal(1, stream.WriteAsyncCallCount);
Assert.Equal(0, stream.WriteCallCount);
Assert.Equal(0, stream.FlushCallCount);
Assert.Equal(0, stream.FlushAsyncCallCount);
Assert.Equal(0, stream.Length);
}
public async Task FlushesBuffer_ButNotStream_OnFlushAsync(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
await writer.WriteAsync(new string('a', byteLength));
var expectedWriteCount = Math.Ceiling((double)byteLength / HttpResponseStreamWriter.DefaultBufferSize);
// Act
await writer.FlushAsync();
// Assert
Assert.Equal(0, stream.FlushAsyncCallCount);
Assert.Equal(expectedWriteCount, stream.WriteAsyncCallCount);
Assert.Equal(byteLength, stream.Length);
}
public async Task FlushWriteThrows_DontFlushInDispose(int byteLength)
{
// Arrange
var stream = new TestMemoryStream() { ThrowOnWrite = true };
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
await writer.WriteAsync(new string('a', byteLength));
await Assert.ThrowsAsync<IOException>(() => writer.FlushAsync());
// Act
writer.Dispose();
// Assert
Assert.Equal(1, stream.WriteAsyncCallCount);
Assert.Equal(0, stream.WriteCallCount);
Assert.Equal(0, stream.FlushCallCount);
Assert.Equal(0, stream.FlushAsyncCallCount);
Assert.Equal(0, stream.Length);
}
public async Task WriteCharAsync_WritesToStream(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
using (writer)
{
for (var i = 0; i < byteLength; i++)
{
await writer.WriteAsync('a');
}
}
// Assert
Assert.Equal(byteLength, stream.Length);
}
public async Task WriteCharArrayAsync_WritesToStream(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
// Act
using (writer)
{
await writer.WriteAsync((new string('a', byteLength)).ToCharArray());
}
// Assert
Assert.Equal(byteLength, stream.Length);
}
public async Task WritesData_InExpectedEncoding(string data, string encodingName)
{
// Arrange
var encoding = Encoding.GetEncoding(encodingName);
var expectedBytes = encoding.GetBytes(data);
var stream = new MemoryStream();
var writer = new HttpResponseStreamWriter(stream, encoding);
// Act
using (writer)
{
await writer.WriteAsync(data);
}
// Assert
Assert.Equal(expectedBytes, stream.ToArray());
}
public async Task WritesData_OfDifferentLength_InExpectedEncoding(
char character,
int charCount,
string encodingName)
{
// Arrange
var encoding = Encoding.GetEncoding(encodingName);
string data = new string(character, charCount);
var expectedBytes = encoding.GetBytes(data);
var stream = new MemoryStream();
var writer = new HttpResponseStreamWriter(stream, encoding);
// Act
using (writer)
{
await writer.WriteAsync(data);
}
// Assert
Assert.Equal(expectedBytes, stream.ToArray());
}
public async Task CopyToAsync(Stream stream, CancellationToken cancellationToken = default)
{
using (var sb = new HttpResponseStreamWriter(stream, Encoding.ASCII))
{
await sb.WriteAsync("Content-Type: application/http; msgtype=response").ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
await sb.WriteAsync(_httpVersion).ConfigureAwait(false);
await sb.WriteAsync(' ').ConfigureAwait(false);
// ReSharper disable once ImpureMethodCallOnReadonlyValueField
await sb.WriteAsync(StatusCode.ToString()).ConfigureAwait(false);
await sb.WriteAsync(' ').ConfigureAwait(false);
await sb.WriteAsync(_reasonPhrase).ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
foreach (var header in Headers)
{
await sb.WriteAsync(header.Key).ConfigureAwait(false);
await sb.WriteAsync(": ").ConfigureAwait(false);
await sb.WriteAsync(header.Value).ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
}
await sb.WriteAsync(Crlf).ConfigureAwait(false);
await sb.FlushAsync().ConfigureAwait(false);
}
if (_content != null)
{
await _content.CopyToAsync(stream, cancellationToken).ConfigureAwait(false);
}
}
public async Task FlushesBuffer_OnDispose(int byteLength)
{
// Arrange
var stream = new TestMemoryStream();
var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
await writer.WriteAsync(new string('a', byteLength));
// Act
writer.Dispose();
// Assert
Assert.Equal(0, stream.FlushCallCount);
Assert.Equal(0, stream.FlushAsyncCallCount);
Assert.Equal(byteLength, stream.Length);
}
/// <inheritdoc />
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
using (var sb = new HttpResponseStreamWriter(stream, Encoding.UTF8))
{
await sb.WriteAsync(this.message.Method.Method).ConfigureAwait(false);
await sb.WriteAsync(' ').ConfigureAwait(false);
await sb.WriteAsync(this.message.RequestUri.ToString()).ConfigureAwait(false);
await sb.WriteAsync(' ').ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
foreach (var header in this.message.Headers)
{
await sb.WriteAsync(header.Key).ConfigureAwait(false);
await sb.WriteAsync(": ").ConfigureAwait(false);
await sb.WriteAsync(string.Join(", ", header.Value)).ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
}
if (this.message.Content?.Headers != null)
{
foreach (var header in this.message.Content?.Headers)
{
await sb.WriteAsync(header.Key).ConfigureAwait(false);
await sb.WriteAsync(": ").ConfigureAwait(false);
await sb.WriteAsync(string.Join(", ", header.Value)).ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
}
}
await sb.WriteAsync(Crlf).ConfigureAwait(false);
}
if (this.message.Content != null)
{
using (var contentStream = await this.message.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
await contentStream.CopyToAsync(stream).ConfigureAwait(false);
}
}
}
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
using (var sb = new HttpResponseStreamWriter(stream, Encoding.ASCII))
{
await sb.WriteAsync(_message.Method.Method).ConfigureAwait(false);
await sb.WriteAsync(' ').ConfigureAwait(false);
// ReSharper disable once ImpureMethodCallOnReadonlyValueField
await sb.WriteAsync(_message.RequestUri.PathAndQuery).ConfigureAwait(false);
await sb.WriteAsync(' ').ConfigureAwait(false);
await sb.WriteAsync($"HTTP/{_message.Version}").ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
await sb.WriteAsync($"Host: {_message.RequestUri.Authority}").ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
foreach (var header in _message.Headers)
{
await sb.WriteAsync(header.Key).ConfigureAwait(false);
await sb.WriteAsync(": ").ConfigureAwait(false);
await sb.WriteAsync(string.Join(", ", header.Value)).ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
}
if (_message.Content?.Headers != null)
{
foreach (var header in _message.Content?.Headers)
{
await sb.WriteAsync(header.Key).ConfigureAwait(false);
await sb.WriteAsync(": ").ConfigureAwait(false);
await sb.WriteAsync(string.Join(", ", header.Value)).ConfigureAwait(false);
await sb.WriteAsync(Crlf).ConfigureAwait(false);
}
}
await sb.WriteAsync(Crlf).ConfigureAwait(false);
}
if (_message.Content != null)
{
using (var contentStream = await _message.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
await contentStream.CopyToAsync(stream).ConfigureAwait(false);
}
}
}
