public void OnWrite_AppendsAcceptEncodingToVaryHeader_IfNotPresent(string providedVaryHeader, string expectedVaryHeader)
    {
        var httpContext = new DefaultHttpContext();

        httpContext.Response.Headers.Vary = providedVaryHeader;
        var stream = new ResponseCompressionBody(httpContext, new MockResponseCompressionProvider(flushable: true), new StreamResponseBodyFeature(new MemoryStream()));

        stream.Write(new byte[] { }, 0, 0);

        Assert.Equal(expectedVaryHeader, httpContext.Response.Headers.Vary);
    }
Esempio n. 2
0
        public async Task WriteAsync_IsPassedToUnderlyingStream_WhenDisableResponseBuffering(bool flushable)
        {
            var buffer = new byte[] { 1 };

            var memoryStream = new MemoryStream();
            var stream       = new ResponseCompressionBody(new DefaultHttpContext(), new MockResponseCompressionProvider(flushable), new StreamResponseBodyFeature(memoryStream));

            stream.DisableBuffering();
            await stream.WriteAsync(buffer, 0, buffer.Length);

            Assert.Equal(buffer, memoryStream.ToArray());
        }
Esempio n. 3
0
        public void BeginWrite_IsPassedToUnderlyingStream_WhenDisableResponseBuffering(bool flushable)
        {
            var buffer = new byte[] { 1 };

            var memoryStream = new MemoryStream();

            var stream = new ResponseCompressionBody(new DefaultHttpContext(), new MockResponseCompressionProvider(flushable), new StreamResponseBodyFeature(memoryStream));

            stream.DisableBuffering();
            stream.BeginWrite(buffer, 0, buffer.Length, (o) => {}, null);

            Assert.Equal(buffer, memoryStream.ToArray());
        }
Esempio n. 4
0
        public async Task SendFileAsync_IsPassedToUnderlyingStream_WhenDisableResponseBuffering()
        {
            var memoryStream = new MemoryStream();

            var stream = new ResponseCompressionBody(new DefaultHttpContext(), new MockResponseCompressionProvider(true), new StreamResponseBodyFeature(memoryStream));

            stream.DisableBuffering();

            var path = "testfile1kb.txt";
            await stream.SendFileAsync(path, 0, null, CancellationToken.None);

            Assert.Equal(File.ReadAllBytes(path), memoryStream.ToArray());
        }
Esempio n. 5
0
    private async Task InvokeCore(HttpContext context)
    {
        var originalBodyFeature        = context.Features.Get <IHttpResponseBodyFeature>();
        var originalCompressionFeature = context.Features.Get <IHttpsCompressionFeature>();

        Debug.Assert(originalBodyFeature != null);

        var compressionBody = new ResponseCompressionBody(context, _provider, originalBodyFeature);

        context.Features.Set <IHttpResponseBodyFeature>(compressionBody);
        context.Features.Set <IHttpsCompressionFeature>(compressionBody);

        try
        {
            await _next(context);

            await compressionBody.FinishCompressionAsync();
        }
        finally
        {
            context.Features.Set(originalBodyFeature);
            context.Features.Set(originalCompressionFeature);
        }
    }