Implemented .ShouldReturn().ActionResult(result => result.Ok()) assertion chain (#359)

Author: ivaylokenov

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Actions/AndActionResultTestBuilder.cs

@@ -17,10 +17,8 @@ public class AndActionResultTestBuilder<TActionResult> : ShouldHaveTestBuilder<T
         /// </summary>
         /// <param name="testContext"><see cref="ControllerTestContext"/> containing data about the currently executed assertion chain.</param>
         public AndActionResultTestBuilder(ControllerTestContext testContext)
-            : base(testContext)
-        {
-            TestHelper.ExecuteTestCleanup();
-        }
+            : base(testContext) 
+            => TestHelper.ExecuteTestCleanup();
 
         /// <inheritdoc />
         public IActionResultTestBuilder<TActionResult> AndAlso()

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Actions/ShouldHave/ShouldHaveActionAttributes.cs

@@ -47,10 +47,8 @@ public IAndActionResultTestBuilder<TActionResult> ActionAttributes(Action<IActio
             return this.Builder;
         }
 
-        private void ThrowNewAttributeAssertionException(string expectedValue, string actualValue)
-        {
-            throw new AttributeAssertionException(
+        private void ThrowNewAttributeAssertionException(string expectedValue, string actualValue) 
+            => throw new AttributeAssertionException(
                 $"{this.TestContext.ExceptionMessagePrefix} action to {expectedValue}, but {actualValue}.");
-        }
     }
 }

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Actions/ShouldHave/ShouldHaveTestBuilder.cs

@@ -20,21 +20,16 @@ public partial class ShouldHaveTestBuilder<TActionResult>
         /// </summary>
         /// <param name="testContext"><see cref="ControllerTestContext"/> containing data about the currently executed assertion chain.</param>
         public ShouldHaveTestBuilder(ControllerTestContext testContext)
-            : base(testContext)
-        {
-            this.TestContext = testContext;
-        }
-        
+            : base(testContext) 
+            => this.TestContext = testContext;
+
         /// <summary>
         /// Gets the currently used <see cref="ControllerTestContext"/>.
         /// </summary>
         /// <value>Result of type <see cref="ControllerTestContext"/>.</value>
         public new ControllerTestContext TestContext
         {
-            get
-            {
-                return this.testContext;
-            }
+            get => this.testContext;
 
             private set
             {

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

@@ -1,5 +1,6 @@
 namespace MyTested.AspNetCore.Mvc.Builders.Actions.ShouldReturn
 {
+    using System;
     using And;
     using Contracts.Actions;
     using Contracts.And;
@@ -14,6 +15,9 @@
     public class ShouldReturnActionResultTestBuilder<TActionResult>
         : ShouldReturnTestBuilder<TActionResult>, IShouldReturnActionResultTestBuilder<TActionResult>
     {
+        private static readonly Type ActionResultType = typeof(IActionResult);
+        private static readonly Type GenericActionResultType = typeof(ActionResult<>);
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ShouldReturnActionResultTestBuilder{TActionResult}"/> class.
         /// </summary>
@@ -24,14 +28,27 @@ public ShouldReturnActionResultTestBuilder(ControllerTestContext testContext)
         }
 
         /// <inheritdoc />
-        public new IAndTestBuilder ActionResult()
+        IAndTestBuilder IShouldReturnActionResultTestBuilder<TActionResult>.ActionResult()
         {
-            InvocationResultValidator.ValidateInvocationResultTypes(
-                this.TestContext,
-                canBeAssignable: true,
-                typesOfExpectedReturnValue: new [] { typeof(IActionResult), typeof(ActionResult<>) });
+            this.ValidateActionResults();
 
             return new AndTestBuilder(this.TestContext);
         }
+
+        /// <inheritdoc />
+        IAndTestBuilder IShouldReturnActionResultTestBuilder<TActionResult>.ActionResult(Action<IShouldReturnTestBuilder<TActionResult>> actionResultTestBuilder)
+        {
+            this.ValidateActionResults();
+
+            actionResultTestBuilder?.Invoke(this);
+
+            return new AndTestBuilder(this.TestContext);
+        }
+
+        private void ValidateActionResults() 
+            => InvocationResultValidator.ValidateInvocationResultTypes(
+                this.TestContext,
+                canBeAssignable: true,
+                typesOfExpectedReturnValue: new[] { ActionResultType, GenericActionResultType });
     }
 }

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

@@ -18,8 +18,12 @@ public interface IShouldReturnActionResultTestBuilder<TActionResult>
         /// <returns>Test builder of <see cref="IAndTestBuilder"/> type.</returns>
         IAndTestBuilder ActionResult();
 
-        //// IActionResult, ActionResult or ActionResult<T> with options to specify the result - Ok() for example
-        //IAndTestBuilder ActionResult(Action<IShouldReturnTestBuilder<TActionResult>> actionResultTestBuilder);
+        /// 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}"/>.
+        /// <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>();

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

@@ -3,6 +3,7 @@
     using Exceptions;
     using Setups;
     using Setups.Controllers;
+    using Setups.Models;
     using Xunit;
 
     public class ShouldReturnActionResultTests
@@ -51,5 +52,57 @@ public void ShouldReturnActionResultShouldThrowExceptionWhenWhenResultIsNotActio
                 },
                 "When calling AnonymousResult action in MvcController expected result to be IActionResult or ActionResult<TValue>, but instead received AnonymousType<Int32, String, AnonymousType<Boolean>>.");
         }
+
+        [Fact]
+        public void ShouldReturnActionResultWithDetailsShouldNotThrowExceptionWhenResultIsIActionResultInterface()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.ActionResultInterface())
+                .ShouldReturn()
+                .ActionResult(result => result
+                    .Ok(okResult => okResult
+                        .Passing(ok => ok.Value?.GetType() == typeof(ResponseModel))));
+        }
+
+        [Fact]
+        public void ShouldReturnActionResultWithDetailsShouldNotThrowExceptionWhenResultIsIActionResultBaseClass()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.ActionResultBaseClass())
+                .ShouldReturn()
+                .ActionResult(result => result
+                    .Ok(okResult => okResult
+                        .Passing(ok => ok.Value?.GetType() == typeof(ResponseModel))));
+        }
+
+        [Fact]
+        public void ShouldReturnActionResultWithDetailsShouldNotThrowExceptionWhenResultIsActionResultOfT()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.ActionResultOfT(int.MaxValue))
+                .ShouldReturn()
+                .ActionResult(result => result
+                    .Ok(okResult => okResult
+                        .Passing(ok => ok.Value?.GetType() == typeof(ResponseModel))));
+        }
+
+        [Fact]
+        public void ShouldReturnActionResultWithDetailsShouldThrowExceptionWhenWhenResultIsNotActionResult()
+        {
+            Test.AssertException<InvocationResultAssertionException>(
+                () =>
+                {
+                    MyController<MvcController>
+                        .Instance()
+                        .Calling(c => c.BadRequestAction())
+                        .ShouldReturn()
+                        .ActionResult(result => result
+                            .Ok());
+                },
+                "When calling BadRequestAction action in MvcController expected result to be OkResult, but instead received BadRequestResult.");
+        }
     }
 }

test/MyTested.AspNetCore.Mvc.Test.Setups/Controllers/MvcController.cs

@@ -1249,12 +1249,12 @@ public IActionResult WithService(IHttpContextAccessor httpContextAccessor)
 
         public IActionResult ActionResultInterface()
         {
-            return this.Ok();
+            return this.Ok(this.ResponseModel.First());
         }
 
         public ActionResult ActionResultBaseClass()
         {
-            return this.Ok();
+            return this.Ok(this.ResponseModel.First());
         }
 
         public ActionResult<ResponseModel> ActionResultOfT(int id)