ControllerTest.cs

// 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.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.IO;
using System.Reflection;
using System.Security.Principal;
using System.Text;
using System.Web.Mvc.Async;
using System.Web.Profile;
using System.Web.Routing;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;
using Moq.Protected;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ControllerTest
    {
        [Fact]
        public void ActionInvokerProperty()
        {
            // Arrange
            Controller controller = new EmptyController();

            // Act & Assert
            MemberHelper.TestPropertyWithDefaultInstance(controller, "ActionInvoker", new ControllerActionInvoker());
        }

        [Fact]
        public void ContentWithContentString()
        {
            // Arrange
            Controller controller = new EmptyController();
            string content = "Some content";

            // Act
            ContentResult result = controller.Content(content);

            // Assert
            Assert.Equal(content, result.Content);
        }

        [Fact]
        public void ContentWithContentStringAndContentType()
        {
            // Arrange
            Controller controller = new EmptyController();
            string content = "Some content";
            string contentType = "Some content type";

            // Act
            ContentResult result = controller.Content(content, contentType);

            // Assert
            Assert.Equal(content, result.Content);
            Assert.Equal(contentType, result.ContentType);
        }

        [Fact]
        public void ContentWithContentStringAndContentTypeAndEncoding()
        {
            // Arrange
            Controller controller = new EmptyController();
            string content = "Some content";
            string contentType = "Some content type";
            Encoding contentEncoding = Encoding.UTF8;

            // Act
            ContentResult result = controller.Content(content, contentType, contentEncoding);

            // Assert
            Assert.Equal(content, result.Content);
            Assert.Equal(contentType, result.ContentType);
            Assert.Same(contentEncoding, result.ContentEncoding);
        }

        [Fact]
        public void ContextProperty()
        {
            var controller = new EmptyController();
            MemberHelper.TestPropertyValue(controller, "ControllerContext", new Mock<ControllerContext>().Object);
        }

        [Fact]
        public void HttpContextProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.HttpContext);

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext).Returns(mockHttpContext.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockHttpContext.Object, c.HttpContext);
        }

        [Fact]
        public void HttpNotFound()
        {
            // Arrange
            var c = new EmptyController();

            // Act
            HttpNotFoundResult result = c.HttpNotFound();

            // Assert
            Assert.NotNull(result);
            Assert.Null(result.StatusDescription);
            Assert.Equal(404, result.StatusCode);
        }

        [Fact]
        public void HttpNotFoundWithNullStatusDescription()
        {
            // Arrange
            var c = new EmptyController();

            // Act
            HttpNotFoundResult result = c.HttpNotFound(statusDescription: null);

            // Assert
            Assert.NotNull(result);
            Assert.Null(result.StatusDescription);
            Assert.Equal(404, result.StatusCode);
        }

        [Fact]
        public void HttpNotFoundWithStatusDescription()
        {
            // Arrange
            var c = new EmptyController();

            // Act
            HttpNotFoundResult result = c.HttpNotFound(statusDescription: "I lost it");

            // Assert
            Assert.NotNull(result);
            Assert.Equal("I lost it", result.StatusDescription);
            Assert.Equal(404, result.StatusCode);
        }

        [Fact]
        public void ModelStateProperty()
        {
            // Arrange
            Controller controller = new EmptyController();

            // Act & assert
            Assert.Same(controller.ViewData.ModelState, controller.ModelState);
        }

        [Fact]
        public void ProfileProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Profile);

            Mock<ProfileBase> mockProfile = new Mock<ProfileBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Profile).Returns(mockProfile.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockProfile.Object, c.Profile);
        }

        [Fact]
        public void RequestProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpRequestBase> mockHttpRequest = new Mock<HttpRequestBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Request).Returns(mockHttpRequest.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockHttpRequest.Object, c.Request);
        }

        [Fact]
        public void ResponseProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpResponseBase> mockHttpResponse = new Mock<HttpResponseBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Response).Returns(mockHttpResponse.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockHttpResponse.Object, c.Response);
        }

        [Fact]
        public void ServerProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpServerUtilityBase> mockServerUtility = new Mock<HttpServerUtilityBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Server).Returns(mockServerUtility.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockServerUtility.Object, c.Server);
        }

        [Fact]
        public void SessionProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpSessionStateBase> mockSessionState = new Mock<HttpSessionStateBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Session).Returns(mockSessionState.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Same(mockSessionState.Object, c.Session);
        }

        [Fact]
        public void UrlProperty()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());

            // Act
            controller.PublicInitialize(requestContext);

            // Assert
            Assert.NotNull(controller.Url);
        }

        [Fact]
        public void UserProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<IPrincipal> mockUser = new Mock<IPrincipal>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.User).Returns(mockUser.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockUser.Object, c.User);
        }

        [Fact]
        public void RouteDataProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            RouteData rd = new RouteData();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.RouteData).Returns(rd);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(rd, c.RouteData);
        }

        [Fact]
        public void ControllerMethodsDoNotHaveNonActionAttribute()
        {
            var methods = typeof(Controller).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            foreach (var method in methods)
            {
                var attrs = method.GetCustomAttributes(typeof(NonActionAttribute), true /* inherit */);
                Assert.True(attrs.Length == 0, "Methods on the Controller class should not be marked [NonAction]: " + method);
            }
        }

        [Fact]
        public void DisposeCallsProtectedDisposingMethod()
        {
            // Arrange
            Mock<Controller> mockController = new Mock<Controller>();
            mockController.Protected().Setup("Dispose", true).Verifiable();
            Controller controller = mockController.Object;

            // Act
            controller.Dispose();

            // Assert
            mockController.Verify();
        }

        [Fact]
        public void ExecuteWithUnknownAction()
        {
            // Arrange
            UnknownActionController controller = new UnknownActionController();
            // We need a provider since Controller.Execute is called
            controller.TempDataProvider = new EmptyTempDataProvider();
            ControllerContext context = GetControllerContext("Foo");

            Mock<IActionInvoker> mockInvoker = new Mock<IActionInvoker>();
            mockInvoker.Setup(o => o.InvokeAction(context, "Foo")).Returns(false);
            controller.ActionInvoker = mockInvoker.Object;

            // Act
            ((IController)controller).Execute(context.RequestContext);

            // Assert
            Assert.True(controller.WasCalled);
        }

        [Fact]
        public void FileWithContents()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            byte[] fileContents = new byte[0];

            // Act
            FileContentResult result = controller.File(fileContents, "someContentType");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileContents, result.FileContents);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal(String.Empty, result.FileDownloadName);
        }

        [Fact]
        public void FileWithContentsAndFileDownloadName()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            byte[] fileContents = new byte[0];

            // Act
            FileContentResult result = controller.File(fileContents, "someContentType", "someDownloadName");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileContents, result.FileContents);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal("someDownloadName", result.FileDownloadName);
        }

        [Fact]
        public void FileWithPath()
        {
            // Arrange
            EmptyController controller = new EmptyController();

            // Act
            FilePathResult result = controller.File("somePath", "someContentType");

            // Assert
            Assert.NotNull(result);
            Assert.Equal("somePath", result.FileName);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal(String.Empty, result.FileDownloadName);
        }

        [Fact]
        public void FileWithPathAndFileDownloadName()
        {
            // Arrange
            EmptyController controller = new EmptyController();

            // Act
            FilePathResult result = controller.File("somePath", "someContentType", "someDownloadName");

            // Assert
            Assert.NotNull(result);
            Assert.Equal("somePath", result.FileName);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal("someDownloadName", result.FileDownloadName);
        }

        [Fact]
        public void FileWithStream()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            Stream fileStream = Stream.Null;

            // Act
            FileStreamResult result = controller.File(fileStream, "someContentType");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileStream, result.FileStream);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal(String.Empty, result.FileDownloadName);
        }

        [Fact]
        public void FileWithStreamAndFileDownloadName()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            Stream fileStream = Stream.Null;

            // Act
            FileStreamResult result = controller.File(fileStream, "someContentType", "someDownloadName");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileStream, result.FileStream);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal("someDownloadName", result.FileDownloadName);
        }

        [Fact]
        public void HandleUnknownActionThrows()
        {
            var controller = new EmptyController();
            Assert.Throws<HttpException>(
                delegate { controller.HandleUnknownAction("UnknownAction"); },
                "A public action method 'UnknownAction' was not found on controller 'System.Web.Mvc.Test.ControllerTest+EmptyController'.");
        }

        /// <summary>
        /// This is a scenario for attribute routing, we don't have a single action nameat this point
        /// </summary>
        [Fact]
        public void HandleUnknownAction_NoActionName_Throws()
        {
            var controller = new EmptyController();
            Assert.Throws<HttpException>(
                delegate { controller.HandleUnknownAction(null); },
                "No matching action was found on controller 'System.Web.Mvc.Test.ControllerTest+EmptyController'. " +
                "This can happen when a controller uses RouteAttribute for routing, but no action on that controller matches the request.");
        }

        [Fact]
        public void JavaScript()
        {
            // Arrange
            Controller controller = GetEmptyController();
            string script = "alert('foo');";

            // Act
            JavaScriptResult result = controller.JavaScript(script);

            // Assert
            Assert.Equal(script, result.Script);
        }

        [Fact]
        public void PartialView()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            PartialViewResult result = controller.PartialView();

            // Assert
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
            Assert.Same(ViewEngines.Engines, result.ViewEngineCollection);
        }

        [Fact]
        public void PartialView_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object model = new object();

            // Act
            PartialViewResult result = controller.PartialView(model);

            // Assert
            Assert.Same(model, result.ViewData.Model);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
        }

        [Fact]
        public void PartialView_ViewName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            PartialViewResult result = controller.PartialView("Some partial view");

            // Assert
            Assert.Equal("Some partial view", result.ViewName);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
        }

        [Fact]
        public void PartialView_ViewName_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object model = new object();

            // Act
            PartialViewResult result = controller.PartialView("Some partial view", model);

            // Assert
            Assert.Equal("Some partial view", result.ViewName);
            Assert.Same(model, result.ViewData.Model);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
        }

        [Fact]
        public void PartialView_ViewEngineCollection()
        {
            // Arrange
            Controller controller = GetEmptyController();
            ViewEngineCollection viewEngines = new ViewEngineCollection();
            controller.ViewEngineCollection = viewEngines;

            // Act
            PartialViewResult result = controller.PartialView();

            // Assert
            Assert.Same(viewEngines, result.ViewEngineCollection);
        }

        [Fact]
        public void RedirectToActionClonesRouteValueDictionary()
        {
            // The RedirectToAction() method should clone the provided dictionary, then operate on the clone.
            // The original dictionary should remain unmodified throughout the helper's execution.

            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary(new { Action = "SomeAction", Controller = "SomeController" });

            // Act
            controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);

            // Assert
            Assert.Equal(2, values.Count);
            Assert.Equal("SomeAction", values["action"]);
            Assert.Equal("SomeController", values["controller"]);
        }

        [Fact]
        public void RedirectToActionOverwritesActionDictionaryKey()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Action = "SomeAction" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Equal("SomeOtherAction", newValues["action"]);
        }

        [Fact]
        public void RedirectToActionOverwritesControllerDictionaryKeyIfSpecified()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Action = "SomeAction", Controller = "SomeController" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Equal("SomeOtherController", newValues["controller"]);
        }

        [Fact]
        public void RedirectToActionPreservesControllerDictionaryKeyIfNotSpecified()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Controller = "SomeController" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Equal("SomeController", newValues["controller"]);
        }

        [Fact]
        public void RedirectToActionWithActionName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction");

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndControllerName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController");

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeOtherController", result.RouteValues["controller"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndControllerNameAndValuesDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary(new { Foo = "SomeFoo" });

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeOtherController", result.RouteValues["controller"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndControllerNameAndValuesObject()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Foo = "SomeFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeOtherController", result.RouteValues["controller"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionSelectsCurrentControllerByDefault()
        {
            // Arrange
            TestRouteController controller = new TestRouteController();
            controller.ControllerContext = GetControllerContext("SomeAction", "TestRoute");

            // Act
            RedirectToRouteResult route = controller.Index() as RedirectToRouteResult;

            // Assert
            Assert.Equal("SomeAction", route.RouteValues["action"]);
            Assert.Equal("TestRoute", route.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionDictionaryOverridesDefaultControllerName()
        {
            // Arrange
            TestRouteController controller = new TestRouteController();
            object values = new { controller = "SomeOtherController" };
            controller.ControllerContext = GetControllerContext("SomeAction", "TestRoute");

            // Act
            RedirectToRouteResult route = controller.RedirectToAction("SomeOtherAction", values);

            // Assert
            Assert.Equal("SomeOtherAction", route.RouteValues["action"]);
            Assert.Equal("SomeOtherController", route.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionSimpleOverridesCallLegacyMethod()
        {
            // The simple overrides need to call RedirectToAction(string, string, RouteValueDictionary) to maintain backwards compat

            // Arrange
            int invocationCount = 0;
            Mock<Controller> controllerMock = new Mock<Controller>();
            controllerMock.Setup(c => c.RedirectToAction(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<RouteValueDictionary>())).Callback(() => { invocationCount++; });

            Controller controller = controllerMock.Object;

            // Act
            controller.RedirectToAction("SomeAction");
            controller.RedirectToAction("SomeAction", (object)null);
            controller.RedirectToAction("SomeAction", (RouteValueDictionary)null);
            controller.RedirectToAction("SomeAction", "SomeController");
            controller.RedirectToAction("SomeAction", "SomeController", (object)null);

            // Assert
            Assert.Equal(5, invocationCount);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndValuesDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary(new { Foo = "SomeFoo" });

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndValuesObject()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Foo = "SomeFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", (RouteValueDictionary)null);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Single(newValues);
            Assert.Equal("SomeOtherAction", newValues["action"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionPermanent()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToActionPermanent("SomeOtherAction");

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Null(result.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionPermanentWithObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToActionPermanent("SomeOtherAction", controllerName: "SomeController", routeValues: new { foo = "bar" });

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("bar", result.RouteValues["foo"]);
            Assert.Equal("SomeController", result.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionPermanentWithRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToActionPermanent("SomeOtherAction", routeValues: new RouteValueDictionary(new { foo = "bar" }));

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("bar", result.RouteValues["foo"]);
        }

        [Fact]
        public void RedirectToRouteSimpleOverridesCallLegacyMethod()
        {
            // The simple overrides need to call RedirectToRoute(string, RouteValueDictionary) to maintain backwards compat

            // Arrange
            int invocationCount = 0;
            Mock<Controller> controllerMock = new Mock<Controller>();
            controllerMock.Setup(c => c.RedirectToRoute(It.IsAny<string>(), It.IsAny<RouteValueDictionary>())).Callback(() => { invocationCount++; });

            Controller controller = controllerMock.Object;

            // Act
            controller.RedirectToRoute("SomeRoute");
            controller.RedirectToRoute("SomeRoute", (object)null);
            controller.RedirectToRoute((object)null);
            controller.RedirectToRoute((RouteValueDictionary)null);

            // Assert
            Assert.Equal(4, invocationCount);
        }

        [Fact]
        public void RedirectToRouteWithNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute((RouteValueDictionary)null);

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            var values = new { Foo = "MyFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary() { { "Foo", "MyFoo" } };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.NotSame(values, result.RouteValues);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo");

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNameAndNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo", (RouteValueDictionary)null);

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNullNameAndNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(null, (RouteValueDictionary)null);

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.Equal(String.Empty, result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNameAndObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            var values = new { Foo = "MyFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo", values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNameAndRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary() { { "Foo", "MyFoo" } };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo", values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.NotSame(values, result.RouteValues);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRoutePermanentWithObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoutePermanent(routeValues: new { Foo = "Bar" });

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("Bar", result.RouteValues["Foo"]);
        }

        [Fact]
        public void RedirectToRoutePermanentWithRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoutePermanent(routeValues: new RouteValueDictionary(new { Foo = "Bar" }));