add option to disable partial response for the current request

Author: dotarj

src/PartialResponse.AspNetCore.Mvc.Formatters.Json/HttpRequestExtensions.cs

@@ -1,49 +1,25 @@
 // Copyright (c) Arjen Post. See License.txt and Notice.txt in the project root for license information.
 
 using System;
+using PartialResponse.AspNetCore.Mvc.Formatters;
 using PartialResponse.Core;
 
 namespace Microsoft.AspNetCore.Http
 {
     public static class HttpRequestExtensions
     {
-        private const string BypassPartialResponse = "BypassPartialResponse";
-
         /// <summary>
-        /// Sets a value indicating whether partial response should be bypassed.
+        /// Indicates that partial response should be bypassed for the current request.
         /// </summary>
-        /// <param name="value">The value.</param>
-        /// <param name="request">The HTTP request.</param>
-        public static void SetBypassPartialResponse(this HttpRequest request, bool value)
+        /// <param name="request">The <see cref="HttpRequest"/>.</param>
+        public static void BypassPartialResponse(this HttpRequest request)
         {
             if (request == null)
             {
                 throw new ArgumentNullException("request");
             }
 
-            request.HttpContext.Items.Add(BypassPartialResponse, value);
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether partial response should be bypassed.
-        /// </summary>
-        /// <param name="request">The HTTP request.</param>
-        /// <returns>True if partial response should be bypassed, otherwise false.</returns>
-        public static bool GetBypassPartialResponse(this HttpRequest request)
-        {
-            if (request == null)
-            {
-                throw new ArgumentNullException("request");
-            }
-
-            object value;
-
-            if (request.HttpContext.Items.TryGetValue(BypassPartialResponse, out value))
-            {
-                return (bool)value;
-            }
-
-            return false;
+            request.HttpContext.Items[PartialJsonOutputFormatter.BypassPartialResponseKey] = null;
         }
 
         internal static bool TryGetFields(this HttpRequest request, out Fields? result)

src/PartialResponse.AspNetCore.Mvc.Formatters.Json/PartialJsonOutputFormatter.cs

@@ -18,6 +18,8 @@ namespace PartialResponse.AspNetCore.Mvc.Formatters
     /// </summary>
     public class PartialJsonOutputFormatter : TextOutputFormatter
     {
+        internal const string BypassPartialResponseKey = "BypassPartialResponse";
+
         private readonly IArrayPool<char> _charPool;
         private readonly bool _ignoreCase;
 
@@ -101,6 +103,26 @@ protected virtual JsonSerializer CreateJsonSerializer()
             return _serializer;
         }
 
+        /// <summary>
+        /// Returns a value that indicates whether partial response should be bypassed for the current request.
+        /// </summary>
+        /// <param name="httpContext">The <see cref="HttpContext"/>.</param>
+        /// <returns>true if the partial response should be bypassed; otherwise, false.</returns>
+        protected virtual bool ShouldBypassPartialResponse(HttpContext httpContext)
+        {
+            if (httpContext == null)
+            {
+                throw new ArgumentNullException(nameof(httpContext));
+            }
+
+            if (httpContext.Items.ContainsKey(BypassPartialResponseKey))
+            {
+                return true;
+            }
+
+            return httpContext.Response.StatusCode != 200;
+        }
+
         /// <inheritdoc />
         public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
         {
@@ -117,13 +139,16 @@ public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext co
             var request = context.HttpContext.Request;
             var response = context.HttpContext.Response;
 
-            Fields? fields;
+            Fields? fields = null;
 
-            if (!request.TryGetFields(out fields))
+            if (!this.ShouldBypassPartialResponse(context.HttpContext))
             {
-                response.StatusCode = 400;
+                if (!request.TryGetFields(out fields))
+                {
+                    response.StatusCode = 400;
 
-                return;
+                    return;
+                }
             }
 
             using (var writer = context.WriterFactory(response.Body, selectedEncoding))

test/PartialResponse.AspNetCore.Mvc.Formatters.Json.Test/PartialJsonOutputFormatterTests.cs

@@ -1,4 +1,5 @@
 using System.Buffers;
+using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using System.Threading.Tasks;
@@ -13,6 +14,7 @@ namespace PartialResponse.AspNetCore.Mvc.Formatters.Json
     public class PartialJsonOutputFormatterTests
     {
         private readonly HttpContext httpContext = Mock.Of<HttpContext>();
+        private readonly Dictionary<object, object> httpContextItems = new Dictionary<object, object>();
         private readonly HttpRequest httpRequest = Mock.Of<HttpRequest>();
         private readonly HttpResponse httpResponse = Mock.Of<HttpResponse>();
         private readonly IQueryCollection queryCollection = Mock.Of<IQueryCollection>();
@@ -31,12 +33,24 @@ public PartialJsonOutputFormatterTests()
             Mock.Get(this.httpContext)
                 .SetupGet(httpContext => httpContext.Response)
                 .Returns(this.httpResponse);
+
+            Mock.Get(this.httpContext)
+                .SetupGet(httpContext => httpContext.Items)
+                .Returns(this.httpContextItems);
+
+            Mock.Get(this.httpRequest)
+                .SetupGet(httpRequest => httpRequest.HttpContext)
+                .Returns(this.httpContext);
         }
 
         [Fact]
         public async Task TheWriteResponseBodyAsyncMethodShouldReturnStatusCode400IfFieldsMalformed()
         {
             // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(200);
+
             Mock.Get(this.queryCollection)
                 .Setup(queryCollection => queryCollection.ContainsKey("fields"))
                 .Returns(true);
@@ -60,6 +74,10 @@ public async Task TheWriteResponseBodyAsyncMethodShouldReturnStatusCode400IfFiel
         public async Task TheWriteResponseBodyAsyncMethodShouldNotWriteBodyIfFieldsMalformed()
         {
             // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(200);
+
             Mock.Get(this.queryCollection)
                 .Setup(queryCollection => queryCollection.ContainsKey("fields"))
                 .Returns(true);
@@ -82,6 +100,10 @@ public async Task TheWriteResponseBodyAsyncMethodShouldNotWriteBodyIfFieldsMalfo
         public async Task TheWriteResponseBodyAsyncMethodShouldNotApplyFieldsIfNotSupplied()
         {
             // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(200);
+
             Mock.Get(this.queryCollection)
                 .Setup(queryCollection => queryCollection.ContainsKey("fields"))
                 .Returns(false);
@@ -102,6 +124,10 @@ public async Task TheWriteResponseBodyAsyncMethodShouldNotApplyFieldsIfNotSuppli
         public async Task TheWriteResponseBodyAsyncMethodShouldApplyFieldsIfSupplied()
         {
             // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(200);
+
             Mock.Get(this.queryCollection)
                 .Setup(queryCollection => queryCollection.ContainsKey("fields"))
                 .Returns(true);
@@ -126,6 +152,10 @@ public async Task TheWriteResponseBodyAsyncMethodShouldApplyFieldsIfSupplied()
         public async Task TheWriteResponseBodyAsyncMethodShouldIgnoreCase()
         {
             // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(200);
+
             Mock.Get(this.queryCollection)
                 .Setup(queryCollection => queryCollection.ContainsKey("fields"))
                 .Returns(true);
@@ -150,6 +180,10 @@ public async Task TheWriteResponseBodyAsyncMethodShouldIgnoreCase()
         public async Task TheWriteResponseBodyAsyncMethodShouldNotIgnoreCase()
         {
             // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(200);
+
             Mock.Get(this.queryCollection)
                 .Setup(queryCollection => queryCollection.ContainsKey("fields"))
                 .Returns(true);
@@ -169,5 +203,63 @@ public async Task TheWriteResponseBodyAsyncMethodShouldNotIgnoreCase()
             // Assert
             Assert.Equal("{}", this.body.ToString());
         }
+
+        [Fact]
+        public async Task TheWriteResponseBodyAsyncMethodShouldBypassPartialResponseIfConfigured()
+        {
+            // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(200);
+
+            Mock.Get(this.queryCollection)
+                .Setup(queryCollection => queryCollection.ContainsKey("fields"))
+                .Returns(true);
+
+            Mock.Get(this.queryCollection)
+                .SetupGet(queryCollection => queryCollection["fields"])
+                .Returns("");
+
+            this.httpRequest.BypassPartialResponse();
+
+            var value = new { foo = "bar" };
+
+            var writeContext = new OutputFormatterWriteContext(this.httpContext, (stream, encoding) => new StringWriter(this.body), typeof(object), value);
+            var formatter = new PartialJsonOutputFormatter(new JsonSerializerSettings(), Mock.Of<ArrayPool<char>>(), false);
+
+            // Act
+            await formatter.WriteResponseBodyAsync(writeContext, Encoding.UTF8);
+
+            // Assert
+            Assert.Equal("{\"foo\":\"bar\"}", this.body.ToString());
+        }
+
+        [Fact]
+        public async Task TheWriteResponseBodyAsyncMethodShouldBypassPartialResponseIfStatusCodeIsNot200()
+        {
+            // Arrange
+            Mock.Get(this.httpResponse)
+                .SetupGet(httpResponse => httpResponse.StatusCode)
+                .Returns(500);
+
+            Mock.Get(this.queryCollection)
+                .Setup(queryCollection => queryCollection.ContainsKey("fields"))
+                .Returns(true);
+
+            Mock.Get(this.queryCollection)
+                .SetupGet(queryCollection => queryCollection["fields"])
+                .Returns("");
+
+            var value = new { foo = "bar" };
+
+            var writeContext = new OutputFormatterWriteContext(this.httpContext, (stream, encoding) => new StringWriter(this.body), typeof(object), value);
+            var formatter = new PartialJsonOutputFormatter(new JsonSerializerSettings(), Mock.Of<ArrayPool<char>>(), false);
+
+            // Act
+            await formatter.WriteResponseBodyAsync(writeContext, Encoding.UTF8);
+
+            // Assert
+            Assert.Equal("{\"foo\":\"bar\"}", this.body.ToString());
+        }
     }
 }