Correct polarity of MediaTypeHeaderValue.IsSubsetOf()` checks and remove one conneg fallback

- #3138 part 2/2
- request's Content-Type header must be a subset of what an `IInputFormatter` can consume
  - `[Consumes]` is similar
- what an `IOutputFormatter` produces must be a subset of the request's Accept header
  - `FormatFilter` and `ObjectResult` are similar
- `ObjectResult` no longer falls back to `Content-Type` header if no `Accept` value is acceptable
- left `WebApiCompatShim` code alone for consistency with down-level `System.Net.Http.Formatting`
- correct tests to match new behaviour
  - do not test `Accept` values containing a `charset` parameter; that case is not valid

WIP:
- four test failures; something about comparing media types w/ charset included
- why do some localization tests fail in VS?

nits:
- add `InputFormatterTests`
- add / update comments and doc comments
- correct xUnit attributes in `ActionResultTest`; odd it doesn't show up in command-line runs

Author: dougbu

src/Microsoft.AspNet.Mvc.Core/ConsumesAttribute.cs

@@ -56,10 +56,10 @@ public void OnResourceExecuting(ResourceExecutingContext context)
                 MediaTypeHeaderValue requestContentType = null;
                 MediaTypeHeaderValue.TryParse(context.HttpContext.Request.ContentType, out requestContentType);
 
-                // Only execute if this is the last filter before calling the action.
-                // This ensures that we only run the filter which is closest to the action.
+                // Confirm the request's content type is more specific than a media type this action supports e.g. OK
+                // if client sent "text/plain" data and this action supports "text/*".
                 if (requestContentType != null &&
-                    !ContentTypes.Any(contentType => contentType.IsSubsetOf(requestContentType)))
+                    !ContentTypes.Any(contentType => requestContentType.IsSubsetOf(contentType)))
                 {
                     context.Result = new UnsupportedMediaTypeResult();
                 }
@@ -102,7 +102,9 @@ public bool Accept(ActionConstraintContext context)
                 return !isActionWithoutConsumeConstraintPresent;
             }
 
-            if (ContentTypes.Any(c => c.IsSubsetOf(requestContentType)))
+            // Confirm the request's content type is more specific than a media type this action supports e.g. OK
+            // if client sent "text/plain" data and this action supports "text/*".
+            if (ContentTypes.Any(contentType => requestContentType.IsSubsetOf(contentType)))
             {
                 return true;
             }

src/Microsoft.AspNet.Mvc.Core/Controllers/FilterActionInvoker.cs

@@ -183,7 +183,7 @@ public virtual async Task InvokeAsync()
             _cursor = new FilterCursor(_filters);
 
             ActionContext.ModelState.MaxAllowedErrors = _maxModelValidationErrors;
-            
+
             await InvokeAllAuthorizationFiltersAsync();
 
             // If Authorization Filters return a result, it's a short circuit because
@@ -663,7 +663,7 @@ private async Task<ActionExecutedContext> InvokeActionFilterAsync()
                                 "Microsoft.AspNet.Mvc.BeforeActionMethod",
                                 new
                                 {
-                                    actionContext = ActionContext, 
+                                    actionContext = ActionContext,
                                     arguments = _actionExecutingContext.ActionArguments,
                                     controller = _actionExecutingContext.Controller
                                 });

src/Microsoft.AspNet.Mvc.Core/Formatters/FormatFilter.cs

@@ -13,7 +13,7 @@
 namespace Microsoft.AspNet.Mvc.Formatters
 {
     /// <summary>
-    /// A filter which will use the format value in the route data or query string to set the content type on an 
+    /// A filter which will use the format value in the route data or query string to set the content type on an
     /// <see cref="ObjectResult" /> returned from an action.
     /// </summary>
     public class FormatFilter : IFormatFilter, IResourceFilter, IResultFilter
@@ -48,13 +48,13 @@ public FormatFilter(IOptions<MvcOptions> options, IActionContextAccessor actionC
         public MediaTypeHeaderValue ContentType { get; }
 
         /// <summary>
-        /// <c>true</c> if the current <see cref="FormatFilter"/> is active and will execute. 
+        /// <c>true</c> if the current <see cref="FormatFilter"/> is active and will execute.
         /// </summary>
         public bool IsActive { get; }
 
         /// <summary>
         /// As a <see cref="IResourceFilter"/>, this filter looks at the request and rejects it before going ahead if
-        /// 1. The format in the request doesnt match any format in the map.
+        /// 1. The format in the request does not match any format in the map.
         /// 2. If there is a conflicting producesFilter.
         /// </summary>
         /// <param name="context">The <see cref="ResourceExecutingContext"/>.</param>
@@ -67,7 +67,8 @@ public void OnResourceExecuting(ResourceExecutingContext context)
 
             if (!IsActive)
             {
-                return; // no format specified by user, so the filter is muted
+                // no format specified by user, so the filter is muted
+                return;
             }
 
             if (ContentType == null)
@@ -77,19 +78,22 @@ public void OnResourceExecuting(ResourceExecutingContext context)
                 return;
             }
 
+            // Determine media types this action supports.
             var responseTypeFilters = context.Filters.OfType<IApiResponseMetadataProvider>();
-            var contentTypes = new List<MediaTypeHeaderValue>();
-
+            var supportedMediaTypes = new List<MediaTypeHeaderValue>();
             foreach (var filter in responseTypeFilters)
             {
-                filter.SetContentTypes(contentTypes);
+                filter.SetContentTypes(supportedMediaTypes);
             }
 
-            if (contentTypes.Count != 0)
+            // Check if support is adequate for requested media type.
+            if (supportedMediaTypes.Count != 0)
             {
-                // We need to check if the action can generate the content type the user asked for. If it cannot, exit
-                // here with not found result. 
-                if (!contentTypes.Any(c => ContentType.IsSubsetOf(c)))
+                // We need to check if the action can generate the content type the user asked for. That is, treat the
+                // request's format and IApiResponseMetadataProvider-provided content types similarly to an Accept
+                // header and an output formatter's SupportedMediaTypes: Confirm action supports a more specific media
+                // type than requested e.g. OK if "text/*" requested and action supports "text/plain".
+                if (!supportedMediaTypes.Any(contentType => contentType.IsSubsetOf(ContentType)))
                 {
                     context.Result = new HttpNotFoundResult();
                 }

src/Microsoft.AspNet.Mvc.Core/Formatters/InputFormatter.cs

@@ -62,12 +62,17 @@ public virtual bool CanRead(InputFormatterContext context)
 
             var contentType = context.HttpContext.Request.ContentType;
             MediaTypeHeaderValue requestContentType;
-            if (!MediaTypeHeaderValue.TryParse(contentType, out requestContentType))
+            if (!MediaTypeHeaderValue.TryParse(contentType, out requestContentType) || requestContentType == null)
             {
                 return false;
             }
 
-            return SupportedMediaTypes.Any(supportedMediaType => supportedMediaType.IsSubsetOf(requestContentType));
+            // Confirm the request's content type is more specific than a media type this formatter supports e.g. OK if
+            // client sent "text/plain" data and this formatter supports "text/*".
+            return SupportedMediaTypes.Any(supportedMediaType =>
+            {
+                return requestContentType.IsSubsetOf(supportedMediaType);
+            });
         }
 
         /// <summary>

src/Microsoft.AspNet.Mvc.Core/Formatters/OutputFormatter.cs

@@ -77,6 +77,8 @@ public virtual IReadOnlyList<MediaTypeHeaderValue> GetSupportedContentTypes(
             {
                 List<MediaTypeHeaderValue> mediaTypes = null;
 
+                // Confirm this formatter supports a more specific media type than requested e.g. OK if "text/*"
+                // requested and formatter supports "text/plain". Treat contentType like it came from an Accept header.
                 foreach (var mediaType in _supportedMediaTypes)
                 {
                     if (mediaType.IsSubsetOf(contentType))
@@ -119,8 +121,7 @@ public virtual Encoding SelectCharacterEncoding(OutputFormatterContext context)
                 {
                     var requestCharset = requestContentType.Charset;
                     encoding = SupportedEncodings.FirstOrDefault(
-                                                            supportedEncoding =>
-                                                                requestCharset.Equals(supportedEncoding.WebName));
+                        supportedEncoding => requestCharset.Equals(supportedEncoding.WebName));
                 }
             }
 
@@ -151,10 +152,11 @@ public virtual bool CanWriteResult(OutputFormatterContext context, MediaTypeHead
             }
             else
             {
-                // Since supportedMedia Type is going to be more specific check if supportedMediaType is a subset
-                // of the content type which is typically what we get on acceptHeader.
-                mediaType = SupportedMediaTypes
-                                  .FirstOrDefault(supportedMediaType => supportedMediaType.IsSubsetOf(contentType));
+                // Confirm this formatter supports a more specific media type than requested e.g. OK if "text/*"
+                // requested and formatter supports "text/plain". contentType is typically what we got in an Accept
+                // header.
+                mediaType = SupportedMediaTypes.FirstOrDefault(
+                    supportedMediaType => supportedMediaType.IsSubsetOf(contentType));
             }
 
             if (mediaType != null)
@@ -201,11 +203,11 @@ public virtual void WriteResponseHeaders(OutputFormatterContext context)
             // Copy the media type as we don't want it to affect the next request
             selectedMediaType = selectedMediaType.Copy();
 
-            // Not text-based media types will use an encoding/charset - binary formats just ignore it. We want to
+            // Note text-based media types will use an encoding/charset - binary formats just ignore it. We want to
             // make this class work with media types that use encodings, and those that don't.
             //
             // The default implementation of SelectCharacterEncoding will read from the list of SupportedEncodings
-            // and will always choose a default encoding if any are supported. So, the only cases where the 
+            // and will always choose a default encoding if any are supported. So, the only cases where the
             // selectedEncoding can be null are:
             //
             // 1). No supported encodings - we assume this is a non-text format
@@ -237,21 +239,17 @@ private Encoding MatchAcceptCharacterEncoding(IList<StringWithQualityHeaderValue
             if (acceptCharsetHeaders != null && acceptCharsetHeaders.Count > 0)
             {
                 var sortedAcceptCharsetHeaders = acceptCharsetHeaders
-                                                    .Where(acceptCharset =>
-                                                                acceptCharset.Quality != HeaderQuality.NoMatch)
-                                                    .OrderByDescending(
-                                                        m => m, StringWithQualityHeaderValueComparer.QualityComparer);
+                    .Where(acceptCharset => acceptCharset.Quality != HeaderQuality.NoMatch)
+                    .OrderByDescending(m => m, StringWithQualityHeaderValueComparer.QualityComparer);
 
                 foreach (var acceptCharset in sortedAcceptCharsetHeaders)
                 {
                     var charset = acceptCharset.Value;
                     if (!string.IsNullOrWhiteSpace(charset))
                     {
-                        var encoding = SupportedEncodings.FirstOrDefault(
-                                                        supportedEncoding =>
-                                                            charset.Equals(supportedEncoding.WebName,
-                                                                           StringComparison.OrdinalIgnoreCase) ||
-                                                            charset.Equals("*", StringComparison.Ordinal));
+                        var encoding = SupportedEncodings.FirstOrDefault(supportedEncoding =>
+                            charset.Equals(supportedEncoding.WebName, StringComparison.OrdinalIgnoreCase) ||
+                            charset.Equals("*", StringComparison.Ordinal));
                         if (encoding != null)
                         {
                             return encoding;