Implement ObjectResultAssertions.ContainsContentType

Author: faddiv

src/FluentAssertions.AspNetCore.Mvc/ObjectResultAssertionsBase.cs

@@ -12,7 +12,7 @@ namespace FluentAssertions.AspNetCore.Mvc
     /// <summary>
     /// Base class for <see cref="ObjectResultAssertions"/>.
     /// </summary>
-    //[DebuggerNonUserCode]
+    [DebuggerNonUserCode]
     public class ObjectResultAssertionsBase<TObjectResult, TObjectResultAssertion> : ObjectAssertions
         where TObjectResult : ObjectResult
         where TObjectResultAssertion : ObjectResultAssertionsBase<TObjectResult, TObjectResultAssertion>
@@ -108,6 +108,38 @@ public TObjectResultAssertion ContainsFormatter(Expression<Func<IOutputFormatter
 
             return (TObjectResultAssertion)this;
         }
+
+        /// <summary>
+        /// Asserts that the <see cref="ObjectResult.ContentTypes"/> contains the specified content type.
+        /// </summary>
+        /// <param name="expected">The expectation content type.</param>
+        /// <param name="reason">
+        ///     A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        ///     is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="reasonArgs">
+        ///     Zero or more objects to format using the placeholders in <paramref name="reason"/>.
+        /// </param>
+        public TObjectResultAssertion ContainsContentType(string expected, string reason = "", params object[] reasonArgs)
+        {
+            var formatters = ObjectResultSubject.ContentTypes;
+
+            if (formatters is null)
+            {
+                Execute.Assertion
+                    .BecauseOf(reason, reasonArgs)
+                    .WithDefaultIdentifier(Identifier + ".ContentTypes")
+                    .FailWith("Expected {context} to contain {0}{reason} but found {1}.", expected, formatters);
+            }
+
+            Execute.Assertion
+                .ForCondition(formatters.Contains(expected))
+                .WithDefaultIdentifier(Identifier + ".ContentTypes")
+                .BecauseOf(reason, reasonArgs)
+                .FailWith("Expected {context} {0} to contain {1}{reason}.", formatters, expected);
+
+            return (TObjectResultAssertion)this;
+        }
         #endregion
 
     }

tests/FluentAssertions.AspNetCore.Mvc.Tests/Helpers/FailureMessageHelper.cs

@@ -71,16 +71,21 @@ private static object ToString(DateTimeOffset? expected)
             return "<null>";
         }
 
-        internal static string ExpectedToContainItemButFoundNull(string context, string predicate)
+        internal static string ExpectedToContainItemButFoundNull(string context, object item)
         {
-            return $"Expected {context} to contain {predicate} because it is 10 but found <null>.";
+            return $"Expected {context} to contain {Formatter.ToString(item)} because it is 10 but found <null>.";
         }
 
         internal static string ExpectedToHaveItemMatching(string context, object list, string predicate)
         {
             return $"Expected {context} {Formatter.ToString(list)} to have an item matching {predicate} because it is 10.";
         }
 
+        internal static string ExpectedToContainItem(string context, object list, string expected)
+        {
+            return $"Expected {context} {Formatter.ToString(list)} to contain {Formatter.ToString(expected)} because it is 10.";
+        }
+
         internal static string ExpectedContextTypeXButFoundY(string context, Type expected, Type actual)
         {
             return ExpectedContextTypeXButFoundY(context, expected.FullName, actual.FullName);

tests/FluentAssertions.AspNetCore.Mvc.Tests/ObjectResultAssertions_Tests.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Linq.Expressions;
+using System.Net.Http.Headers;
 using FluentAssertions.Mvc.Tests.Helpers;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Formatters;
@@ -73,11 +75,12 @@ public void ContainsFormatter_OnNullFormatters_ShouldFail()
             {
                 Formatters = null
             };
+            Expression<Func<IOutputFormatter, bool>> expectation = formatter => formatter == null;
             string failureMessage = FailureMessageHelper.ExpectedToContainItemButFoundNull(
                 "ObjectResult.Formatters",
-                "(formatter == null)");
+                expectation.Body);
 
-            Action a = () => result.Should().BeObjectResult().ContainsFormatter(formatter => formatter == null, Reason, ReasonArgs);
+            Action a = () => result.Should().BeObjectResult().ContainsFormatter(expectation, Reason, ReasonArgs);
 
             a.Should().Throw<Exception>()
                 .WithMessage(failureMessage);
@@ -102,5 +105,60 @@ public void ContainsFormatter_GivenUnexpected_ShouldFail()
                 .WithMessage(failureMessage);
         }
 
+
+
+
+
+
+        [Fact]
+        public void ContainsContentType_GivenExpected_ShouldPass()
+        {
+            var mediaType = "text/html";
+            var result = new ObjectResult(TestValue)
+            {
+                ContentTypes = { mediaType }
+            };
+
+            result.Should().BeObjectResult().ContainsContentType(mediaType);
+        }
+#if NETCOREAPP2_1
+        // In NetCore3.1 ContentTypes cant be null.
+        [Fact]
+        public void ContainsContentType_OnNullMediaType_ShouldFail()
+        {
+            var expected = "text/json";
+            var result = new ObjectResult(TestValue)
+            {
+                ContentTypes = null
+            };
+            string failureMessage = FailureMessageHelper.ExpectedToContainItemButFoundNull(
+                "ObjectResult.ContentTypes",
+                expected);
+
+            Action a = () => result.Should().BeObjectResult().ContainsContentType(expected, Reason, ReasonArgs);
+
+            a.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
+#endif
+        [Fact]
+        public void ContainsContentType_GivenUnexpected_ShouldFail()
+        {
+            var mediaType = "text/html";
+            var expected = "text/json";
+            var result = new ObjectResult(TestValue)
+            {
+                ContentTypes = { mediaType }
+            };
+            string failureMessage = FailureMessageHelper.ExpectedToContainItem(
+                "ObjectResult.ContentTypes",
+                result.ContentTypes,
+                expected);
+
+            Action a = () => result.Should().BeObjectResult().ContainsContentType(expected, Reason, ReasonArgs);
+
+            a.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
     }
 }