Added .ShouldReturn().ActionResult<TResult>() assertion chain for action results (#359)

Author: ivaylokenov

src/MyTested.AspNetCore.Mvc.Abstractions/Utilities/Extensions/TupleExtensions.cs

@@ -9,9 +9,15 @@ public static (string, string) GetTypeComparisonNames(this (Type Expected, Type
             var expected = typeTuple.Expected;
             var actual = typeTuple.Actual;
 
-            var useFullName = expected?.Name == actual?.Name;
+            var expectedName = expected?.ToFriendlyTypeName();
+            var actualName = actual?.ToFriendlyTypeName();
 
-            return (expected.ToFriendlyTypeName(useFullName), actual.ToFriendlyTypeName(useFullName));
+            if (expectedName == actualName)
+            {
+                return (expected.ToFriendlyTypeName(true), actual.ToFriendlyTypeName(true));
+            }
+                
+            return (expectedName, actualName);
         }
     }
 }

src/MyTested.AspNetCore.Mvc.Abstractions/Utilities/Validators/InvocationResultValidator.cs

@@ -39,8 +39,14 @@ public static void ValidateInvocationResultType(
         public static void ValidateInvocationResultType<TExpectedType>(
             ComponentTestContext testContext,
             bool canBeAssignable = false,
-            bool allowDifferentGenericTypeDefinitions = false) 
-            => ValidateInvocationResultType(testContext, typeof(TExpectedType), canBeAssignable, allowDifferentGenericTypeDefinitions);
+            bool allowDifferentGenericTypeDefinitions = false,
+            Type typeOfActualReturnValue = null) 
+            => ValidateInvocationResultType(
+                testContext, 
+                typeof(TExpectedType), 
+                canBeAssignable, 
+                allowDifferentGenericTypeDefinitions,
+                typeOfActualReturnValue);
 
         public static void ValidateInvocationResultTypes(
             ComponentTestContext testContext,

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Actions/ShouldReturn/ShouldReturnActionResultTestBuilder.cs

@@ -13,7 +13,8 @@
     /// </summary>
     /// <typeparam name="TActionResult">Result from invoked action in ASP.NET Core MVC controller.</typeparam>
     public class ShouldReturnActionResultTestBuilder<TActionResult>
-        : ShouldReturnTestBuilder<TActionResult>, IShouldReturnActionResultTestBuilder<TActionResult>
+        : ShouldReturnTestBuilder<TActionResult>, 
+        IShouldReturnActionResultTestBuilder<TActionResult>
     {
         private static readonly Type ActionResultType = typeof(IActionResult);
         private static readonly Type GenericActionResultType = typeof(ActionResult<>);
@@ -45,6 +46,15 @@ IAndTestBuilder IShouldReturnActionResultTestBuilder<TActionResult>.ActionResult
             return new AndTestBuilder(this.TestContext);
         }
 
+        IAndTestBuilder IShouldReturnActionResultTestBuilder<TActionResult>.ActionResult<TResult>()
+        {
+            InvocationResultValidator.ValidateInvocationResultType<ActionResult<TResult>>(
+                this.TestContext,
+                typeOfActualReturnValue: this.TestContext.Method.ReturnType);
+
+            return new AndTestBuilder(this.TestContext);
+        }
+
         private void ValidateActionResults() 
             => InvocationResultValidator.ValidateInvocationResultTypes(
                 this.TestContext,

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Contracts/Actions/IShouldReturnActionResultTestBuilder.cs

@@ -18,15 +18,22 @@ public interface IShouldReturnActionResultTestBuilder<TActionResult>
         /// <returns>Test builder of <see cref="IAndTestBuilder"/> type.</returns>
         IAndTestBuilder ActionResult();
 
+        /// <summary>
         /// Tests whether the action result is <see cref="Microsoft.AspNetCore.Mvc.IActionResult"/>,
         /// <see cref="Microsoft.AspNetCore.Mvc.ActionResult"/> or
         /// <see cref="Microsoft.AspNetCore.Mvc.ActionResult{TResult}"/>.
+        /// </summary>
         /// <param name="actionResultTestBuilder">Test builder which asserts the actual action result.</param>
         /// <returns>Test builder of <see cref="IAndTestBuilder"/> type.</returns>
         IAndTestBuilder ActionResult(Action<IShouldReturnTestBuilder<TActionResult>> actionResultTestBuilder);
 
-        //// ActionResult<TResult>, consider OkResult for example to be valid too? 
-        //IAndTestBuilder ActionResult<TResult>();
+        /// <summary>
+        /// Tests whether the action result is
+        /// <see cref="Microsoft.AspNetCore.Mvc.ActionResult{TResult}"/>.
+        /// </summary>
+        /// <typeparam name="TResult">Type of the expected result.</typeparam>
+        /// <returns>Test builder of <see cref="IAndTestBuilder"/> type.</returns>
+        IAndTestBuilder ActionResult<TResult>();
 
         //// ActionResult<TResult>, consider OkResult for example to be valid too? with additional options to specify the result - Ok() for example
         //IAndTestBuilder ActionResult<TResult>(Action<IShouldReturnTestBuilder<TActionResult>> actionResultTestBuilder);

test/MyTested.AspNetCore.Mvc.Controllers.Test/BuildersTests/ActionsTests/ShouldReturnTests/ShouldReturnActionResultTests.cs

@@ -19,7 +19,7 @@ public void ShouldReturnActionResultShouldNotThrowExceptionWhenResultIsIActionRe
         }
 
         [Fact]
-        public void ShouldReturnActionResultShouldNotThrowExceptionWhenResultIsIActionResultBaseClass()
+        public void ShouldReturnActionResultShouldNotThrowExceptionWhenResultIsActionResultBaseClass()
         {
             MyController<MvcController>
                 .Instance()
@@ -66,7 +66,7 @@ public void ShouldReturnActionResultWithDetailsShouldNotThrowExceptionWhenResult
         }
 
         [Fact]
-        public void ShouldReturnActionResultWithDetailsShouldNotThrowExceptionWhenResultIsIActionResultBaseClass()
+        public void ShouldReturnActionResultWithDetailsShouldNotThrowExceptionWhenResultIsActionResultBaseClass()
         {
             MyController<MvcController>
                 .Instance()
@@ -104,5 +104,70 @@ public void ShouldReturnActionResultWithDetailsShouldThrowExceptionWhenWhenResul
                 },
                 "When calling BadRequestAction action in MvcController expected result to be OkResult, but instead received BadRequestResult.");
         }
+
+        [Fact]
+        public void ShouldReturnActionResultOfTShouldNotThrowExceptionWhenResultIsActionResultOfTWithActionResult()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.ActionResultOfT(0))
+                .ShouldReturn()
+                .ActionResult<ResponseModel>();
+        }
+
+        [Fact]
+        public void ShouldReturnActionResultOfTShouldNotThrowExceptionWhenResultIsActionResultOfTWithModel()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.ActionResultOfT(1))
+                .ShouldReturn()
+                .ActionResult<ResponseModel>();
+        }
+
+        [Fact]
+        public void ShouldReturnActionResultOfTShouldThrowExceptionWhenResultIsIActionResultInterface()
+        {
+            Test.AssertException<InvocationResultAssertionException>(
+                () =>
+                {
+                    MyController<MvcController>
+                        .Instance()
+                        .Calling(c => c.ActionResultInterface())
+                        .ShouldReturn()
+                        .ActionResult<ResponseModel>();
+                },
+                "When calling ActionResultInterface action in MvcController expected result to be ActionResult<ResponseModel>, but instead received IActionResult.");
+        }
+
+        [Fact]
+        public void ShouldReturnActionResultOfTShouldThrowExceptionWhenResultIsActionResultBaseClass()
+        {
+            Test.AssertException<InvocationResultAssertionException>(
+                () =>
+                {
+                    MyController<MvcController>
+                        .Instance()
+                        .Calling(c => c.ActionResultBaseClass())
+                        .ShouldReturn()
+                        .ActionResult<ResponseModel>();
+                },
+                "When calling ActionResultBaseClass action in MvcController expected result to be ActionResult<ResponseModel>, but instead received ActionResult.");
+        }
+
+        [Fact]
+        public void ShouldReturnActionResultOfTShouldThrowExceptionWhenResultIsActionResultOfWrongModel()
+        {
+            Test.AssertException<InvocationResultAssertionException>(
+                () =>
+                {
+                    MyController<MvcController>
+                        .Instance()
+                        .Calling(c => c.ActionResultOfT(0))
+                        .ShouldReturn()
+                        .ActionResult<RequestModel>();
+                },
+                "When calling ActionResultOfT action in MvcController expected result to be ActionResult<RequestModel>, but instead received ActionResult<ResponseModel>.");
+        }
     }
 }