RedirectToPage(page, handler) does not work (#6503)

Fixes #6436

src/Microsoft.AspNetCore.Mvc.Core/ControllerBase.cs

@@ -1002,7 +1002,7 @@ namespace Microsoft.AspNetCore.Mvc
         /// <returns>The <see cref="RedirectToPageResult"/> with <see cref="RedirectToPageResult.Permanent"/> set.</returns>
         [NonAction]
         public virtual RedirectToPageResult RedirectToPagePermanent(string pageName, string pageHandler)
-            => RedirectToPagePermanent(pageName, routeValues: null);
+            => RedirectToPagePermanent(pageName, pageHandler, routeValues: null, fragment: null);
 
         /// <summary>
         /// Redirects (<see cref="StatusCodes.Status301MovedPermanently"/>) to the specified <paramref name="pageName"/>

src/Microsoft.AspNetCore.Mvc.RazorPages/PageBase.cs

@@ -972,7 +972,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
         /// <param name="pageHandler">The page handler to redirect to.</param>
         /// <returns>The <see cref="RedirectToPageResult"/>.</returns>
         public virtual RedirectToPageResult RedirectToPage(string pageName, string pageHandler)
-            => RedirectToPage(pageName, routeValues: null);
+            => RedirectToPage(pageName, pageHandler, routeValues: null, fragment: null);
 
         /// <summary>
         /// Redirects (<see cref="StatusCodes.Status302Found"/>) to the specified <paramref name="pageName"/>
@@ -1066,7 +1066,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
         /// <param name="routeValues">The parameters for a route.</param>
         /// <param name="fragment">The fragment to add to the URL.</param>
         /// <returns>The <see cref="RedirectToPageResult"/> with <see cref="RedirectToPageResult.Permanent"/> set.</returns>
-        protected RedirectToPageResult RedirectToPagePermanent(string pageName, string pageHandler, object routeValues, string fragment)
+        public virtual RedirectToPageResult RedirectToPagePermanent(string pageName, string pageHandler, object routeValues, string fragment)
             => new RedirectToPageResult(pageName, pageHandler, routeValues, permanent: true, fragment: fragment);
 
         /// <summary>

test/Microsoft.AspNetCore.Mvc.Core.Test/ControllerBaseTest.cs

@@ -986,6 +986,213 @@ namespace Microsoft.AspNetCore.Mvc.Core.Test
             Assert.Equal(expected, resultPermanent.RouteValues);
         }
 
+        [Fact]
+        public void RedirectToPage_WithPageName()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page";
+
+            // Act
+            var result = controller.RedirectToPage(pageName);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameAndHandler()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+
+            // Act
+            var result = controller.RedirectToPage(pageName, pageHandler);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameAndRouteValues()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var routeVaues = new { key = "value" };
+
+            // Act
+            var result = controller.RedirectToPage(pageName, routeVaues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameHandlerAndFragment()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+
+            // Act
+            var result = controller.RedirectToPage(pageName, pageHandler, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Equal(fragment, result.Fragment);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameRouteValuesHandlerAndFragment()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = controller.RedirectToPage(pageName, pageHandler, routeValues, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.Equal(fragment, result.Fragment);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageName()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+
+            // Act
+            var result = controller.RedirectToPagePermanent(pageName);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNameAndPageHandler()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+
+            // Act
+            var result = controller.RedirectToPagePermanent(pageName, pageHandler);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNameAndRouteValues()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = controller.RedirectToPagePermanent(pageName, routeValues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerAndFragment()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+
+            // Act
+            var result = controller.RedirectToPagePermanent(pageName, pageHandler, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Equal(fragment, result.Fragment);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerRouteValuesAndFragment()
+        {
+            // Arrange
+            var controller = new TestableController();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var routeValues = new { key = "value" };
+            var fragment = "fragment";
+
+            // Act
+            var result = controller.RedirectToPagePermanent(pageName, pageHandler, routeValues, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.Equal(fragment, result.Fragment);
+            Assert.True(result.Permanent);
+        }
+
         [Fact]
         public void RedirectToPagePreserveMethod_WithParameterUrl_SetsRedirectResultPreserveMethod()
         {

test/Microsoft.AspNetCore.Mvc.RazorPages.Test/PageModelTest.cs

@@ -937,6 +937,275 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
             }
         }
 
+        [Fact]
+        public void RedirectToPage_WithNoArguments()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+
+            // Act
+            var result = pageModel.RedirectToPage();
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Null(result.PageName);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageName()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page";
+
+            // Act
+            var result = pageModel.RedirectToPage(pageName);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithRouteValues()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = pageModel.RedirectToPage(routeValues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Null(result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameAndHandler()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+
+            // Act
+            var result = pageModel.RedirectToPage(pageName, pageHandler);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameAndRouteValues()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var routeVaues = new { key = "value" };
+
+            // Act
+            var result = pageModel.RedirectToPage(pageName, routeVaues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameHandlerAndFragment()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+
+            // Act
+            var result = pageModel.RedirectToPage(pageName, pageHandler, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Equal(fragment, result.Fragment);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameRouteValuesHandlerAndFragment()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = pageModel.RedirectToPage(pageName, pageHandler, routeValues, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.Equal(fragment, result.Fragment);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageName()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+
+            // Act
+            var result = pageModel.RedirectToPagePermanent(pageName);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNameAndPageHandler()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+
+            // Act
+            var result = pageModel.RedirectToPagePermanent(pageName, pageHandler);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNameAndRouteValues()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = pageModel.RedirectToPagePermanent(pageName, routeValues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerAndRouteValues()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = pageModel.RedirectToPagePermanent(pageName, pageHandler, routeValues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerAndFragment()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+
+            // Act
+            var result = pageModel.RedirectToPagePermanent(pageName, pageHandler, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Equal(fragment, result.Fragment);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerRouteValuesAndFragment()
+        {
+            // Arrange
+            var pageModel = new TestPageModel();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var routeValues = new { key = "value" };
+            var fragment = "fragment";
+
+            // Act
+            var result = pageModel.RedirectToPagePermanent(pageName, pageHandler, routeValues, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.Equal(fragment, result.Fragment);
+            Assert.True(result.Permanent);
+        }
+
         [Fact]
         public void RedirectToPagePreserveMethod_WithParameterUrl_SetsRedirectResultPreserveMethod()
         {

test/Microsoft.AspNetCore.Mvc.RazorPages.Test/PageTest.cs

@@ -1023,6 +1023,275 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages
             Assert.Equal(expected, resultPermanent.RouteValues);
         }
 
+        [Fact]
+        public void RedirectToPage_WithNoArguments()
+        {
+            // Arrange
+            var page = new TestPage();
+
+            // Act
+            var result = page.RedirectToPage();
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Null(result.PageName);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageName()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page";
+
+            // Act
+            var result = page.RedirectToPage(pageName);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithRouteValues()
+        {
+            // Arrange
+            var page = new TestPage();
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = page.RedirectToPage(routeValues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Null(result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameAndHandler()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+
+            // Act
+            var result = page.RedirectToPage(pageName, pageHandler);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameAndRouteValues()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var routeVaues = new { key = "value" };
+
+            // Act
+            var result = page.RedirectToPage(pageName, routeVaues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameHandlerAndFragment()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+
+            // Act
+            var result = page.RedirectToPage(pageName, pageHandler, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Equal(fragment, result.Fragment);
+        }
+
+        [Fact]
+        public void RedirectToPage_WithPageNameRouteValuesHandlerAndFragment()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = page.RedirectToPage(pageName, pageHandler, routeValues, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.Equal(fragment, result.Fragment);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageName()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+
+            // Act
+            var result = page.RedirectToPagePermanent(pageName);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNameAndPageHandler()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+
+            // Act
+            var result = page.RedirectToPagePermanent(pageName, pageHandler);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNameAndRouteValues()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = page.RedirectToPagePermanent(pageName, routeValues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerAndRouteValues()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var routeValues = new { key = "value" };
+
+            // Act
+            var result = page.RedirectToPagePermanent(pageName, pageHandler, routeValues);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerAndFragment()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var fragment = "fragment";
+
+            // Act
+            var result = page.RedirectToPagePermanent(pageName, pageHandler, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Equal(fragment, result.Fragment);
+            Assert.True(result.Permanent);
+        }
+
+        [Fact]
+        public void RedirectToPagePermanent_WithPageNamePageHandlerRouteValuesAndFragment()
+        {
+            // Arrange
+            var page = new TestPage();
+            var pageName = "/Page-Name";
+            var pageHandler = "page-handler";
+            var routeValues = new { key = "value" };
+            var fragment = "fragment";
+
+            // Act
+            var result = page.RedirectToPagePermanent(pageName, pageHandler, routeValues, fragment);
+
+            // Assert
+            Assert.IsType<RedirectToPageResult>(result);
+            Assert.Equal(pageName, result.PageName);
+            Assert.Equal(pageHandler, result.PageHandler);
+            Assert.Collection(
+                result.RouteValues,
+                item =>
+                {
+                    Assert.Equal("key", item.Key);
+                    Assert.Equal("value", item.Value);
+                });
+            Assert.Equal(fragment, result.Fragment);
+            Assert.True(result.Permanent);
+        }
+
         [Fact]
         public void RedirectToPagePreserveMethod_WithParameterUrl_SetsRedirectResultPreserveMethod()
         {