public void OnWrite_AppendsAcceptEncodingToVaryHeader_IfNotPresent(string providedVaryHeader, string expectedVaryHeader)
{
var httpContext = new DefaultHttpContext();
httpContext.Response.Headers[HeaderNames.Vary] = providedVaryHeader;
var stream = new BodyWrapperStream(httpContext, new MemoryStream(), new MockResponseCompressionProvider(flushable: true), null, null);
stream.Write(new byte[] { }, 0, 0);
Assert.Equal(expectedVaryHeader, httpContext.Response.Headers[HeaderNames.Vary]);
}
public async Task WriteAsync_IsPassedToUnderlyingStream_WhenDisableResponseBuffering(bool flushable)
{
var buffer = new byte[] { 1 };
var memoryStream = new MemoryStream();
var stream = new BodyWrapperStream(new DefaultHttpContext(), memoryStream, new MockResponseCompressionProvider(flushable), null, null, null);
stream.DisableResponseBuffering();
await stream.WriteAsync(buffer, 0, buffer.Length);
Assert.Equal(buffer, memoryStream.ToArray());
}
public async Task SendFileAsync_IsPassedToUnderlyingStream_WhenDisableResponseBuffering()
{
var memoryStream = new MemoryStream();
var stream = new BodyWrapperStream(new DefaultHttpContext(), memoryStream, new MockResponseCompressionProvider(true), null, null, null);
stream.DisableResponseBuffering();
var path = "testfile1kb.txt";
await stream.SendFileAsync(path, 0, null, CancellationToken.None);
Assert.Equal(File.ReadAllBytes(path), memoryStream.ToArray());
}
public async Task Invoke(HttpContext context)
{
bool useMinification = _options.IsMinificationEnabled() && _minificationManagers.Count > 0;
bool useCompression = _options.IsCompressionEnabled() && _compressionManager != null;
if (!useMinification && !useCompression)
{
await _next.Invoke(context);
return;
}
else
{
HttpResponse response = context.Response;
IFeatureCollection features = context.Features;
Stream originalStream = response.Body;
IHttpBufferingFeature originalBufferFeature = features.Get <IHttpBufferingFeature>();
BodyWrapperStream bodyWrapperStream = new BodyWrapperStream(context, originalStream, _options,
useMinification ? _minificationManagers : new List <IMarkupMinificationManager>(),
useCompression ? _compressionManager : null,
originalBufferFeature);
response.Body = bodyWrapperStream;
features.Set <IHttpBufferingFeature>(bodyWrapperStream);
try
{
await _next(context);
await bodyWrapperStream.Finish();
}
finally
{
#if NETCOREAPP3_0
await bodyWrapperStream.DisposeAsync();
#else
bodyWrapperStream.Dispose();
#endif
response.Body = originalStream;
features.Set(originalBufferFeature);
}
}
}
public void Write_IsPassedToUnderlyingStream_WhenDisableResponseBuffering(bool flushable)
{
var buffer = new byte[] { 1 };
byte[] written = null;
var mock = new Mock <Stream>();
mock.SetupGet(s => s.CanWrite).Returns(true);
mock.Setup(s => s.Write(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>()))
.Callback <byte[], int, int>((b, o, c) =>
{
written = new ArraySegment <byte>(b, 0, c).ToArray();
});
var stream = new BodyWrapperStream(new DefaultHttpContext(), mock.Object, new MockResponseCompressionProvider(flushable), null, null);
stream.DisableResponseBuffering();
stream.Write(buffer, 0, buffer.Length);
Assert.Equal(buffer, written);
}
public async Task SendFileAsync_IsPassedToUnderlyingStream_WhenDisableResponseBuffering()
{
byte[] written = null;
var mock = new Mock <Stream>();
mock.SetupGet(s => s.CanWrite).Returns(true);
mock.Setup(s => s.WriteAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Callback <byte[], int, int, CancellationToken>((b, o, c, t) =>
{
written = new ArraySegment <byte>(b, 0, c).ToArray();
})
.Returns(Task.FromResult(0));
var stream = new BodyWrapperStream(new DefaultHttpContext(), mock.Object, new MockResponseCompressionProvider(true), null, null);
stream.DisableResponseBuffering();
var path = "testfile1kb.txt";
await stream.SendFileAsync(path, 0, null, CancellationToken.None);
Assert.Equal(File.ReadAllBytes(path), written);
}
