Added support for razor pages, added tests and functional tests to validate the implementation

Author: javiercn

src/Mvc/Mvc.Core/test/Routing/DynamicControllerEndpointMatcherPolicyTest.cs

@@ -58,7 +58,7 @@ public DynamicControllerEndpointMatcherPolicyTest()
                 _ => Task.CompletedTask,
                 new EndpointMetadataCollection(new object[]
                 {
-                    new DynamicControllerRouteValueTransformerMetadata(typeof(CustomTransformer), null),
+                    new DynamicControllerRouteValueTransformerMetadata(typeof(CustomTransformer), State),
                 }),
                 "dynamic");
 
@@ -71,7 +71,8 @@ public DynamicControllerEndpointMatcherPolicyTest()
             services.AddScoped<CustomTransformer>(s =>
             {
                 var transformer = new CustomTransformer();
-                transformer.Transform = (c, values) => Transform(c, values);
+                transformer.Transform = (c, values, state) => Transform(c, values, state);
+                transformer.Filter = (c, values, state, candidates) => Filter(c, values, state, candidates);
                 return transformer;
             });
             Services = services.BuildServiceProvider();
@@ -91,7 +92,11 @@ public DynamicControllerEndpointMatcherPolicyTest()
 
         private IServiceProvider Services { get; }
 
-        private Func<HttpContext, RouteValueDictionary, ValueTask<RouteValueDictionary>> Transform { get; set; }
+        private Func<HttpContext, RouteValueDictionary, object, ValueTask<RouteValueDictionary>> Transform { get; set; }
+
+        private Func<HttpContext, RouteValueDictionary, object, IReadOnlyList<Endpoint>, ValueTask<IReadOnlyList<Endpoint>>> Filter { get; set; } = (_, __, ___, e) => new ValueTask<IReadOnlyList<Endpoint>>(e);
+
+        private object State { get; } = new object();
 
         [Fact]
         public async Task ApplyAsync_NoMatch()
@@ -106,7 +111,7 @@ public async Task ApplyAsync_NoMatch()
             var candidates = new CandidateSet(endpoints, values, scores);
             candidates.SetValidity(0, false);
 
-            Transform = (c, values) =>
+            Transform = (c, values, state) =>
             {
                 throw new InvalidOperationException();
             };
@@ -135,7 +140,7 @@ public async Task ApplyAsync_HasMatchNoEndpointFound()
 
             var candidates = new CandidateSet(endpoints, values, scores);
 
-            Transform = (c, values) =>
+            Transform = (c, values, state) =>
             {
                 return new ValueTask<RouteValueDictionary>(new RouteValueDictionary());
             };
@@ -166,7 +171,7 @@ public async Task ApplyAsync_HasMatchFindsEndpoint_WithoutRouteValues()
 
             var candidates = new CandidateSet(endpoints, values, scores);
 
-            Transform = (c, values) =>
+            Transform = (c, values, state) =>
             {
                 return new ValueTask<RouteValueDictionary>(new RouteValueDictionary(new
                 {
@@ -212,12 +217,13 @@ public async Task ApplyAsync_HasMatchFindsEndpoint_WithRouteValues()
 
             var candidates = new CandidateSet(endpoints, values, scores);
 
-            Transform = (c, values) =>
+            Transform = (c, values, state) =>
             {
                 return new ValueTask<RouteValueDictionary>(new RouteValueDictionary(new
                 {
                     controller = "Home",
                     action = "Index",
+                    state
                 }));
             };
 
@@ -242,13 +248,162 @@ public async Task ApplyAsync_HasMatchFindsEndpoint_WithRouteValues()
                 {
                     Assert.Equal("controller", kvp.Key);
                     Assert.Equal("Home", kvp.Value);
-                }, 
+                },
+                kvp =>
+                {
+                    Assert.Equal("slug", kvp.Key);
+                    Assert.Equal("test", kvp.Value);
+                },
+                kvp =>
+                {
+                    Assert.Equal("state", kvp.Key);
+                    Assert.Same(State, kvp.Value);
+                });
+            Assert.True(candidates.IsValidCandidate(0));
+        }
+
+        [Fact]
+        public async Task ApplyAsync_CanDiscardFoundEndpoints()
+        {
+            // Arrange
+            var policy = new DynamicControllerEndpointMatcherPolicy(Selector, Comparer);
+
+            var endpoints = new[] { DynamicEndpoint, };
+            var values = new RouteValueDictionary[] { new RouteValueDictionary(new { slug = "test", }), };
+            var scores = new[] { 0, };
+
+            var candidates = new CandidateSet(endpoints, values, scores);
+
+            Transform = (c, values, state) =>
+            {
+                return new ValueTask<RouteValueDictionary>(new RouteValueDictionary(new
+                {
+                    controller = "Home",
+                    action = "Index",
+                    state
+                }));
+            };
+
+            Filter = (c, values, state, endpoints) =>
+            {
+                return new ValueTask<IReadOnlyList<Endpoint>>(Array.Empty<Endpoint>());
+            };
+
+            var httpContext = new DefaultHttpContext()
+            {
+                RequestServices = Services,
+            };
+
+            // Act
+            await policy.ApplyAsync(httpContext, candidates);
+
+            // Assert
+            Assert.False(candidates.IsValidCandidate(0));
+        }
+
+        [Fact]
+        public async Task ApplyAsync_CanReplaceFoundEndpoints()
+        {
+            // Arrange
+            var policy = new DynamicControllerEndpointMatcherPolicy(Selector, Comparer);
+
+            var endpoints = new[] { DynamicEndpoint, };
+            var values = new RouteValueDictionary[] { new RouteValueDictionary(new { slug = "test", }), };
+            var scores = new[] { 0, };
+
+            var candidates = new CandidateSet(endpoints, values, scores);
+
+            Transform = (c, values, state) =>
+            {
+                return new ValueTask<RouteValueDictionary>(new RouteValueDictionary(new
+                {
+                    controller = "Home",
+                    action = "Index",
+                    state
+                }));
+            };
+
+            Filter = (c, values, state, endpoints) => new ValueTask<IReadOnlyList<Endpoint>>(new[]
+            {
+                new Endpoint((ctx) => Task.CompletedTask, new EndpointMetadataCollection(Array.Empty<object>()), "ReplacedEndpoint")
+            });
+
+            var httpContext = new DefaultHttpContext()
+            {
+                RequestServices = Services,
+            };
+
+            // Act
+            await policy.ApplyAsync(httpContext, candidates);
+
+            // Assert
+            Assert.Collection(
+                candidates[0].Values.OrderBy(kvp => kvp.Key),
+                kvp =>
+                {
+                    Assert.Equal("action", kvp.Key);
+                    Assert.Equal("Index", kvp.Value);
+                },
+                kvp =>
+                {
+                    Assert.Equal("controller", kvp.Key);
+                    Assert.Equal("Home", kvp.Value);
+                },
                 kvp =>
                 {
                     Assert.Equal("slug", kvp.Key);
                     Assert.Equal("test", kvp.Value);
+                },
+                kvp =>
+                {
+                    Assert.Equal("state", kvp.Key);
+                    Assert.Same(State, kvp.Value);
                 });
+            Assert.Equal("ReplacedEndpoint", candidates[0].Endpoint.DisplayName);
+            Assert.True(candidates.IsValidCandidate(0));
+        }
+
+        [Fact]
+        public async Task ApplyAsync_CanExpandTheListOfFoundEndpoints()
+        {
+            // Arrange
+            var policy = new DynamicControllerEndpointMatcherPolicy(Selector, Comparer);
+
+            var endpoints = new[] { DynamicEndpoint, };
+            var values = new RouteValueDictionary[] { new RouteValueDictionary(new { slug = "test", }), };
+            var scores = new[] { 0, };
+
+            var candidates = new CandidateSet(endpoints, values, scores);
+
+            Transform = (c, values, state) =>
+            {
+                return new ValueTask<RouteValueDictionary>(new RouteValueDictionary(new
+                {
+                    controller = "Home",
+                    action = "Index",
+                    state
+                }));
+            };
+
+            Filter = (c, values, state, endpoints) => new ValueTask<IReadOnlyList<Endpoint>>(new[]
+            {
+                ControllerEndpoints[1], ControllerEndpoints[2]
+            });
+
+            var httpContext = new DefaultHttpContext()
+            {
+                RequestServices = Services,
+            };
+
+            // Act
+            await policy.ApplyAsync(httpContext, candidates);
+
+            // Assert
+            Assert.Equal(2, candidates.Count);
             Assert.True(candidates.IsValidCandidate(0));
+            Assert.True(candidates.IsValidCandidate(1));
+            Assert.Same(ControllerEndpoints[1], candidates[0].Endpoint);
+            Assert.Same(ControllerEndpoints[2], candidates[1].Endpoint);
         }
 
         private class TestDynamicControllerEndpointSelector : DynamicControllerEndpointSelector
@@ -261,11 +416,18 @@ public TestDynamicControllerEndpointSelector(EndpointDataSource dataSource)
 
         private class CustomTransformer : DynamicRouteValueTransformer
         {
-            public Func<HttpContext, RouteValueDictionary, ValueTask<RouteValueDictionary>> Transform { get; set; }
+            public Func<HttpContext, RouteValueDictionary, object, ValueTask<RouteValueDictionary>> Transform { get; set; }
+
+            public Func<HttpContext, RouteValueDictionary, object, IReadOnlyList<Endpoint>, ValueTask<IReadOnlyList<Endpoint>>> Filter { get; set; }
 
             public override ValueTask<RouteValueDictionary> TransformAsync(HttpContext httpContext, RouteValueDictionary values)
             {
-                return Transform(httpContext, values);
+                return Transform(httpContext, values, State);
+            }
+
+            public override ValueTask<IReadOnlyList<Endpoint>> FilterAsync(HttpContext httpContext, RouteValueDictionary values, IReadOnlyList<Endpoint> endpoints)
+            {
+                return Filter(httpContext, values, State, endpoints);
             }
         }
     }

src/Mvc/Mvc.RazorPages/src/Builder/RazorPagesEndpointRouteBuilderExtensions.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -299,6 +299,30 @@ public static IEndpointConventionBuilder MapFallbackToAreaPage(
         /// </remarks>
         public static void MapDynamicPageRoute<TTransformer>(this IEndpointRouteBuilder endpoints, string pattern)
             where TTransformer : DynamicRouteValueTransformer
+        {
+            MapDynamicPageRoute<TTransformer>(endpoints, pattern, state: null);
+        }
+
+        /// <summary>
+        /// Adds a specialized <see cref="RouteEndpoint"/> to the <see cref="IEndpointRouteBuilder"/> that will
+        /// attempt to select a page using the route values produced by <typeparamref name="TTransformer"/>.
+        /// </summary>
+        /// <param name="endpoints">The <see cref="IEndpointRouteBuilder"/> to add the route to.</param>
+        /// <param name="pattern">The URL pattern of the route.</param>
+        /// <param name="state">A state object to provide to the <typeparamref name="TTransformer" /> instance.</param>
+        /// <typeparam name="TTransformer">The type of a <see cref="DynamicRouteValueTransformer"/>.</typeparam>
+        /// <remarks>
+        /// <para>
+        /// This method allows the registration of a <see cref="RouteEndpoint"/> and <see cref="DynamicRouteValueTransformer"/>
+        /// that combine to dynamically select a page using custom logic.
+        /// </para>
+        /// <para>
+        /// The instance of <typeparamref name="TTransformer"/> will be retrieved from the dependency injection container.
+        /// Register <typeparamref name="TTransformer"/> with the desired service lifetime in <c>ConfigureServices</c>.
+        /// </para>
+        /// </remarks>
+        public static void MapDynamicPageRoute<TTransformer>(this IEndpointRouteBuilder endpoints, string pattern, object state)
+            where TTransformer : DynamicRouteValueTransformer
         {
             if (endpoints == null)
             {
@@ -316,14 +340,14 @@ public static void MapDynamicPageRoute<TTransformer>(this IEndpointRouteBuilder
             GetOrCreateDataSource(endpoints).CreateInertEndpoints = true;
 
             endpoints.Map(
-                pattern, 
+                pattern,
                 context =>
                 {
                     throw new InvalidOperationException("This endpoint is not expected to be executed directly.");
                 })
                 .Add(b =>
                 {
-                    b.Metadata.Add(new DynamicPageRouteValueTransformerMetadata(typeof(TTransformer)));
+                    b.Metadata.Add(new DynamicPageRouteValueTransformerMetadata(typeof(TTransformer), state));
                 });
         }
 

src/Mvc/Mvc.RazorPages/src/Infrastructure/DynamicPageEndpointMatcherPolicy.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -105,13 +105,15 @@ public async Task ApplyAsync(HttpContext httpContext, CandidateSet candidates)
                 // no realistic way this could happen.
                 var dynamicPageMetadata = endpoint.Metadata.GetMetadata<DynamicPageMetadata>();
                 var transformerMetadata = endpoint.Metadata.GetMetadata<DynamicPageRouteValueTransformerMetadata>();
+                DynamicRouteValueTransformer transformer = null;
                 if (dynamicPageMetadata != null)
                 {
                     dynamicValues = dynamicPageMetadata.Values;
                 }
                 else if (transformerMetadata != null)
                 {
-                    var transformer = (DynamicRouteValueTransformer)httpContext.RequestServices.GetRequiredService(transformerMetadata.SelectorType);
+                    transformer = (DynamicRouteValueTransformer)httpContext.RequestServices.GetRequiredService(transformerMetadata.SelectorType);
+                    transformer.State = transformerMetadata.State;
                     dynamicValues = await transformer.TransformAsync(httpContext, originalValues);
                 }
                 else
@@ -154,6 +156,16 @@ public async Task ApplyAsync(HttpContext httpContext, CandidateSet candidates)
                     }
                 }
 
+                if (transformer != null)
+                {
+                    endpoints = await transformer.FilterAsync(httpContext, values, endpoints);
+                    if (endpoints.Count == 0)
+                    {
+                        candidates.ReplaceEndpoint(i, null, null);
+                        continue;
+                    }
+                }
+
                 // Update the route values
                 candidates.ReplaceEndpoint(i, endpoint, values);
 

src/Mvc/Mvc.RazorPages/src/Infrastructure/DynamicPageRouteValueTransformerMetadata.cs

@@ -1,4 +1,4 @@
-// Copyright (c) .NET Foundation. All rights reserved.
+// Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
@@ -9,7 +9,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure
 {
     internal class DynamicPageRouteValueTransformerMetadata : IDynamicEndpointMetadata
     {
-        public DynamicPageRouteValueTransformerMetadata(Type selectorType)
+        public DynamicPageRouteValueTransformerMetadata(Type selectorType, object state)
         {
             if (selectorType == null)
             {
@@ -24,10 +24,13 @@ public DynamicPageRouteValueTransformerMetadata(Type selectorType)
             }
 
             SelectorType = selectorType;
+            State = state;
         }
 
         public bool IsDynamic => true;
 
+        public object State { get; }
+
         public Type SelectorType { get; }
     }
 }