Issue 202 - Added direct lambda expression in the WithModelOfType<> option

Author: IvayloGoranov

src/MyTested.AspNetCore.Mvc.Models/BaseTestBuilderWithResponseModelExtensions.cs

@@ -86,6 +86,56 @@ public static IAndModelDetailsTestBuilder<TModel> WithModelOfType<TModel>(
             return new ModelDetailsTestBuilder<TModel>(actualBuilder.TestContext);
         }
 
+        /// <summary>
+        /// Tests whether model of the given type is returned from the invoked method and whether the provided predicate is passing.
+        /// </summary>
+        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithResponseModel"/> type.</param>
+        /// <typeparam name="TModel">Type of the model.</typeparam>
+        /// <param name="predicate">Predicate testing the model.</param>
+        /// <returns>Test builder of <see cref="IModelDetailsTestBuilder{TModel}"/>.</returns>
+        public static IAndModelDetailsTestBuilder<TModel> WithModelOfType<TModel>(
+            this IBaseTestBuilderWithResponseModel builder,
+            Func<TModel, bool> predicate)
+        {
+            var actualBuilder = (BaseTestBuilderWithResponseModel)builder;
+
+            actualBuilder.WithModelOfType<TModel>();
+
+            if (!predicate(actualBuilder.TestContext.ModelAs<TModel>()))
+            {
+                throw new ResponseModelAssertionException(string.Format(
+                    "{0} response model {1} to pass the given predicate, but it failed.",
+                    actualBuilder.TestContext.ExceptionMessagePrefix,
+                    typeof(TModel).ToFriendlyTypeName()));
+            }
+
+            actualBuilder.TestContext.Model = actualBuilder.GetActualModel<TModel>();
+
+            return new ModelDetailsTestBuilder<TModel>(actualBuilder.TestContext);
+        }
+
+        /// <summary>
+        /// Tests whether model of the given type is returned from the invoked method and whether the provided assertions are passing.
+        /// </summary>
+        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithResponseModel"/> type.</param>
+        /// <typeparam name="TModel">Type of the model.</typeparam>
+        /// <param name="assertions">Method containing all assertions for the model.</param>
+        /// <returns>Test builder of <see cref="IModelDetailsTestBuilder{TModel}"/>.</returns>
+        public static IAndModelDetailsTestBuilder<TModel> WithModelOfType<TModel>(
+            this IBaseTestBuilderWithResponseModel builder,
+            Action<TModel> assertions)
+        {
+            var actualBuilder = (BaseTestBuilderWithResponseModel)builder;
+
+            actualBuilder.WithModelOfType<TModel>();
+
+            assertions(actualBuilder.TestContext.ModelAs<TModel>());
+
+            actualBuilder.TestContext.Model = actualBuilder.GetActualModel<TModel>();
+
+            return new ModelDetailsTestBuilder<TModel>(actualBuilder.TestContext);
+        }
+
         /// <summary>
         /// Tests whether a deeply equal object to the provided one is returned from the invoked method.
         /// </summary>

test/MyTested.AspNetCore.Mvc.ModelState.Test/BuildersTests/ModelsTests/ModelErrorTestBuilderTests.cs

@@ -146,6 +146,23 @@ public void AndProvideTheModelShouldReturnProperModelWhenThereIsResponseModelWit
                     }));
         }
 
+        [Fact]
+        public void AndProvideTheModelShouldReturnProperModelWhenThereIsResponseModelWithPredicate()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.OkResultWithResponse())
+                .ShouldReturn()
+                .Ok(ok => ok
+                    .WithModelOfType<List<ResponseModel>>(m => m.Count == 2)
+                    .ShouldPassForThe<List<ResponseModel>>(responseModel =>
+                    {
+                        Assert.NotNull(responseModel);
+                        Assert.IsAssignableFrom<List<ResponseModel>>(responseModel);
+                        Assert.Equal(2, responseModel.Count);
+                    }));
+        }
+
         [Fact]
         public void AndProvideTheModelShouldReturnProperModelWhenThereIsResponseModelWithModelStateError()
         {

test/MyTested.AspNetCore.Mvc.Models.Test/BuildersTests/ModelsTests/ResponseModelDetailsTestBuilderTests.cs

@@ -12,7 +12,7 @@
     public class ResponseModelDetailsTestBuilderTests
     {
         [Fact]
-        public void WithResponseModelShouldNotThrowExceptionWithCorrectAssertions()
+        public void WithResponseModelShouldNotThrowExceptionPassingCorrectAssertions()
         {
             MyController<MvcController>
                 .Instance()
@@ -28,7 +28,22 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectAssertions()
         }
 
         [Fact]
-        public void WithResponseModelShouldThrowExceptionWithIncorrectAssertions()
+        public void WithResponseModelShouldNotThrowExceptionWithActionWithCorrectAssertions()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.OkResultWithResponse())
+                .ShouldReturn()
+                .Ok(ok => ok
+                    .WithModelOfType<ICollection<ResponseModel>>(m =>
+                    {
+                        Assert.Equal(2, m.Count);
+                        Assert.Equal(1, m.First().IntegerValue);
+                    }));
+        }
+
+        [Fact]
+        public void WithResponseModelShouldThrowExceptionPassingIncorrectAssertions()
         {
             Assert.Throws<EqualException>(
                 () =>
@@ -48,7 +63,26 @@ public void WithResponseModelShouldThrowExceptionWithIncorrectAssertions()
         }
 
         [Fact]
-        public void WithResponseModelShouldNotThrowExceptionWithCorrectPredicate()
+        public void WithResponseModelShouldThrowExceptionWithActionWithIncorrectAssertions()
+        {
+            Assert.Throws<EqualException>(
+                () =>
+                {
+                    MyController<MvcController>
+                        .Instance()
+                        .Calling(c => c.OkResultWithResponse())
+                        .ShouldReturn()
+                        .Ok(ok => ok
+                            .WithModelOfType<ICollection<ResponseModel>>(m =>
+                            {
+                                Assert.Equal(1, m.First().IntegerValue);
+                                Assert.Equal(3, m.Count);
+                            }));
+                });
+        }
+
+        [Fact]
+        public void WithResponseModelShouldNotThrowExceptionPassingCorrectPredicate()
         {
             MyController<MvcController>
                 .Instance()
@@ -60,7 +94,18 @@ public void WithResponseModelShouldNotThrowExceptionWithCorrectPredicate()
         }
 
         [Fact]
-        public void WithResponseModelShouldThrowExceptionWithWrongPredicate()
+        public void WithResponseModelShouldNotThrowExceptionWithCorrectPredicate()
+        {
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.OkResultWithResponse())
+                .ShouldReturn()
+                .Ok(ok => ok
+                    .WithModelOfType<ICollection<ResponseModel>>(m => m.First().IntegerValue == 1));
+        }
+
+        [Fact]
+        public void WithResponseModelShouldThrowExceptionPassingWrongPredicate()
         {
             Test.AssertException<ResponseModelAssertionException>(
                 () =>
@@ -75,5 +120,21 @@ public void WithResponseModelShouldThrowExceptionWithWrongPredicate()
                 }, 
                 "When calling OkResultWithResponse action in MvcController expected response model IList<ResponseModel> to pass the given predicate, but it failed.");
         }
+
+        [Fact]
+        public void WithResponseModelShouldThrowExceptionWithWrongPredicate()
+        {
+            Test.AssertException<ResponseModelAssertionException>(
+                () =>
+                {
+                    MyController<MvcController>
+                        .Instance()
+                        .Calling(c => c.OkResultWithResponse())
+                        .ShouldReturn()
+                        .Ok(ok => ok
+                            .WithModelOfType<IList<ResponseModel>>(m => m.First().IntegerValue == 2));
+                },
+                "When calling OkResultWithResponse action in MvcController expected response model IList<ResponseModel> to pass the given predicate, but it failed.");
+        }
     }
 }