ResponseCompression: set Content-Encoding and Vary headers for HEAD requests (#28464)

* ResponseCompression: set Content-Encoding and Vary headers for HEAD requests

* Feedback

Author: alefranz

src/Middleware/ResponseCompression/src/ResponseCompressionBody.cs

@@ -59,6 +59,12 @@ internal async Task FinishCompressionAsync()
             {
                 await _compressionStream.DisposeAsync();
             }
+
+            // Adds the compression headers for HEAD requests even if the body was not used.
+            if (!_compressionChecked && HttpMethods.IsHead(_context.Request.Method))
+            {
+                InitializeCompressionHeaders();
+            }
         }
 
         HttpsCompressionMode IHttpsCompressionFeature.Mode { get; set; } = HttpsCompressionMode.Default;
@@ -232,40 +238,49 @@ public override async Task WriteAsync(byte[] buffer, int offset, int count, Canc
             }
         }
 
-        private void OnWrite()
+        private void InitializeCompressionHeaders()
         {
-            if (!_compressionChecked)
+            if (_provider.ShouldCompressResponse(_context))
             {
-                _compressionChecked = true;
-                if (_provider.ShouldCompressResponse(_context))
-                {
-                    // If the MIME type indicates that the response could be compressed, caches will need to vary by the Accept-Encoding header
-                    var varyValues = _context.Response.Headers.GetCommaSeparatedValues(HeaderNames.Vary);
-                    var varyByAcceptEncoding = false;
+                // If the MIME type indicates that the response could be compressed, caches will need to vary by the Accept-Encoding header
+                var varyValues = _context.Response.Headers.GetCommaSeparatedValues(HeaderNames.Vary);
+                var varyByAcceptEncoding = false;
 
-                    for (var i = 0; i < varyValues.Length; i++)
+                for (var i = 0; i < varyValues.Length; i++)
+                {
+                    if (string.Equals(varyValues[i], HeaderNames.AcceptEncoding, StringComparison.OrdinalIgnoreCase))
                     {
-                        if (string.Equals(varyValues[i], HeaderNames.AcceptEncoding, StringComparison.OrdinalIgnoreCase))
-                        {
-                            varyByAcceptEncoding = true;
-                            break;
-                        }
+                        varyByAcceptEncoding = true;
+                        break;
                     }
+                }
 
-                    if (!varyByAcceptEncoding)
-                    {
-                        _context.Response.Headers.Append(HeaderNames.Vary, HeaderNames.AcceptEncoding);
-                    }
+                if (!varyByAcceptEncoding)
+                {
+                    _context.Response.Headers.Append(HeaderNames.Vary, HeaderNames.AcceptEncoding);
+                }
 
-                    var compressionProvider = ResolveCompressionProvider();
-                    if (compressionProvider != null)
-                    {
-                        _context.Response.Headers.Append(HeaderNames.ContentEncoding, compressionProvider.EncodingName);
-                        _context.Response.Headers.Remove(HeaderNames.ContentMD5); // Reset the MD5 because the content changed.
-                        _context.Response.Headers.Remove(HeaderNames.ContentLength);
+                var compressionProvider = ResolveCompressionProvider();
+                if (compressionProvider != null)
+                {
+                    _context.Response.Headers.Append(HeaderNames.ContentEncoding, compressionProvider.EncodingName);
+                    _context.Response.Headers.Remove(HeaderNames.ContentMD5); // Reset the MD5 because the content changed.
+                    _context.Response.Headers.Remove(HeaderNames.ContentLength);
+                }
+            }
+        }
 
-                        _compressionStream = compressionProvider.CreateStream(_innerStream);
-                    }
+        private void OnWrite()
+        {
+            if (!_compressionChecked)
+            {
+                _compressionChecked = true;
+
+                InitializeCompressionHeaders();
+
+                if (_compressionProvider != null)
+                {
+                    _compressionStream = _compressionProvider.CreateStream(_innerStream);
                 }
             }
         }

src/Middleware/ResponseCompression/test/ResponseCompressionMiddlewareTest.cs

@@ -119,6 +119,25 @@ public async Task Request_AcceptUnknown_NotCompressed()
             AssertLog(logMessages.Skip(2).First(), LogLevel.Debug, "No matching response compression provider found.");
         }
 
+        [Fact]
+        public async Task RequestHead_NoAcceptEncoding_Uncompressed()
+        {
+            var (response, logMessages) = await InvokeMiddleware(100, requestAcceptEncodings: null, responseType: TextPlain, httpMethod: HttpMethods.Head);
+
+            CheckResponseNotCompressed(response, expectedBodyLength: 100, sendVaryHeader: false);
+            AssertLog(logMessages.Single(), LogLevel.Debug, "No response compression available, the Accept-Encoding header is missing or invalid.");
+        }
+
+        [Fact]
+        public async Task RequestHead_AcceptGzipDeflate_CompressedGzip()
+        {
+            var (response, logMessages) = await InvokeMiddleware(100, requestAcceptEncodings: new[] { "gzip", "deflate" }, responseType: TextPlain, httpMethod: HttpMethods.Head);
+
+            // Per RFC 7231, section 4.3.2, the Content-Lenght header can be omitted on HEAD requests.
+            CheckResponseCompressed(response, expectedBodyLength: null, expectedEncoding: "gzip");
+            AssertCompressedWithLog(logMessages, "gzip");
+        }
+
         [Theory]
         [InlineData("text/plain")]
         [InlineData("text/PLAIN")]
@@ -1154,7 +1173,8 @@ public async Task Dispose_SyncWriteOrFlushNotCalled(string encoding)
             string[] requestAcceptEncodings,
             string responseType,
             Action<HttpResponse> addResponseAction = null,
-            Action<ResponseCompressionOptions> configure = null)
+            Action<ResponseCompressionOptions> configure = null,
+            string httpMethod = "GET")
         {
             var sink = new TestSink(
                 TestSink.EnableWithTypeName<ResponseCompressionProvider>,
@@ -1178,6 +1198,13 @@ public async Task Dispose_SyncWriteOrFlushNotCalled(string encoding)
                         {
                             context.Response.Headers[HeaderNames.ContentMD5] = "MD5";
                             context.Response.ContentType = responseType;
+
+                            if (HttpMethods.IsHead(context.Request.Method))
+                            {
+                                context.Response.ContentLength = uncompressedBodyLength;
+                                return Task.CompletedTask;
+                            }
+
                             addResponseAction?.Invoke(context.Response);
                             return context.Response.WriteAsync(new string('a', uncompressedBodyLength));
                         });
@@ -1189,7 +1216,7 @@ public async Task Dispose_SyncWriteOrFlushNotCalled(string encoding)
             var server = host.GetTestServer();
             var client = server.CreateClient();
 
-            var request = new HttpRequestMessage(HttpMethod.Get, "");
+            var request = new HttpRequestMessage(new HttpMethod(httpMethod), "");
             for (var i = 0; i < requestAcceptEncodings?.Length; i++)
             {
                 request.Headers.AcceptEncoding.Add(System.Net.Http.Headers.StringWithQualityHeaderValue.Parse(requestAcceptEncodings[i]));
@@ -1200,7 +1227,7 @@ public async Task Dispose_SyncWriteOrFlushNotCalled(string encoding)
             return (response, sink.Writes.ToList());
         }
 
-        private void CheckResponseCompressed(HttpResponseMessage response, int expectedBodyLength, string expectedEncoding)
+        private void CheckResponseCompressed(HttpResponseMessage response, long? expectedBodyLength, string expectedEncoding)
         {
             var containsVaryAcceptEncoding = false;
             foreach (var value in response.Headers.GetValues(HeaderNames.Vary))
@@ -1217,7 +1244,7 @@ private void CheckResponseCompressed(HttpResponseMessage response, int expectedB
             Assert.Equal(expectedBodyLength, response.Content.Headers.ContentLength);
         }
 
-        private void CheckResponseNotCompressed(HttpResponseMessage response, int expectedBodyLength, bool sendVaryHeader)
+        private void CheckResponseNotCompressed(HttpResponseMessage response, long? expectedBodyLength, bool sendVaryHeader)
         {
             if (sendVaryHeader)
             {