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

Fixes #6436
2017-07-06 14:12:57 -07:00 · 2017-07-06 14:12:57 -07:00 · 288da1a405
parent 8b9b8beb1d
commit 288da1a405
5 changed files with 748 additions and 3 deletions
--- a/src/Microsoft.AspNetCore.Mvc.Core/ControllerBase.cs
+++ b/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"/>
--- a/src/Microsoft.AspNetCore.Mvc.RazorPages/PageBase.cs
+++ b/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>
--- a/test/Microsoft.AspNetCore.Mvc.Core.Test/ControllerBaseTest.cs
+++ b/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()
        {
--- a/test/Microsoft.AspNetCore.Mvc.RazorPages.Test/PageModelTest.cs
+++ b/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()
        {
--- a/test/Microsoft.AspNetCore.Mvc.RazorPages.Test/PageTest.cs
+++ b/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()
        {