Controllers now can be created with inner builder (#318)

Author: ivaylokenov

samples/Blog/Blog.Test/Controllers/ArticlesControllerTest.cs

@@ -20,8 +20,8 @@ public class ArticlesControllerTest
         [InlineData(18, 2, 6)]
         public void AllShouldReturnDefaultViewWithCorrectModel(int total, int page, int expectedCount)
             => MyController<ArticlesController>
-                .Instance()
-                .WithData(ArticleTestData.GetArticles(total))
+                .Instance(instance => instance
+                    .WithData(ArticleTestData.GetArticles(total)))
                 .Calling(c => c.All(page))
                 .ShouldReturn()
                 .View(view => view

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Contracts/Controllers/IAndControllerInstanceBuilder.cs

@@ -1,16 +1,16 @@
 namespace MyTested.AspNetCore.Mvc.Builders.Contracts.Controllers
 {
     /// <summary>
-    /// Used for adding AndAlso() method to the controller builder.
+    /// Used for adding AndAlso() method to the controller instance builder.
     /// </summary>
     /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
-    public interface IAndControllerInstanceBuilder<TController> : IControllerBuilder<TController>
+    public interface IAndControllerInstanceBuilder<TController> : IControllerInstanceBuilder<TController>
         where TController : class
     {
         /// <summary>
         /// AndAlso method for better readability when building controller instance.
         /// </summary>
         /// <returns>The same <see cref="IAndControllerBuilder{TController}"/>.</returns>
-        IAndControllerBuilder<TController> AndAlso();
+        IAndControllerInstanceBuilder<TController> AndAlso();
     }
 }

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Contracts/Controllers/IBaseControllerBuilder.cs

@@ -5,46 +5,47 @@
     using Microsoft.AspNetCore.Mvc;
 
     /// <summary>
-    /// Used for building the controller which will be tested.
+    /// Base controller builder.
     /// </summary>
     /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
-    /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
-    public interface IBaseControllerBuilder<TController, TBuilder> : IBaseTestBuilderWithComponentBuilder<IAndControllerBuilder<TController>>
+    /// <typeparam name="TBuilder">Base builder.</typeparam>
+    public interface IBaseControllerBuilder<TController, TBuilder> : IBaseTestBuilderWithComponentBuilder<TBuilder>
         where TController : class
+        where TBuilder : IBaseTestBuilder
     {
         /// <summary>
         /// Sets the <see cref="ControllerContext"/> on the tested controller.
         /// </summary>
         /// <param name="controllerContext">Instance of <see cref="ControllerContext"/> to set.</param>
         /// <returns>The same <see cref="IControllerBuilder{TController}"/>.</returns>
-        IAndControllerBuilder<TController> WithControllerContext(ControllerContext controllerContext);
+        TBuilder WithControllerContext(ControllerContext controllerContext);
 
         /// <summary>
         /// Sets the <see cref="ControllerContext"/> on the tested controller.
         /// </summary>
         /// <param name="controllerContextSetup">Action setting the <see cref="ControllerContext"/>.</param>
         /// <returns>The same <see cref="IControllerBuilder{TController}"/>.</returns>
-        IAndControllerBuilder<TController> WithControllerContext(Action<ControllerContext> controllerContextSetup);
+        TBuilder WithControllerContext(Action<ControllerContext> controllerContextSetup);
 
         /// <summary>
         /// Sets the <see cref="ActionContext"/> on the tested controller.
         /// </summary>
         /// <param name="actionContext">Instance of <see cref="ActionContext"/> to set.</param>
         /// <returns>The same <see cref="IControllerBuilder{TController}"/>.</returns>
-        IAndControllerBuilder<TController> WithActionContext(ActionContext actionContext);
+        TBuilder WithActionContext(ActionContext actionContext);
 
         /// <summary>
         /// Sets the <see cref="ActionContext"/> on the tested controller.
         /// </summary>
         /// <param name="actionContextSetup">Action setting the <see cref="ActionContext"/>.</param>
         /// <returns>The same <see cref="IControllerBuilder{TController}"/>.</returns>
-        IAndControllerBuilder<TController> WithActionContext(Action<ActionContext> actionContextSetup);
+        TBuilder WithActionContext(Action<ActionContext> actionContextSetup);
 
         /// <summary>
         /// Sets custom properties to the controller using a delegate.
         /// </summary>
         /// <param name="controllerSetup">Action to use for controller setup.</param>
         /// <returns>The same <see cref="IControllerBuilder{TController}"/>.</returns>
-        IAndControllerBuilder<TController> WithSetup(Action<TController> controllerSetup);
+        TBuilder WithSetup(Action<TController> controllerSetup);
     }
 }

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Contracts/Controllers/IControllerActionCallBuilder.cs

@@ -0,0 +1,51 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Contracts.Controllers
+{
+    using System;
+    using System.Linq.Expressions;
+    using System.Threading.Tasks;
+    using Actions;
+    using Base;
+
+    /// <summary>
+    /// Used for testing the controller.
+    /// </summary>
+    /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
+    public interface IControllerActionCallBuilder<TController> : IBaseTestBuilderWithComponent
+    {
+        /// <summary>
+        /// Used for testing controller additional details.
+        /// </summary>
+        /// <returns>Test builder of <see cref="IControllerTestBuilder"/> type.</returns>
+        IControllerTestBuilder ShouldHave();
+
+        /// <summary>
+        /// Indicates which action should be invoked and tested.
+        /// </summary>
+        /// <typeparam name="TActionResult">Type of result from action.</typeparam>
+        /// <param name="actionCall">Method call expression indicating invoked action.</param>
+        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
+        IActionResultTestBuilder<TActionResult> Calling<TActionResult>(Expression<Func<TController, TActionResult>> actionCall);
+
+        /// <summary>
+        /// Indicates which action should be invoked and tested.
+        /// </summary>
+        /// <typeparam name="TActionResult">Type of result from action.</typeparam>
+        /// <param name="actionCall">Method call expression indicating invoked asynchronous action.</param>
+        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
+        IActionResultTestBuilder<TActionResult> Calling<TActionResult>(Expression<Func<TController, Task<TActionResult>>> actionCall);
+
+        /// <summary>
+        /// Indicates which action should be invoked and tested.
+        /// </summary>
+        /// <param name="actionCall">Method call expression indicating invoked void action.</param>
+        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
+        IVoidActionResultTestBuilder Calling(Expression<Action<TController>> actionCall);
+
+        /// <summary>
+        /// Indicates which action should be invoked and tested.
+        /// </summary>
+        /// <param name="actionCall">Method call expression indicating invoked asynchronous void action.</param>
+        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
+        IVoidActionResultTestBuilder Calling(Expression<Func<TController, Task>> actionCall);
+    }
+}

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Contracts/Controllers/IControllerBuilder.cs

@@ -1,51 +1,13 @@
 namespace MyTested.AspNetCore.Mvc.Builders.Contracts.Controllers
 {
-    using System;
-    using System.Linq.Expressions;
-    using System.Threading.Tasks;
-    using Actions;
-
     /// <summary>
     /// Used for building the controller which will be tested.
     /// </summary>
     /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
-    public interface IControllerBuilder<TController> : IBaseControllerBuilder<TController, IAndControllerBuilder<TController>>
+    public interface IControllerBuilder<TController> 
+        : IBaseControllerBuilder<TController, IAndControllerBuilder<TController>>,
+        IControllerActionCallBuilder<TController>
         where TController : class
     {
-        /// <summary>
-        /// Used for testing controller additional details.
-        /// </summary>
-        /// <returns>Test builder of <see cref="IControllerTestBuilder"/> type.</returns>
-        IControllerTestBuilder ShouldHave();
-
-        /// <summary>
-        /// Indicates which action should be invoked and tested.
-        /// </summary>
-        /// <typeparam name="TActionResult">Type of result from action.</typeparam>
-        /// <param name="actionCall">Method call expression indicating invoked action.</param>
-        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
-        IActionResultTestBuilder<TActionResult> Calling<TActionResult>(Expression<Func<TController, TActionResult>> actionCall);
-
-        /// <summary>
-        /// Indicates which action should be invoked and tested.
-        /// </summary>
-        /// <typeparam name="TActionResult">Type of result from action.</typeparam>
-        /// <param name="actionCall">Method call expression indicating invoked asynchronous action.</param>
-        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
-        IActionResultTestBuilder<TActionResult> Calling<TActionResult>(Expression<Func<TController, Task<TActionResult>>> actionCall);
-
-        /// <summary>
-        /// Indicates which action should be invoked and tested.
-        /// </summary>
-        /// <param name="actionCall">Method call expression indicating invoked void action.</param>
-        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
-        IVoidActionResultTestBuilder Calling(Expression<Action<TController>> actionCall);
-
-        /// <summary>
-        /// Indicates which action should be invoked and tested.
-        /// </summary>
-        /// <param name="actionCall">Method call expression indicating invoked asynchronous void action.</param>
-        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
-        IVoidActionResultTestBuilder Calling(Expression<Func<TController, Task>> actionCall);
     }
 }

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Controllers/BaseControllerBuilder.cs

@@ -0,0 +1,64 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Controllers
+{
+    using Components;
+    using Contracts.Base;
+    using Internal.Contracts;
+    using Internal.TestContexts;
+    using Microsoft.AspNetCore.Mvc.Controllers;
+    using Microsoft.AspNetCore.Mvc.Internal;
+    using Microsoft.Extensions.DependencyInjection;
+    using System.Linq.Expressions;
+    using System.Reflection;
+    using Utilities.Extensions;
+
+    /// <summary>
+    /// Base controller builder.
+    /// </summary>
+    /// /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
+    /// <typeparam name="TBuilder">Base builder.</typeparam>
+    public abstract partial class BaseControllerBuilder<TController, TBuilder>
+        : BaseComponentBuilder<TController, ControllerTestContext, TBuilder>
+        where TController : class
+        where TBuilder : IBaseTestBuilder
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseControllerBuilder{TController, TBuilder}"/> class.
+        /// </summary>
+        /// <param name="testContext"><see cref="ControllerTestContext"/> containing data about the currently executed assertion chain.</param>
+        protected BaseControllerBuilder(ControllerTestContext testContext) 
+            : base(testContext)
+        {
+        }
+
+        protected override string ComponentName => "controller";
+
+        protected override bool IsValidComponent
+            => this.Services
+                .GetRequiredService<IValidControllersCache>()
+                .IsValid(typeof(TController));
+
+        protected override TController TryCreateComponentWithFactory()
+        {
+            try
+            {
+                return this.Services
+                    .GetService<IControllerFactory>()
+                    ?.CreateController(this.TestContext.ComponentContext) as TController;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        protected override void ActivateComponent()
+            => this.Services
+                .GetServices<IControllerPropertyActivator>()
+                ?.ForEach(a => a.Activate(this.TestContext.ComponentContext, this.TestContext.Component));
+
+        protected override void ProcessAndValidateMethod(LambdaExpression methodCall, MethodInfo methodInfo)
+        {
+            // Intentionally left empty. Not all controller builders allow action execution.
+        }
+    }
+}

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Controllers/ControllerSetupBuilder.cs renamed to src/MyTested.AspNetCore.Mvc.Controllers/Builders/Controllers/BaseControllerSetupBuilder.cs

@@ -2,42 +2,39 @@
 {
     using System;
     using System.Reflection;
-    using Contracts.Controllers;
     using Internal.Controllers;
     using Microsoft.AspNetCore.Mvc;
     using Utilities.Validators;
 
     /// <content>
     /// Used for building the controller which will be tested.
     /// </content>
-    public partial class ControllerBuilder<TController>
+    public abstract partial class BaseControllerBuilder<TController, TBuilder>
     {
         /// <inheritdoc />
-        public IAndControllerBuilder<TController> WithControllerContext(ControllerContext controllerContext)
-        {
-            return this.WithActionContext(controllerContext);
-        }
+        public TBuilder WithControllerContext(ControllerContext controllerContext)
+            => this.WithActionContext(controllerContext);
 
         /// <inheritdoc />
-        public IAndControllerBuilder<TController> WithControllerContext(Action<ControllerContext> controllerContextSetup)
+        public TBuilder WithControllerContext(Action<ControllerContext> controllerContextSetup)
         {
             this.TestContext.ComponentContextPreparationDelegate += controllerContextSetup;
-            return this;
+            return this.Builder;
         }
 
         /// <inheritdoc />
-        public IAndControllerBuilder<TController> WithActionContext(ActionContext actionContext)
+        public TBuilder WithActionContext(ActionContext actionContext)
         {
             CommonValidator.CheckForNullReference(actionContext, nameof(ActionContext));
             this.TestContext.ComponentContext = ControllerContextMock.FromActionContext(this.TestContext, actionContext);
-            return this;
+            return this.Builder;
         }
 
         /// <inheritdoc />
-        public IAndControllerBuilder<TController> WithActionContext(Action<ActionContext> actionContextSetup)
+        public TBuilder WithActionContext(Action<ActionContext> actionContextSetup)
         {
             this.TestContext.ComponentContextPreparationDelegate += actionContextSetup;
-            return this;
+            return this.Builder;
         }
 
         protected override void PrepareComponentContext()

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Controllers/ControllerBuilder.cs

@@ -1,20 +1,16 @@
 namespace MyTested.AspNetCore.Mvc.Builders.Controllers
 {
-    using Components;
     using Contracts.Controllers;
     using Internal.Configuration;
-    using Internal.Contracts;
     using Internal.TestContexts;
-    using Microsoft.AspNetCore.Mvc.Controllers;
-    using Microsoft.AspNetCore.Mvc.Internal;
-    using Microsoft.Extensions.DependencyInjection;
-    using Utilities.Extensions;
 
     /// <summary>
     /// Used for building the controller which will be tested.
     /// </summary>
     /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
-    public partial class ControllerBuilder<TController> : BaseComponentBuilder<TController, ControllerTestContext, IAndControllerBuilder<TController>>, IAndControllerBuilder<TController>
+    public partial class ControllerBuilder<TController> 
+        : BaseControllerBuilder<TController, IAndControllerBuilder<TController>>, 
+        IAndControllerBuilder<TController>
         where TController : class
     {
         /// <summary>
@@ -30,13 +26,6 @@ public ControllerBuilder(ControllerTestContext testContext)
 
         public bool EnabledModelStateValidation { get; set; }
 
-        protected override string ComponentName => "controller";
-
-        protected override bool IsValidComponent
-            => this.Services
-                .GetRequiredService<IValidControllersCache>()
-                .IsValid(typeof(TController));
-
         /// <inheritdoc />
         public IAndControllerBuilder<TController> AndAlso() => this;
 
@@ -48,24 +37,5 @@ public IControllerTestBuilder ShouldHave()
         }
 
         protected override IAndControllerBuilder<TController> SetBuilder() => this;
-        
-        protected override TController TryCreateComponentWithFactory()
-        {
-            try
-            {
-                return this.Services
-                    .GetService<IControllerFactory>()
-                    ?.CreateController(this.TestContext.ComponentContext) as TController;
-            }
-            catch
-            {
-                return null;
-            }
-        }
-
-        protected override void ActivateComponent() 
-            => this.Services
-                .GetServices<IControllerPropertyActivator>()
-                ?.ForEach(a => a.Activate(this.TestContext.ComponentContext, this.TestContext.Component));
     }
 }