Add ContainsFormatter To ObjectResultAssertions.

Author: faddiv

src/FluentAssertions.AspNetCore.Mvc/ObjectResultAssertionsBase.cs

@@ -1,14 +1,18 @@
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using System;
 using System.Diagnostics;
+using System.Linq;
+using System.Linq.Expressions;
 
 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>
@@ -67,6 +71,43 @@ public TValue ValueAs<TValue>()
 
             return (TValue)value;
         }
+
+        /// <summary>
+        /// Asserts that the <see cref="ObjectResult.Formatters"/> contains at least one item that matches the predicate.
+        /// </summary>
+        /// <param name="expectation">A predicate to match the items in the <see cref="ObjectResult.Formatters"/> against.</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 ContainsFormatter(Expression<Func<IOutputFormatter, bool>> expectation, string reason = "", params object[] reasonArgs)
+        {
+            if (expectation is null)
+                throw new ArgumentNullException(nameof(expectation));
+
+            var formatters = ObjectResultSubject.Formatters;
+
+            if (formatters is null)
+            {
+                Execute.Assertion
+                    .BecauseOf(reason, reasonArgs)
+                    .WithDefaultIdentifier(Identifier + ".Formatters")
+                    .FailWith("Expected {context} to contain {0}{reason} but found {1}.", expectation.Body, formatters);
+            }
+
+            var func = expectation.Compile();
+
+            Execute.Assertion
+                .ForCondition(formatters.Any(func))
+                .WithDefaultIdentifier(Identifier+ ".Formatters")
+                .BecauseOf(reason, reasonArgs)
+                .FailWith("Expected {context} {0} to have an item matching {1}{reason}.", formatters, expectation.Body);
+
+            return (TObjectResultAssertion)this;
+        }
         #endregion
 
     }

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

@@ -1,4 +1,5 @@
-using System;
+using FluentAssertions.Formatting;
+using System;
 using System.Globalization;
 using System.Linq;
 using System.Text;
@@ -70,6 +71,16 @@ private static object ToString(DateTimeOffset? expected)
             return "<null>";
         }
 
+        internal static string ExpectedToContainItemButFoundNull(string context, string predicate)
+        {
+            return $"Expected {context} to contain {predicate} 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 ExpectedContextTypeXButFoundY(string context, Type expected, Type actual)
         {
             return ExpectedContextTypeXButFoundY(context, expected.FullName, actual.FullName);

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

@@ -0,0 +1,106 @@
+using System;
+using FluentAssertions.Mvc.Tests.Helpers;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Moq;
+using Xunit;
+
+namespace FluentAssertions.AspNetCore.Mvc.Tests
+{
+    public class ObjectResultAssertions_Tests
+    {
+        private const string TestValue = "testValue";
+        public const string Reason = FailureMessageHelper.Reason;
+        public readonly static object[] ReasonArgs = FailureMessageHelper.ReasonArgs;
+
+        [Fact]
+        public void Value_GivenObjectResult_ShouldHaveTheSameValue()
+        {
+            var result = new ObjectResult(TestValue);
+            result.Should().BeObjectResult().Value.Should().BeSameAs(TestValue);
+        }
+
+        [Fact]
+        public void ValueAs_GivenObjectResult_ShouldHaveTheSameValue()
+        {
+            var result = new ObjectResult(TestValue);
+
+            result.Should().BeObjectResult().ValueAs<string>().Should().BeSameAs(TestValue);
+        }
+
+        [Fact]
+        public void ValueAs_GivenWrongType_ShouldFail()
+        {
+            var result = new ObjectResult(TestValue);
+            string failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundY(
+                "ObjectResult.Value", typeof(int), typeof(string));
+
+            Action a = () => result.Should().BeObjectResult().ValueAs<int>().Should().Be(2);
+
+            a.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
+
+        [Fact]
+        public void ValueAs_Null_ShouldFail()
+        {
+            ActionResult result = new ObjectResult(null);
+            string failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundNull(
+                "ObjectResult.Value", typeof(object));
+
+            Action a = () => result.Should().BeObjectResult().ValueAs<object>();
+
+            a.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
+
+        [Fact]
+        public void ContainsFormatter_GivenExpected_ShouldPass()
+        {
+            var formatterMock = new Mock<IOutputFormatter>();
+            var result = new ObjectResult(TestValue)
+            {
+                Formatters = { formatterMock.Object }
+            };
+
+            result.Should().BeObjectResult().ContainsFormatter(formatter => ReferenceEquals(formatter, formatterMock.Object));
+        }
+
+        [Fact]
+        public void ContainsFormatter_OnNullFormatters_ShouldFail()
+        {
+            var result = new ObjectResult(TestValue)
+            {
+                Formatters = null
+            };
+            string failureMessage = FailureMessageHelper.ExpectedToContainItemButFoundNull(
+                "ObjectResult.Formatters",
+                "(formatter == null)");
+
+            Action a = () => result.Should().BeObjectResult().ContainsFormatter(formatter => formatter == null, Reason, ReasonArgs);
+
+            a.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
+
+        [Fact]
+        public void ContainsFormatter_GivenUnexpected_ShouldFail()
+        {
+            var formatterMock = new Mock<IOutputFormatter>();
+            var result = new ObjectResult(TestValue)
+            {
+                Formatters = { formatterMock.Object }
+            };
+            string failureMessage = FailureMessageHelper.ExpectedToHaveItemMatching(
+                "ObjectResult.Formatters",
+                result.Formatters, 
+                "False");
+
+            Action a = () => result.Should().BeObjectResult().ContainsFormatter(formatter => false, Reason, ReasonArgs);
+
+            a.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
+
+    }
+}