Redirect().To() now considers With.Any ignored values (closes #196)

Author: ivaylokenov

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

@@ -1,5 +1,6 @@
 namespace MyTested.AspNetCore.Mvc.Utilities.Extensions
 {
+    using System;
     using System.Collections.Generic;
     using System.Linq;
     using Internal.TestContexts;
@@ -18,17 +19,27 @@ public static IDictionary<string, MethodArgumentTestContext> ToDetailedValues(th
                 });
         }
 
-        public static IDictionary<string, object> ToRouteValues(this IDictionary<string, MethodArgumentTestContext> dictionary)
+        public static IDictionary<string, object> ToRouteValues(
+            this IDictionary<string, MethodArgumentTestContext> dictionary,
+            Func<KeyValuePair<string, MethodArgumentTestContext>, bool> filter = null)
         {
-            return dictionary.ToDictionary(
+            var result = dictionary.AsEnumerable();
+
+            if (filter != null)
+            {
+                result = result.Where(filter);
+            }
+
+            return result.ToDictionary(
                 a => a.Key,
                 a => a.Value.Value);
         }
 
         public static IDictionary<string, object> ToSortedRouteValues(
-            this IDictionary<string, MethodArgumentTestContext> dictionary)
+            this IDictionary<string, MethodArgumentTestContext> dictionary,
+            Func<KeyValuePair<string, MethodArgumentTestContext>, bool> filter = null)
         {
-            return new SortedDictionary<string, object>(dictionary.ToRouteValues());
+            return new SortedDictionary<string, object>(dictionary.ToRouteValues(filter));
         }
     }
 }

src/MyTested.AspNetCore.Mvc.Controllers/Utilities/Extensions/UrlHelperExtensions.cs

@@ -1,26 +1,49 @@
 namespace MyTested.AspNetCore.Mvc.Utilities.Extensions
 {
+    using System.Collections.Generic;
+    using System.Linq;
     using System.Linq.Expressions;
     using Internal.Routing;
     using Internal.TestContexts;
     using Microsoft.AspNetCore.Mvc;
 
     public static class UrlHelperExtensions
     {
-        public static string ExpressionLink(this IUrlHelper urlHelper, LambdaExpression lambdaExpression)
+        public static string ExpressionLink(
+            this IUrlHelper urlHelper,
+            LambdaExpression lambdaExpression,
+            out ICollection<string> ignoredRouteKeys)
         {
             var routeValues = RouteExpressionParser.Parse(lambdaExpression, considerParameterDescriptors: true);
+
+            var ignoredKeys = routeValues
+                .ActionArguments
+                .Where(a => a.Value.Value.ToString() == ExpressionParser.IgnoredExpressionArgument)
+                .Select(a => a.Key)
+                .ToList();
+            
+            ignoredRouteKeys = ignoredKeys;
+
             return urlHelper.Action(
                 routeValues.Action,
                 routeValues.ControllerName,
-                routeValues.ActionArguments.ToSortedRouteValues());
+                routeValues.ActionArguments.ToSortedRouteValues(kvp => !ignoredKeys.Contains(kvp.Key)));
         }
 
         public static string GenerateLink(
             this IUrlHelper urlHelper,
             LinkGenerationTestContext linkGenerationTestContext,
-            ControllerTestContext controllerTestContext)
+            ControllerTestContext controllerTestContext,
+            ICollection<string> ignoredRouteKeys = null)
         {
+            if (ignoredRouteKeys != null)
+            {
+                linkGenerationTestContext.RouteValues = linkGenerationTestContext
+                    .RouteValues
+                    ?.Where(kvp => !ignoredRouteKeys.Contains(kvp.Key))
+                    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+            }
+
             string uri = null;
             if (!string.IsNullOrWhiteSpace(linkGenerationTestContext.Location))
             {

src/MyTested.AspNetCore.Mvc.Controllers/Utilities/Validators/RouteActionResultValidator.cs

@@ -279,8 +279,15 @@ public static void ValidateExpressionLink(
                 .GetRequiredService<IUrlHelperFactory>()
                 .GetUrlHelper(actionContext);
 
-            var expectedUri = urlHelper.ExpressionLink(expectedRouteValuesAsLambdaExpression);
-            var actualUri = urlHelper.GenerateLink(linkGenerationTestContext, controllerTestContext);
+            ICollection<string> ignoredRouteKeys;
+            var expectedUri = urlHelper.ExpressionLink(
+                expectedRouteValuesAsLambdaExpression,
+                out ignoredRouteKeys);
+            
+            var actualUri = urlHelper.GenerateLink(
+                linkGenerationTestContext,
+                controllerTestContext,
+                ignoredRouteKeys);
 
             if (!string.Equals(expectedUri, actualUri, StringComparison.OrdinalIgnoreCase))
             {

test/MyTested.AspNetCore.Mvc.Controllers.Test/BuildersTests/ActionResultsTests/RedirectTests/RedirectTestBuilderTests.cs

@@ -522,7 +522,7 @@ public void EverySpecificMethodShouldThrowExceptionWhenSuchPropertyIsNotFound()
         }
 
         [Fact]
-        public void AtShouldWorkCorrectlyWithCorrectActionCall()
+        public void ToShouldWorkCorrectlyWithCorrectActionCall()
         {
             MyApplication.StartsFrom<RoutingStartup>();
 
@@ -537,7 +537,22 @@ public void AtShouldWorkCorrectlyWithCorrectActionCall()
         }
 
         [Fact]
-        public void AtShouldWorkCorrectlyWithCorrectVoidActionCall()
+        public void ToShouldWorkCorrectlyWithWithAnyCall()
+        {
+            MyApplication.StartsFrom<RoutingStartup>();
+
+            MyController<MvcController>
+                .Instance()
+                .Calling(c => c.RedirectToRouteAction())
+                .ShouldReturn()
+                .Redirect()
+                .To<NoAttributesController>(c => c.WithParameter(With.Any<int>()));
+
+            MyApplication.IsUsingDefaultConfiguration();
+        }
+
+        [Fact]
+        public void ToShouldWorkCorrectlyWithCorrectVoidActionCall()
         {
             MyApplication.StartsFrom<RoutingStartup>();
 
@@ -552,7 +567,7 @@ public void AtShouldWorkCorrectlyWithCorrectVoidActionCall()
         }
 
         [Fact]
-        public void AtShouldWorkCorrectlyWithCorrectTaskActionCall()
+        public void ToShouldWorkCorrectlyWithCorrectTaskActionCall()
         {
             MyApplication.StartsFrom<RoutingStartup>();