Created all pipeline interfaces allowing assertions from a route to a controller (#282)

Author: ivaylokenov

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

@@ -7,7 +7,7 @@
     /// Used for testing the action and its result.
     /// </summary>
     /// <typeparam name="TActionResult">Type of action result to be tested.</typeparam>
-    public interface IActionResultTestBuilder<TActionResult> : IBaseTestBuilderWithActionResult
+    public interface IActionResultTestBuilder<TActionResult> : IBaseTestBuilderWithInvokedAction
     {
         /// <summary>
         /// Used for testing the action's additional data - action attributes, HTTP response, view bag and more.

src/MyTested.AspNetCore.Mvc.Pipeline/Builders/Contracts/Pipeline/IAndWhichControllerInstanceBuilder.cs

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

src/MyTested.AspNetCore.Mvc.Pipeline/Builders/Contracts/Pipeline/IWhichControllerInstanceBuilder.cs

@@ -0,0 +1,16 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Contracts.Pipeline
+{
+    using Builders.Contracts.Actions;
+    using Controllers;
+
+    /// <summary>
+    /// Used for building the controller which will be tested after a route assertion.
+    /// </summary>
+    /// <typeparam name="TController"></typeparam>
+    public interface IWhichControllerInstanceBuilder<TController> 
+        : IBaseControllerBuilder<TController, IAndWhichControllerInstanceBuilder<TController>>,
+        IActionResultTestBuilder<object>
+        where TController : class
+    {
+    }
+}

src/MyTested.AspNetCore.Mvc.Pipeline/ControllerRouteTestBuilderPipelineExtensions.cs

@@ -0,0 +1,42 @@
+namespace MyTested.AspNetCore.Mvc
+{
+    using System;
+    using Builders.Contracts.Actions;
+    using Builders.Contracts.Controllers;
+    using Builders.Contracts.Pipeline;
+    using Builders.Contracts.Routing;
+
+    /// <summary>
+    /// Contains extension methods for <see cref="IControllerRouteTestBuilder{TController}"/>.
+    /// </summary>
+    public static class ControllerRouteTestBuilderPipelineExtensions
+    {
+        /// <summary>
+        /// Allows the route test to continue the assertion chain on the matched controller action.
+        /// </summary>
+        /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
+        /// <param name="builder">Instance of <see cref="IControllerRouteTestBuilder{TController}"/> type.</param>
+        /// <returns>Test builder of <see cref="IWhichControllerInstanceBuilder{TController}"/> type.</returns>
+        public static IWhichControllerInstanceBuilder<TController> Which<TController>(
+            this IControllerRouteTestBuilder<TController> builder)
+            where TController : class
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Allows the route test to continue the assertion chain on the matched controller action.
+        /// </summary>
+        /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
+        /// <param name="builder">Instance of <see cref="IControllerRouteTestBuilder{TController}"/> type.</param>
+        /// <param name="controllerInstanceBuilder">Builder for creating the controller instance.</param>
+        /// <returns>Test builder of <see cref="IActionResultTestBuilder{TActionResult}"/> type.</returns>
+        public static IActionResultTestBuilder<object> Which<TController>(
+            this IControllerRouteTestBuilder<TController> builder,
+            Action<IControllerInstanceBuilder<TController>> controllerInstanceBuilder)
+            where TController : class
+        {
+            return null;
+        }
+    }
+}

src/MyTested.AspNetCore.Mvc.Routing/Builders/Contracts/Routing/IControllerRouteTestBuilder.cs

@@ -0,0 +1,10 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Contracts.Routing
+{
+    /// <summary>
+    /// Used for testing controller route details.
+    /// </summary>
+    /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
+    public interface IControllerRouteTestBuilder<TController> : IAndResolvedRouteTestBuilder
+    {
+    }
+}

src/MyTested.AspNetCore.Mvc.Routing/Builders/Contracts/Routing/IShouldMapTestBuilder.cs

@@ -44,17 +44,17 @@ IAndResolvedRouteTestBuilder To<TController>()
         /// </summary>
         /// <typeparam name="TController">Type of expected resolved controller.</typeparam>
         /// <param name="actionCall">Method call expression indicating the expected resolved action.</param>
-        /// <returns>The <see cref="IAndResolvedRouteTestBuilder"/>.</returns>
-        IAndResolvedRouteTestBuilder To<TController>(Expression<Action<TController>> actionCall)
+        /// <returns>The <see cref="IControllerRouteTestBuilder{TController}"/>.</returns>
+        IControllerRouteTestBuilder<TController> To<TController>(Expression<Action<TController>> actionCall)
             where TController : class;
 
         /// <summary>
         /// Tests whether the built route is resolved to the asynchronous action provided by the expression.
         /// </summary>
         /// <typeparam name="TController">Type of expected resolved controller.</typeparam>
         /// <param name="actionCall">Method call expression indicating the expected resolved asynchronous action.</param>
-        /// <returns>The <see cref="IAndResolvedRouteTestBuilder"/>.</returns>
-        IAndResolvedRouteTestBuilder To<TController>(Expression<Func<TController, Task>> actionCall)
+        /// <returns>The <see cref="IControllerRouteTestBuilder{TController}"/>.</returns>
+        IControllerRouteTestBuilder<TController> To<TController>(Expression<Func<TController, Task>> actionCall)
             where TController : class;
 
         /// <summary>

src/MyTested.AspNetCore.Mvc.Routing/Builders/Routing/ControllerRouteTestBuilder.cs

@@ -0,0 +1,23 @@
+namespace MyTested.AspNetCore.Mvc.Builders.Routing
+{
+    using Contracts.Routing;
+    using Internal.TestContexts;
+
+    /// <summary>
+    /// Used for testing controller route details.
+    /// </summary>
+    /// <typeparam name="TController">Class representing ASP.NET Core MVC controller.</typeparam>
+    public class ControllerRouteTestBuilder<TController>
+        : ShouldMapTestBuilder,
+        IControllerRouteTestBuilder<TController>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ControllerRouteTestBuilder{TController}"/> class.
+        /// </summary>
+        /// <param name="testContext"><see cref="RouteTestContext"/> containing data about the currently executed assertion chain.</param>
+        public ControllerRouteTestBuilder(RouteTestContext testContext) 
+            : base(testContext)
+        {
+        }
+    }
+}

src/MyTested.AspNetCore.Mvc.Routing/Builders/Routing/ShouldMapTestBuilder.cs

@@ -227,14 +227,14 @@ public IAndResolvedRouteTestBuilder To<TController>()
         }
 
         /// <inheritdoc />
-        public IAndResolvedRouteTestBuilder To<TController>(Expression<Action<TController>> actionCall)
+        public IControllerRouteTestBuilder<TController> To<TController>(Expression<Action<TController>> actionCall)
             where TController : class 
-            => this.ProcessRouteLambdaExpression(actionCall);
+            => this.ProcessRouteLambdaExpression<TController>(actionCall);
 
         /// <inheritdoc />
-        public IAndResolvedRouteTestBuilder To<TController>(Expression<Func<TController, Task>> actionCall)
+        public IControllerRouteTestBuilder<TController> To<TController>(Expression<Func<TController, Task>> actionCall)
             where TController : class 
-            => this.ProcessRouteLambdaExpression(actionCall);
+            => this.ProcessRouteLambdaExpression<TController>(actionCall);
 
         /// <inheritdoc />
         public void ToNonExistingRoute()
@@ -251,11 +251,11 @@ public void ToNonExistingRoute()
         /// <inheritdoc />
         public IResolvedRouteTestBuilder AndAlso() => this;
 
-        private IAndResolvedRouteTestBuilder ProcessRouteLambdaExpression(LambdaExpression actionCall)
+        private IControllerRouteTestBuilder<TController> ProcessRouteLambdaExpression<TController>(LambdaExpression actionCall)
         {
             this.actionCallExpression = actionCall;
             this.ValidateRouteInformation();
-            return this;
+            return new ControllerRouteTestBuilder<TController>(this.TestContext);
         }
 
         private void ValidateRouteInformation()

src/MyTested.AspNetCore.Mvc.Routing/Internal/TestContexts/RouteTestContext.cs

@@ -3,7 +3,6 @@
     using System;
     using Microsoft.AspNetCore.Routing;
     using Microsoft.AspNetCore.Http.Features.Authentication;
-    using Routing;
 
     public class RouteTestContext : HttpTestContext
     {