private void AdvertizeSupportedEncodings(HttpContext context, RequestDecompressionOptions decompressionOptions)
{
_decompressionProviders ??= CreateDecompressionProviders(decompressionOptions.Providers);
_acceptEncodingHeader ??= CreateAcceptEncodingHeader(_decompressionProviders);
context.Response.Headers.AcceptEncoding = _acceptEncodingHeader;
}
public async Task InvokeCodingRelaxed(string encodingIn, string messageIn, string encodingOut, string messageOut, long?contentLength, int statusCode)
{
Task NextRequestDelegate(HttpContext httpContext)
{
Assert.AreEqual(encodingOut, httpContext.Request.Headers.ContentEncoding.ToString());
Assert.AreEqual(contentLength, httpContext.Request.Headers.ContentLength);
Assert.AreEqual(messageOut, AsString(httpContext.Request.Body));
Assert.AreEqual(statusCode, httpContext.Response.StatusCode);
return(Task.CompletedTask);
}
var options = new RequestDecompressionOptions();
var logger = NullLogger <RequestDecompressionMiddleware> .Instance;
var httpContext = new DefaultHttpContext();
options.Providers.Add <TestDecompressionProviderA>();
options.AllowUnsupportedEncodings = true;
httpContext.Request.Headers.ContentEncoding = new(encodingIn.Split('+', StringSplitOptions.RemoveEmptyEntries));
httpContext.Request.Headers.ContentLength = 1L;
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(messageIn));
var middleware = new RequestDecompressionMiddleware(Options.Create(options), logger);
await middleware.InvokeAsync(httpContext, NextRequestDelegate);
Assert.AreEqual("", httpContext.Response.Headers.AcceptEncoding.ToString());
}
public void Options_InitializedWithDefaultProviders()
{
// Arrange
var defaultProviderCount = 3;
// Act
var options = new RequestDecompressionOptions();
// Assert
var providers = options.DecompressionProviders;
Assert.Equal(defaultProviderCount, providers.Count);
var brotliProvider = Assert.Contains("br", providers);
Assert.IsType <BrotliDecompressionProvider>(brotliProvider);
var deflateProvider = Assert.Contains("deflate", providers);
Assert.IsType <DeflateDecompressionProvider>(deflateProvider);
var gzipProvider = Assert.Contains("gzip", providers);
Assert.IsType <GZipDecompressionProvider>(gzipProvider);
}
public void AddProviderWithTypeWhenTypeDoesNotImplementInterface()
{
var options = new RequestDecompressionOptions();
Assert.ThrowsException <ArgumentException>(() =>
options.Providers.Add(typeof(TestDecompressionProvider01)));
}
public void AddProviderWithTypeWhenTypeIsNull()
{
var options = new RequestDecompressionOptions();
Assert.ThrowsException <ArgumentNullException>(() =>
options.Providers.Add(null));
}
public void AddProviderWithTypeWhenTypeDoesNotHaveAttribute()
{
var options = new RequestDecompressionOptions();
Assert.ThrowsException <ArgumentException>(() =>
options.Providers.Add(typeof(TestDecompressionProvider00)));
}
public async Task InvokeAsyncWhenRequestHasContentRangeHeader()
{
var options = new RequestDecompressionOptions();
options.Providers.Add <TestDecompressionProvider10>();
var serviceProviderMock = new Mock <IServiceProvider>(MockBehavior.Strict);
var optionsMock = new Mock <IOptions <RequestDecompressionOptions> >(MockBehavior.Strict);
optionsMock
.Setup(o => o.Value)
.Returns(options);
var loggerMock = new Mock <ILogger <RequestDecompressionMiddleware> >(MockBehavior.Loose);
loggerMock
.Setup(o => o.IsEnabled(It.IsAny <LogLevel>()))
.Returns(true);
var middleware = new RequestDecompressionMiddleware(serviceProviderMock.Object, optionsMock.Object, loggerMock.Object);
var content = "Hello World!";
var contentBytes = Encoding.UTF8.GetBytes(content);
var httpContext = new DefaultHttpContext();
httpContext.Request.Method = HttpMethods.Post;
httpContext.Request.Headers.Add(HeaderNames.ContentEncoding, "encoding");
httpContext.Request.Headers.Add(HeaderNames.ContentRange, "0-*/*");
httpContext.Request.Body = new TestRequestStream(contentBytes);
await middleware.InvokeAsync(httpContext, c => Task.CompletedTask);
Assert.AreEqual(0, httpContext.Response.Body.Length);
}
public void Constructor()
{
var options = new RequestDecompressionOptions();
Assert.IsTrue(options.SkipUnsupportedEncodings);
Assert.IsNotNull(options.Providers);
Assert.AreEqual(0, options.Providers.Count);
}
public void AddProviderWithType()
{
var options = new RequestDecompressionOptions();
options.Providers.Add(typeof(TestDecompressionProvider10));
Assert.IsNotNull(options.Providers);
Assert.AreEqual(1, options.Providers.Count);
Assert.IsTrue(options.Providers.Contains(typeof(TestDecompressionProvider10)));
}
private static RequestDecompressionMiddleware CreateMiddleware(bool relax, bool advertize)
{
var options = new RequestDecompressionOptions();
options.Providers.Add <TestRequestDecompressionProvider>();
options.AllowUnsupportedEncodings = relax;
options.AdvertiseSupportedEncodings = advertize;
return(new(Options.Create(options), NullLogger <RequestDecompressionMiddleware> .Instance));
}
private static RequestDecompressionMiddleware CreateMiddleware(bool advertize, int encodings)
{
var options = new RequestDecompressionOptions();
if (encodings > 0)
{
options.Providers.Add <TestRequestDecompressionProviderA>();
}
if (encodings > 1)
{
options.Providers.Add <TestRequestDecompressionProviderB>();
}
options.AdvertiseSupportedEncodings = advertize;
return(new(Options.Create(options), NullLogger <RequestDecompressionMiddleware> .Instance));
}
public void ConstructorWithDuplicateEncodings()
{
var options = new RequestDecompressionOptions();
options.Providers.Add <TestDecompressionProvider20>();
options.Providers.Add <TestDecompressionProvider21>();
var serviceProviderMock = new Mock <IServiceProvider>(MockBehavior.Strict);
var optionsMock = new Mock <IOptions <RequestDecompressionOptions> >(MockBehavior.Strict);
optionsMock
.Setup(o => o.Value)
.Returns(options);
var loggerMock = new Mock <ILogger <RequestDecompressionMiddleware> >(MockBehavior.Loose);
Assert.ThrowsException <InvalidOperationException>(() =>
new RequestDecompressionMiddleware(serviceProviderMock.Object, optionsMock.Object, loggerMock.Object));
}
private static void PostConfigure(RequestDecompressionOptions options)
{
options.Providers.TrimExcess();
}
private static void Configure(RequestDecompressionOptions options)
{
options.AllowUnsupportedEncodings = true;
options.Providers.Add <GzipRequestDecompressionProvider>();
options.Providers.Add <BrotliRequestDecompressionProvider>();
}
public async Task InvokeAsync(string encoding1, string encoding2, bool skipUnsupportedEncodings, int statusCode)
{
var options = new RequestDecompressionOptions();
options.Providers.Add <DeflateDecompressionProvider>();
options.Providers.Add <GzipDecompressionProvider>();
options.Providers.Add <BrotliDecompressionProvider>();
options.SkipUnsupportedEncodings = skipUnsupportedEncodings;
var loggerMock = new Mock <ILogger <RequestDecompressionMiddleware> >(MockBehavior.Loose);
loggerMock
.Setup(o => o.IsEnabled(It.IsAny <LogLevel>()))
.Returns(true);
var serviceProviderMock = new Mock <IServiceProvider>(MockBehavior.Strict);
var optionsMock = new Mock <IOptions <RequestDecompressionOptions> >(MockBehavior.Strict);
optionsMock
.Setup(o => o.Value)
.Returns(options);
var middleware = new RequestDecompressionMiddleware(serviceProviderMock.Object, optionsMock.Object, loggerMock.Object);
var content = "Hello World!";
var contentBytes1 = Encoding.UTF8.GetBytes(content);
var contentBytes2 = default(byte[]);
var encoding1Values = new StringValues(encoding1.Split(' ', StringSplitOptions.RemoveEmptyEntries));
var encoding2Values = new StringValues(encoding2.Split(' ', StringSplitOptions.RemoveEmptyEntries));
foreach (var encoding in encoding1Values)
{
contentBytes1 = CompressionEncoder.Encode(contentBytes1, encoding);
}
var httpContext = new DefaultHttpContext();
httpContext.Request.Method = HttpMethods.Post;
httpContext.Request.Headers.Add(HeaderNames.ContentEncoding, encoding1Values);
httpContext.Request.Body = new TestRequestStream(contentBytes1);
await middleware.InvokeAsync(httpContext, c => Task.CompletedTask);
if (statusCode == StatusCodes.Status200OK)
{
Assert.AreEqual(encoding2Values, httpContext.Request.Headers[HeaderNames.ContentEncoding]);
if (encoding2 == "")
{
if (httpContext.Request.Body is TestRequestStream)
{
contentBytes2 = ((TestRequestStream)httpContext.Request.Body).ToArray();
}
else
{
contentBytes2 = ((MemoryStream)httpContext.Request.Body).ToArray();
}
Assert.AreEqual(content, Encoding.UTF8.GetString(contentBytes2));
}
}
Assert.AreEqual(statusCode, httpContext.Response.StatusCode);
}
