add CombineLogsWithStreamCloseWorks test

Author: ExtraClock

src/Middleware/HttpLogging/test/HttpLoggingMiddlewareTests.cs

@@ -406,7 +406,7 @@ public async Task RequestBodyWithStreamCloseWorks(string expected)
                 // (1) The subsequent middleware reads right up to the buffer size (guided by the ContentLength header)
                 while (contentLengthBytesLeft > 0)
                 {
-                    var res = await c.Request.Body.ReadAsync(arr, 0, (int)Math.Min(arr.Length, contentLengthBytesLeft));
+                    var res = await c.Request.Body.ReadAsync(arr, 0, arr.Length);
                     contentLengthBytesLeft -= res;
                     if (res == 0)
                     {
@@ -1672,6 +1672,73 @@ public async Task CombineLogs_Exception_RequestLogged()
         Assert.Equal(lines.Length, i);
     }
 
+    [Theory]
+    [InlineData(HttpLoggingFields.RequestBody | HttpLoggingFields.ResponseBody, true, true)]
+    [InlineData(HttpLoggingFields.RequestBody, true, false)]
+    [InlineData(HttpLoggingFields.ResponseBody, false, true)]
+    public async Task CombineLogsWithStreamCloseWorks(HttpLoggingFields fields, bool hasRequestBody, bool hasResponseBody)
+    {
+        var options = CreateOptionsAccessor();
+        options.CurrentValue.LoggingFields = fields;
+        options.CurrentValue.CombineLogs = true;
+
+        var middleware = CreateMiddleware(
+            async c =>
+            {
+                var arr = new byte[4096];
+                var contentLengthBytesLeft = c.Request.Body.Length;
+
+                // (1) The subsequent middleware reads right up to the buffer size (guided by the ContentLength header)
+                while (contentLengthBytesLeft > 0)
+                {
+                    var res = await c.Request.Body.ReadAsync(arr, 0, arr.Length);
+                    contentLengthBytesLeft -= res;
+                    if (res == 0)
+                    {
+                        break;
+                    }
+                }
+
+                // (2) The subsequent middleware closes the request stream after its consumption
+                c.Request.Body.Close();
+
+
+                c.Response.ContentType = "text/plain";
+
+                // (3) The subsequent middleware writes its response
+                await c.Response.WriteAsync("test response");
+
+                // (4) The subsequent middleware closes the response stream after it has completed writing to it
+                c.Response.Body.Close();
+            },
+            options);
+
+        var httpContext = new DefaultHttpContext();
+        httpContext.Request.ContentType = "text/plain";
+        var requestBodyBuffer = Encoding.UTF8.GetBytes("test request");
+        httpContext.Request.Body = new MemoryStream(requestBodyBuffer);
+        httpContext.Request.ContentLength = requestBodyBuffer.Length;
+
+        await middleware.Invoke(httpContext);
+
+        var lines = Assert.Single(TestSink.Writes.Where(w => w.LogLevel >= LogLevel.Information)).Message.Split(Environment.NewLine);
+        var i = 0;
+        Assert.Equal("Request and Response:", lines[i++]);
+        if (fields.HasFlag(HttpLoggingFields.RequestBody))
+        {
+            Assert.Equal("RequestBody: test request", lines[i++]);
+            // Here we expect "Only partially consumed by app" status as the middleware reads request body right to its end,
+            // but never further as it follows the ContentLength header. From logging middleware perspective it looks like
+            // a partial consumption as it can't know for sure if it has been drained to the end or not.
+            Assert.Equal("RequestBodyStatus: [Only partially consumed by app]", lines[i++]);
+        }
+        if (fields.HasFlag(HttpLoggingFields.ResponseBody))
+        {
+            Assert.Equal("ResponseBody: test response", lines[i++]);
+        }
+        Assert.Equal(lines.Length, i);
+    }
+
     [Fact]
     public async Task ResponseInterceptorCanDisableResponseLogs()
     {