Create basic ConvertToActionResultAssertions.

Author: faddiv

src/FluentAssertions.AspNetCore.Mvc/ActionResultAssertionsOfTValue.cs

@@ -0,0 +1,55 @@
+#if NETCOREAPP3_0
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics;
+
+namespace FluentAssertions.AspNetCore.Mvc
+{
+    /// <summary>
+    /// Contains a number of methods to assert that an <see cref="ActionResult"/> is in the expected state.
+    /// </summary>
+    [DebuggerNonUserCode]
+    public class ActionResultAssertions<TValue> : ReferenceTypeAssertions<ActionResult<TValue>, ActionResultAssertions<TValue>>
+    {
+        #region Public Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ActionResultAssertions{TValue}" /> class.
+        /// </summary>
+        public ActionResultAssertions(ActionResult<TValue> subject)
+        {
+            Subject = subject;
+        }
+
+        #endregion Public Constructors
+
+        #region Protected Properties
+
+        /// <inheritdoc />
+        protected override string Identifier { get; } = $"ActionResult<{typeof(TValue).Name}>";
+
+        #endregion Protected Properties
+
+        #region Public Properties
+
+        /// <summary>
+        /// Gets the <see cref="ActionResult{TValue}.Result"/> of the actual Subjhect.
+        /// </summary>
+        public ActionResult Result => Subject.Result;
+
+        /// <summary>
+        /// Gets the <see cref="ActionResult{TValue}.Value"/> of the actual Subjhect.
+        /// </summary>
+        public TValue Value => Subject.Value;
+
+        #endregion Public Properties
+
+        #region Public Methods
+
+        /// TODO What should be here?
+        
+        #endregion Public Methods
+    }
+}
+#endif

src/FluentAssertions.AspNetCore.Mvc/AssertionsExtensions.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
 using Microsoft.AspNetCore.Routing;
 using System.Diagnostics;
 
@@ -36,5 +37,18 @@ public static RouteDataAssertions Should(this RouteData routeData)
         {
             return new RouteDataAssertions(routeData);
         }
+
+#if NETCOREAPP3_0
+
+        /// <summary>
+        /// Returns an <see cref="ConvertToActionResultAssertions"/> object that can be used to assert the
+        /// current <see cref="IConvertToActionResult"/>.
+        /// </summary>
+        public static ConvertToActionResultAssertions Should(this IConvertToActionResult actual)
+        {
+            return new ConvertToActionResultAssertions(actual);
+        }
+
+#endif
     }
 }

src/FluentAssertions.AspNetCore.Mvc/ConvertToActionResultAssertions.cs

@@ -0,0 +1,62 @@
+#if NETCOREAPP3_0
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FluentAssertions.AspNetCore.Mvc
+{
+    /// <summary>
+    /// Contains a number of methods to assert that an <see cref="IConvertToActionResult"/> is in the expected state.
+    /// </summary>
+    public class ConvertToActionResultAssertions : ReferenceTypeAssertions<IConvertToActionResult, ConvertToActionResultAssertions>
+    {
+        public ConvertToActionResultAssertions(IConvertToActionResult subject)
+        {
+            Subject = subject;
+        }
+
+        /// <inheritdoc />
+        protected override string Identifier => "IConvertToActionResult";
+
+        /// <summary>
+        /// Asserts that the subject is a <see cref="ActionResult{TValue}"/>.
+        /// </summary>
+        /// <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>
+        [CustomAssertion]
+        public ActionResultAssertions<TValue> BeActionResult<TValue>(string reason = "", params object[] reasonArgs)
+        {
+            Execute.Assertion
+                .BecauseOf(reason, reasonArgs)
+                .ForCondition(!(Subject is null))
+                .FailWith(FailureMessages.CommonNullWasSuppliedFailMessage, typeof(ActionResult<TValue>));
+
+            var type = Subject.GetType();
+
+            Execute.Assertion
+                .BecauseOf(reason, reasonArgs)
+                .ForCondition(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ActionResult<>))
+                .FailWith(FailureMessages.CommonTypeFailMessage, typeof(ActionResult<TValue>), Subject.GetType());
+
+            var genericParameter = type.GenericTypeArguments[0];
+
+            Execute.Assertion
+                .BecauseOf(reason, reasonArgs)
+                .ForCondition(genericParameter == typeof(TValue))
+                .FailWith("Expected {context} to be ActionResult<TValue> with type {0}{reason} but was {1}.", typeof(TValue), genericParameter);
+
+            return new ActionResultAssertions<TValue>((ActionResult<TValue>)Subject);
+        }
+    }
+}
+
+#endif

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

@@ -0,0 +1,30 @@
+#if NETCOREAPP3_0
+using FluentAssertions.AspNetCore.Mvc.Tests.Helpers;
+using FluentAssertions.Mvc.Tests.Helpers;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+using System;
+using Xunit;
+
+namespace FluentAssertions.AspNetCore.Mvc.Tests
+{
+    public class ActionResultAssertionsOfTValue_Tests
+    {
+        public const string Reason = FailureMessageHelper.Reason;
+        public readonly static object[] ReasonArgs = FailureMessageHelper.ReasonArgs;
+
+        #region Public Methods
+
+        [Fact]
+        public void Result_GivenActionResultOfTValue_ShouldReturnSameValue()
+        {
+            var actionResult = new BadRequestResult();
+            var result = new ActionResult<object>(actionResult);
+
+            result.Should().BeActionResult<object>().Result.Should().BeSameAs(actionResult);
+        }
+
+        #endregion Public Methods
+    }
+}
+#endif

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

@@ -0,0 +1,80 @@
+#if NETCOREAPP3_0
+using FluentAssertions.Mvc.Tests.Helpers;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Moq;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace FluentAssertions.AspNetCore.Mvc.Tests
+{
+    public class ConvertToActionResultAssertions_Tests
+    {
+        public const string Reason = FailureMessageHelper.Reason;
+        public readonly static object[] ReasonArgs = FailureMessageHelper.ReasonArgs;
+
+        [Fact]
+        public void BeActionResult_GivenActionResultOfTValue_ShouldPass()
+        {
+            var actionResult = new BadRequestResult();
+            IConvertToActionResult result = new ActionResult<object>(actionResult);
+
+            result.Should().BeActionResult<object>();
+        }
+
+        [Fact]
+        public void BeActionResult_GivenActionResultOfTValue_ShouldReturnActionResultAssertionsOfTValue()
+        {
+            var actionResult = new BadRequestResult();
+            IConvertToActionResult subject = new ActionResult<object>(actionResult);
+
+            var result = subject.Should().BeActionResult<object>();
+
+            result.Should().BeOfType<ActionResultAssertions<object>>();
+        }
+
+        [Fact]
+        public void BeActionResult_GivenNull_ShouldFail()
+        {
+            IConvertToActionResult result = null;
+            var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundNull(
+                "result", typeof(ActionResult<object>));
+
+            Action action = () => result.Should().BeActionResult<object>(Reason, ReasonArgs);
+
+            action.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
+
+        [Fact]
+        public void BeActionResult_GivenUnexpectedTValue_ShouldFail()
+        {
+            var actionResult = new BadRequestResult();
+            IConvertToActionResult result = new ActionResult<string>(actionResult);
+
+            Action action = () => result.Should().BeActionResult<int>(Reason, ReasonArgs);
+
+            action.Should().Throw<Exception>()
+                .WithMessage("Expected result to be ActionResult<TValue> with type System.Int32 because it is 10 but was System.String.");
+        }
+
+        [Fact]
+        public void BeActionResult_GivenUnexpectedType_ShouldFail()
+        {
+            IConvertToActionResult result = new Mock<IConvertToActionResult>().Object;
+            var failureMessage = FailureMessageHelper.ExpectedContextTypeXButFoundY(
+                "result", "Microsoft.AspNetCore.Mvc.ActionResult`1[System.Object]", result.GetType().FullName);
+
+            Action action = () => result.Should().BeActionResult<object>(Reason, ReasonArgs);
+
+            action.Should().Throw<Exception>()
+                .WithMessage(failureMessage);
+        }
+
+
+    }
+}
+
+#endif

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

@@ -72,7 +72,12 @@ private static object ToString(DateTimeOffset? expected)
 
         internal static string ExpectedContextTypeXButFoundY(string context, Type expected, Type actual)
         {
-            return $"Expected {context} to be of type {expected.FullName} but was {actual.FullName}.";
+            return ExpectedContextTypeXButFoundY(context, expected.FullName, actual.FullName);
+        }
+
+        internal static string ExpectedContextTypeXButFoundY(string context, string expected, string actual)
+        {
+            return $"Expected {context} to be of type {expected} but was {actual}.";
         }
 
         internal static string ExpectedContextTypeXButFoundNull(string context, Type expectedType)