2050 lines
73 KiB
C#
2050 lines
73 KiB
C#
// Copyright (c) Microsoft Corporation. All rights reserved. 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.Web.UnitTestUtil;
|
|
using Moq;
|
|
using Moq.Protected;
|
|
using Xunit;
|
|
using Assert = Microsoft.TestCommon.AssertEx;
|
|
|
|
namespace System.Web.Mvc.Test
|
|
{
|
|
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'.");
|
|
}
|
|
|
|
[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" }));
|
|
|
|
// Assert
|
|
Assert.True(result.Permanent);
|
|
Assert.Equal("Bar", result.RouteValues["Foo"]);
|
|
}
|
|
|
|
[Fact]
|
|
public void RedirectReturnsCorrectActionResult()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act & Assert
|
|
var result = controller.Redirect("http://www.contoso.com/");
|
|
|
|
// Assert
|
|
Assert.Equal("http://www.contoso.com/", result.Url);
|
|
Assert.False(result.Permanent);
|
|
}
|
|
|
|
[Fact]
|
|
public void RedirectPermanentReturnsCorrectActionResult()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act & Assert
|
|
var result = controller.RedirectPermanent("http://www.contoso.com/");
|
|
|
|
// Assert
|
|
Assert.Equal("http://www.contoso.com/", result.Url);
|
|
Assert.True(result.Permanent);
|
|
}
|
|
|
|
[Fact]
|
|
public void RedirectWithEmptyUrlThrows()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNullOrEmpty(
|
|
delegate { controller.Redirect(String.Empty); },
|
|
"url");
|
|
}
|
|
|
|
[Fact]
|
|
public void RedirectPermanentWithEmptyUrlThrows()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNullOrEmpty(
|
|
delegate { controller.RedirectPermanent(String.Empty); },
|
|
"url");
|
|
}
|
|
|
|
[Fact]
|
|
public void RedirectWithNullUrlThrows()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNullOrEmpty(
|
|
delegate { controller.Redirect(url: null); },
|
|
"url");
|
|
}
|
|
|
|
[Fact]
|
|
public void RedirectPermanentWithNullUrlThrows()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNullOrEmpty(
|
|
delegate { controller.RedirectPermanent(url: null); },
|
|
"url");
|
|
}
|
|
|
|
[Fact]
|
|
public void View()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act
|
|
ViewResult result = controller.View();
|
|
|
|
// Assert
|
|
Assert.Same(controller.ViewData, result.ViewData);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
Assert.Same(ViewEngines.Engines, result.ViewEngineCollection);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_Model()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
object viewItem = new object();
|
|
|
|
// Act
|
|
ViewResult result = controller.View(viewItem);
|
|
|
|
// Assert
|
|
Assert.Same(viewItem, result.ViewData.Model);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_ViewName()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act
|
|
ViewResult result = controller.View("Foo");
|
|
|
|
// Assert
|
|
Assert.Equal("Foo", result.ViewName);
|
|
Assert.Same(controller.ViewData, result.ViewData);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_ViewName_Model()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
object viewItem = new object();
|
|
|
|
// Act
|
|
ViewResult result = controller.View("Foo", viewItem);
|
|
|
|
// Assert
|
|
Assert.Equal("Foo", result.ViewName);
|
|
Assert.Same(viewItem, result.ViewData.Model);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_ViewName_MasterViewName()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
|
|
// Act
|
|
ViewResult result = controller.View("Foo", "Bar");
|
|
|
|
// Assert
|
|
Assert.Equal("Foo", result.ViewName);
|
|
Assert.Equal("Bar", result.MasterName);
|
|
Assert.Same(controller.ViewData, result.ViewData);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_ViewName_MasterViewName_Model()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
object viewItem = new object();
|
|
|
|
// Act
|
|
ViewResult result = controller.View("Foo", "Bar", viewItem);
|
|
|
|
// Assert
|
|
Assert.Equal("Foo", result.ViewName);
|
|
Assert.Equal("Bar", result.MasterName);
|
|
Assert.Same(viewItem, result.ViewData.Model);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_View()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
IView view = new Mock<IView>().Object;
|
|
|
|
// Act
|
|
ViewResult result = controller.View(view);
|
|
|
|
// Assert
|
|
Assert.Same(result.View, view);
|
|
Assert.Same(controller.ViewData, result.ViewData);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_View_Model()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
IView view = new Mock<IView>().Object;
|
|
object model = new object();
|
|
|
|
// Act
|
|
ViewResult result = controller.View(view, model);
|
|
|
|
// Assert
|
|
Assert.Same(result.View, view);
|
|
Assert.Same(controller.ViewData, result.ViewData);
|
|
Assert.Same(controller.TempData, result.TempData);
|
|
Assert.Same(model, result.ViewData.Model);
|
|
}
|
|
|
|
[Fact]
|
|
public void View_ViewEngineCollection()
|
|
{
|
|
// Arrange
|
|
Controller controller = GetEmptyController();
|
|
ViewEngineCollection viewEngines = new ViewEngineCollection();
|
|
controller.ViewEngineCollection = viewEngines;
|
|
|
|
// Act
|
|
ViewResult result = controller.View();
|
|
|
|
// Assert
|
|
Assert.Same(viewEngines, result.ViewEngineCollection);
|
|
}
|
|
|
|
internal static void AddRequestParams(Mock<HttpRequestBase> requestMock, object paramValues)
|
|
{
|
|
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(paramValues);
|
|
foreach (PropertyDescriptor prop in props)
|
|
{
|
|
requestMock.Setup(o => o[It.Is<string>(item => String.Equals(prop.Name, item, StringComparison.OrdinalIgnoreCase))]).Returns((string)prop.GetValue(paramValues));
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void TempDataGreetUserWithNoUserIDRedirects()
|
|
{
|
|
// Arrange
|
|
TempDataHomeController tempDataHomeController = new TempDataHomeController();
|
|
|
|
// Act
|
|
RedirectToRouteResult result = tempDataHomeController.GreetUser() as RedirectToRouteResult;
|
|
RouteValueDictionary values = result.RouteValues;
|
|
|
|
// Assert
|
|
Assert.True(values.ContainsKey("action"));
|
|
Assert.Equal("ErrorPage", values["action"]);
|
|
Assert.Empty(tempDataHomeController.TempData);
|
|
}
|
|
|
|
[Fact]
|
|
public void TempDataGreetUserWithUserIDCopiesToViewDataAndRenders()
|
|
{
|
|
// Arrange
|
|
TempDataHomeController tempDataHomeController = new TempDataHomeController();
|
|
tempDataHomeController.TempData["UserID"] = "TestUserID";
|
|
|
|
// Act
|
|
ViewResult result = tempDataHomeController.GreetUser() as ViewResult;
|
|
ViewDataDictionary viewData = tempDataHomeController.ViewData;
|
|
|
|
// Assert
|
|
Assert.Equal("GreetUser", result.ViewName);
|
|
Assert.NotNull(viewData);
|
|
Assert.True(viewData.ContainsKey("NewUserID"));
|
|
Assert.Equal("TestUserID", viewData["NewUserID"]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TempDataIndexSavesUserIDAndRedirects()
|
|
{
|
|
// Arrange
|
|
TempDataHomeController tempDataHomeController = new TempDataHomeController();
|
|
|
|
// Act
|
|
RedirectToRouteResult result = tempDataHomeController.Index() as RedirectToRouteResult;
|
|
RouteValueDictionary values = result.RouteValues;
|
|
|
|
// Assert
|
|
Assert.True(values.ContainsKey("action"));
|
|
Assert.Equal("GreetUser", values["action"]);
|
|
|
|
Assert.True(tempDataHomeController.TempData.ContainsKey("UserID"));
|
|
Assert.Equal("user123", tempDataHomeController.TempData["UserID"]);
|
|
}
|
|
|
|
[Fact]
|
|
public void TempDataSavedWhenControllerThrows()
|
|
{
|
|
// Arrange
|
|
BrokenController controller = new BrokenController() { ValidateRequest = false };
|
|
Mock<HttpContextBase> mockContext = HttpContextHelpers.GetMockHttpContext();
|
|
HttpSessionStateBase session = GetEmptySession();
|
|
mockContext.Setup(o => o.Session).Returns(session);
|
|
RouteData rd = new RouteData();
|
|
rd.Values.Add("action", "Crash");
|
|
controller.ControllerContext = new ControllerContext(mockContext.Object, rd, controller);
|
|
|
|
// Assert
|
|
Assert.Throws<InvalidOperationException>(
|
|
delegate { ((IController)controller).Execute(controller.ControllerContext.RequestContext); });
|
|
Assert.NotEqual(mockContext.Object.Session[SessionStateTempDataProvider.TempDataSessionStateKey], null);
|
|
TempDataDictionary tempData = new TempDataDictionary();
|
|
tempData.Load(controller.ControllerContext, controller.TempDataProvider);
|
|
Assert.Equal(tempData["Key1"], "Value1");
|
|
}
|
|
|
|
[Fact]
|
|
public void TempDataMovedToPreviousTempDataInDestinationController()
|
|
{
|
|
// Arrange
|
|
Mock<Controller> mockController = new Mock<Controller>() { CallBase = true };
|
|
Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
|
|
HttpSessionStateBase session = GetEmptySession();
|
|
mockContext.Setup(o => o.Session).Returns(session);
|
|
mockController.Object.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), mockController.Object);
|
|
|
|
// Act
|
|
mockController.Object.TempData.Add("Key", "Value");
|
|
mockController.Object.TempData.Save(mockController.Object.ControllerContext, mockController.Object.TempDataProvider);
|
|
|
|
// Assert
|
|
Assert.True(mockController.Object.TempData.ContainsKey("Key"));
|
|
Assert.True(mockController.Object.TempData.ContainsValue("Value"));
|
|
|
|
// Instantiate "destination" controller with the same session state and see that it gets the temp data
|
|
Mock<Controller> mockDestinationController = new Mock<Controller>() { CallBase = true };
|
|
Mock<HttpContextBase> mockDestinationContext = new Mock<HttpContextBase>();
|
|
mockDestinationContext.Setup(o => o.Session).Returns(session);
|
|
mockDestinationController.Object.ControllerContext = new ControllerContext(mockDestinationContext.Object, new RouteData(), mockDestinationController.Object);
|
|
mockDestinationController.Object.TempData.Load(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);
|
|
|
|
// Assert
|
|
Assert.True(mockDestinationController.Object.TempData.ContainsKey("Key"));
|
|
|
|
// Act
|
|
mockDestinationController.Object.TempData["NewKey"] = "NewValue";
|
|
Assert.True(mockDestinationController.Object.TempData.ContainsKey("NewKey"));
|
|
mockDestinationController.Object.TempData.Save(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);
|
|
|
|
// Instantiate "second destination" controller with the same session state and see that it gets the temp data
|
|
Mock<Controller> mockSecondDestinationController = new Mock<Controller>() { CallBase = true };
|
|
Mock<HttpContextBase> mockSecondDestinationContext = new Mock<HttpContextBase>();
|
|
mockSecondDestinationContext.Setup(o => o.Session).Returns(session);
|
|
mockSecondDestinationController.Object.ControllerContext = new ControllerContext(mockSecondDestinationContext.Object, new RouteData(), mockSecondDestinationController.Object);
|
|
mockSecondDestinationController.Object.TempData.Load(mockSecondDestinationController.Object.ControllerContext, mockSecondDestinationController.Object.TempDataProvider);
|
|
|
|
// Assert
|
|
Assert.True(mockSecondDestinationController.Object.TempData.ContainsKey("Key"));
|
|
Assert.True(mockSecondDestinationController.Object.TempData.ContainsKey("NewKey"));
|
|
}
|
|
|
|
[Fact]
|
|
public void TempDataRemovesKeyWhenRead()
|
|
{
|
|
// Arrange
|
|
Mock<Controller> mockController = new Mock<Controller>() { CallBase = true };
|
|
Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
|
|
HttpSessionStateBase session = GetEmptySession();
|
|
mockContext.Setup(o => o.Session).Returns(session);
|
|
mockController.Object.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), mockController.Object);
|
|
|
|
// Act
|
|
mockController.Object.TempData.Add("Key", "Value");
|
|
mockController.Object.TempData.Save(mockController.Object.ControllerContext, mockController.Object.TempDataProvider);
|
|
|
|
// Assert
|
|
Assert.True(mockController.Object.TempData.ContainsKey("Key"));
|
|
Assert.True(mockController.Object.TempData.ContainsValue("Value"));
|
|
|
|
// Instantiate "destination" controller with the same session state and see that it gets the temp data
|
|
Mock<Controller> mockDestinationController = new Mock<Controller>() { CallBase = true };
|
|
Mock<HttpContextBase> mockDestinationContext = new Mock<HttpContextBase>();
|
|
mockDestinationContext.Setup(o => o.Session).Returns(session);
|
|
mockDestinationController.Object.ControllerContext = new ControllerContext(mockDestinationContext.Object, new RouteData(), mockDestinationController.Object);
|
|
mockDestinationController.Object.TempData.Load(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);
|
|
|
|
// Assert
|
|
Assert.True(mockDestinationController.Object.TempData.ContainsKey("Key"));
|
|
|
|
// Act
|
|
object value = mockDestinationController.Object.TempData["Key"];
|
|
mockDestinationController.Object.TempData.Save(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);
|
|
|
|
// Instantiate "second destination" controller with the same session state and see that it gets the temp data
|
|
Mock<Controller> mockSecondDestinationController = new Mock<Controller>() { CallBase = true };
|
|
Mock<HttpContextBase> mockSecondDestinationContext = new Mock<HttpContextBase>();
|
|
mockSecondDestinationContext.Setup(o => o.Session).Returns(session);
|
|
mockSecondDestinationController.Object.ControllerContext = new ControllerContext(mockSecondDestinationContext.Object, new RouteData(), mockSecondDestinationController.Object);
|
|
mockSecondDestinationController.Object.TempData.Load(mockSecondDestinationController.Object.ControllerContext, mockSecondDestinationController.Object.TempDataProvider);
|
|
|
|
// Assert
|
|
Assert.False(mockSecondDestinationController.Object.TempData.ContainsKey("Key"));
|
|
}
|
|
|
|
[Fact]
|
|
public void TempDataValidForSingleControllerWhenSessionStateDisabled()
|
|
{
|
|
// Arrange
|
|
Mock<Controller> mockController = new Mock<Controller>();
|
|
Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
|
|
HttpSessionStateBase session = null;
|
|
mockContext.Setup(o => o.Session).Returns(session);
|
|
mockController.Object.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), mockController.Object);
|
|
mockController.Object.TempData = new TempDataDictionary();
|
|
|
|
// Act
|
|
mockController.Object.TempData["Key"] = "Value";
|
|
|
|
// Assert
|
|
Assert.True(mockController.Object.TempData.ContainsKey("Key"));
|
|
}
|
|
|
|
[Fact]
|
|
public void TryUpdateModelCallsModelBinderForModel()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
IValueProvider valueProvider = new SimpleValueProvider();
|
|
|
|
Controller controller = new EmptyController();
|
|
controller.ControllerContext = GetControllerContext("someAction");
|
|
|
|
// Act
|
|
bool returned = controller.TryUpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" }, null, valueProvider);
|
|
|
|
// Assert
|
|
Assert.True(returned);
|
|
Assert.Equal(valueProvider, myModel.BindingContext.ValueProvider);
|
|
Assert.Equal("somePrefix", myModel.BindingContext.ModelName);
|
|
Assert.Equal(controller.ModelState, myModel.BindingContext.ModelState);
|
|
Assert.Equal(typeof(MyModel), myModel.BindingContext.ModelType);
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop1"));
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop2"));
|
|
Assert.False(myModel.BindingContext.PropertyFilter("prop3"));
|
|
}
|
|
|
|
[Fact]
|
|
public void TryUpdateModelReturnsFalseIfModelStateInvalid()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
|
|
Controller controller = new EmptyController();
|
|
controller.ModelState.AddModelError("key", "some exception message");
|
|
|
|
// Act
|
|
bool returned = controller.TryUpdateModel(myModel, new SimpleValueProvider());
|
|
|
|
// Assert
|
|
Assert.False(returned);
|
|
}
|
|
|
|
[Fact]
|
|
public void TryUpdateModelSuppliesControllerValueProviderIfNoValueProviderSpecified()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
IValueProvider valueProvider = new SimpleValueProvider();
|
|
|
|
Controller controller = new EmptyController();
|
|
controller.ValueProvider = valueProvider;
|
|
|
|
// Act
|
|
bool returned = controller.TryUpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" });
|
|
|
|
// Assert
|
|
Assert.True(returned);
|
|
Assert.Equal(valueProvider, myModel.BindingContext.ValueProvider);
|
|
}
|
|
|
|
[Fact]
|
|
public void TryUpdateModelSuppliesEmptyModelNameIfNoPrefixSpecified()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
bool returned = controller.TryUpdateModel(myModel, new[] { "prop1", "prop2" }, new SimpleValueProvider());
|
|
|
|
// Assert
|
|
Assert.True(returned);
|
|
Assert.Equal(String.Empty, myModel.BindingContext.ModelName);
|
|
}
|
|
|
|
[Fact]
|
|
public void TryUpdateModelThrowsIfModelIsNull()
|
|
{
|
|
// Arrange
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNull(
|
|
delegate { controller.TryUpdateModel<object>(null, new SimpleValueProvider()); }, "model");
|
|
}
|
|
|
|
[Fact]
|
|
public void TryUpdateModelThrowsIfValueProviderIsNull()
|
|
{
|
|
// Arrange
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNull(
|
|
delegate { controller.TryUpdateModel(new object(), null, null, null, null); }, "valueProvider");
|
|
}
|
|
|
|
[Fact]
|
|
public void UpdateModelReturnsIfModelStateValid()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
controller.UpdateModel(myModel, new SimpleValueProvider());
|
|
|
|
// Assert
|
|
// nothing to do - if we got here, the test passed
|
|
}
|
|
|
|
[Fact]
|
|
public void TryUpdateModelWithoutBindPropertiesImpliesAllPropertiesAreUpdateable()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
bool returned = controller.TryUpdateModel(myModel, "somePrefix", new SimpleValueProvider());
|
|
|
|
// Assert
|
|
Assert.True(returned);
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop1"));
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop2"));
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop3"));
|
|
}
|
|
|
|
[Fact]
|
|
public void UpdateModelSuppliesControllerValueProviderIfNoValueProviderSpecified()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
IValueProvider valueProvider = new SimpleValueProvider();
|
|
|
|
Controller controller = new EmptyController() { ValueProvider = valueProvider };
|
|
|
|
// Act
|
|
controller.UpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" });
|
|
|
|
// Assert
|
|
Assert.Equal(valueProvider, myModel.BindingContext.ValueProvider);
|
|
}
|
|
|
|
[Fact]
|
|
public void UpdateModelThrowsIfModelStateInvalid()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
|
|
Controller controller = new EmptyController();
|
|
controller.ModelState.AddModelError("key", "some exception message");
|
|
|
|
// Act & assert
|
|
Assert.Throws<InvalidOperationException>(
|
|
delegate { controller.UpdateModel(myModel, new SimpleValueProvider()); },
|
|
"The model of type 'System.Web.Mvc.Test.ControllerTest+MyModel' could not be updated.");
|
|
}
|
|
|
|
[Fact]
|
|
public void UpdateModelWithoutBindPropertiesImpliesAllPropertiesAreUpdateable()
|
|
{
|
|
// Arrange
|
|
MyModel myModel = new MyModelSubclassed();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
controller.UpdateModel(myModel, "somePrefix", new SimpleValueProvider());
|
|
|
|
// Assert
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop1"));
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop2"));
|
|
Assert.True(myModel.BindingContext.PropertyFilter("prop3"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Json()
|
|
{
|
|
// Arrange
|
|
MyModel model = new MyModel();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
JsonResult result = controller.Json(model);
|
|
|
|
// Assert
|
|
Assert.Same(model, result.Data);
|
|
Assert.Null(result.ContentType);
|
|
Assert.Null(result.ContentEncoding);
|
|
Assert.Equal(JsonRequestBehavior.DenyGet, result.JsonRequestBehavior);
|
|
}
|
|
|
|
[Fact]
|
|
public void JsonWithContentType()
|
|
{
|
|
// Arrange
|
|
MyModel model = new MyModel();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
JsonResult result = controller.Json(model, "text/xml");
|
|
|
|
// Assert
|
|
Assert.Same(model, result.Data);
|
|
Assert.Equal("text/xml", result.ContentType);
|
|
Assert.Null(result.ContentEncoding);
|
|
Assert.Equal(JsonRequestBehavior.DenyGet, result.JsonRequestBehavior);
|
|
}
|
|
|
|
[Fact]
|
|
public void JsonWithContentTypeAndEncoding()
|
|
{
|
|
// Arrange
|
|
MyModel model = new MyModel();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
JsonResult result = controller.Json(model, "text/xml", Encoding.UTF32);
|
|
|
|
// Assert
|
|
Assert.Same(model, result.Data);
|
|
Assert.Equal("text/xml", result.ContentType);
|
|
Assert.Equal(Encoding.UTF32, result.ContentEncoding);
|
|
Assert.Equal(JsonRequestBehavior.DenyGet, result.JsonRequestBehavior);
|
|
}
|
|
|
|
[Fact]
|
|
public void JsonWithBehavior()
|
|
{
|
|
// Arrange
|
|
MyModel model = new MyModel();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
JsonResult result = controller.Json(model, JsonRequestBehavior.AllowGet);
|
|
|
|
// Assert
|
|
Assert.Same(model, result.Data);
|
|
Assert.Null(result.ContentType);
|
|
Assert.Null(result.ContentEncoding);
|
|
Assert.Equal(JsonRequestBehavior.AllowGet, result.JsonRequestBehavior);
|
|
}
|
|
|
|
[Fact]
|
|
public void JsonWithContentTypeAndBehavior()
|
|
{
|
|
// Arrange
|
|
MyModel model = new MyModel();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
JsonResult result = controller.Json(model, "text/xml", JsonRequestBehavior.AllowGet);
|
|
|
|
// Assert
|
|
Assert.Same(model, result.Data);
|
|
Assert.Equal("text/xml", result.ContentType);
|
|
Assert.Null(result.ContentEncoding);
|
|
Assert.Equal(JsonRequestBehavior.AllowGet, result.JsonRequestBehavior);
|
|
}
|
|
|
|
[Fact]
|
|
public void JsonWithContentTypeAndEncodingAndBehavior()
|
|
{
|
|
// Arrange
|
|
MyModel model = new MyModel();
|
|
Controller controller = new EmptyController();
|
|
|
|
// Act
|
|
JsonResult result = controller.Json(model, "text/xml", Encoding.UTF32, JsonRequestBehavior.AllowGet);
|
|
|
|
// Assert
|
|
Assert.Same(model, result.Data);
|
|
Assert.Equal("text/xml", result.ContentType);
|
|
Assert.Equal(Encoding.UTF32, result.ContentEncoding);
|
|
Assert.Equal(JsonRequestBehavior.AllowGet, result.JsonRequestBehavior);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExecuteDoesNotCallTempDataLoadOrSave()
|
|
{
|
|
// Arrange
|
|
TempDataDictionary tempData = new TempDataDictionary();
|
|
ViewContext viewContext = new ViewContext { TempData = tempData };
|
|
RouteData routeData = new RouteData();
|
|
routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = viewContext;
|
|
routeData.Values["action"] = "SimpleAction";
|
|
RequestContext requestContext = new RequestContext(HttpContextHelpers.GetMockHttpContext().Object, routeData);
|
|
// Strict == no default implementations == calls to Load & Save are not allowed
|
|
Mock<ITempDataProvider> tempDataProvider = new Mock<ITempDataProvider>(MockBehavior.Strict);
|
|
SimpleController controller = new SimpleController();
|
|
controller.ValidateRequest = false;
|
|
|
|
// Act
|
|
((IController)controller).Execute(requestContext);
|
|
|
|
// Assert
|
|
tempDataProvider.Verify();
|
|
}
|
|
|
|
// Model validation
|
|
|
|
[Fact]
|
|
public void TryValidateModelGuardClauses()
|
|
{
|
|
// Arrange
|
|
Controller controller = new SimpleController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNull(
|
|
() => controller.TryValidateModel(null),
|
|
"model");
|
|
}
|
|
|
|
[Fact]
|
|
public void TryValidateModelWithValidModel()
|
|
{
|
|
// Arrange
|
|
Controller controller = new SimpleController();
|
|
TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 15 };
|
|
|
|
// Act
|
|
bool result = controller.TryValidateModel(model);
|
|
|
|
// Assert
|
|
Assert.True(result);
|
|
Assert.True(controller.ModelState.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void TryValidateModelWithInvalidModel()
|
|
{
|
|
// Arrange
|
|
Controller controller = new SimpleController();
|
|
TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 5 };
|
|
|
|
// Act
|
|
bool result = controller.TryValidateModel(model, "Prefix");
|
|
|
|
// Assert
|
|
Assert.False(result);
|
|
Assert.Equal("Out of range!", controller.ModelState["Prefix.IntegerProperty"].Errors[0].ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidateModelGuardClauses()
|
|
{
|
|
// Arrange
|
|
Controller controller = new SimpleController();
|
|
|
|
// Act & Assert
|
|
Assert.ThrowsArgumentNull(
|
|
() => controller.ValidateModel(null),
|
|
"model");
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidateModelWithValidModel()
|
|
{
|
|
// Arrange
|
|
Controller controller = new SimpleController();
|
|
TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 15 };
|
|
|
|
// Act
|
|
controller.ValidateModel(model);
|
|
|
|
// Assert
|
|
Assert.True(controller.ModelState.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidateModelWithInvalidModel()
|
|
{
|
|
// Arrange
|
|
Controller controller = new SimpleController();
|
|
TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 5 };
|
|
|
|
// Act & Assert
|
|
Assert.Throws<InvalidOperationException>(
|
|
() => controller.ValidateModel(model, "Prefix"),
|
|
"The model of type '" + model.GetType().FullName + "' is not valid.");
|
|
|
|
Assert.Equal("Out of range!", controller.ModelState["Prefix.IntegerProperty"].Errors[0].ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public void ValidateControllerUsesCachedResolver()
|
|
{
|
|
var controller = new EmptyController();
|
|
|
|
var resolver = controller.Resolver;
|
|
|
|
Assert.Equal(DependencyResolver.CurrentCache.GetType(), resolver.GetType());
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public void CreateActionInvokerCallsIntoResolverInstance()
|
|
{
|
|
// Controller uses an IDependencyResolver to create an IActionInvoker.
|
|
var controller = new EmptyController();
|
|
Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
|
|
Mock<IAsyncActionInvoker> actionInvokerMock = new Mock<IAsyncActionInvoker>();
|
|
resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvoker))).Returns(actionInvokerMock.Object);
|
|
controller.Resolver = resolverMock.Object;
|
|
|
|
var ai = controller.CreateActionInvoker();
|
|
|
|
resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvoker)), Times.Once());
|
|
Assert.Same(actionInvokerMock.Object, ai);
|
|
}
|
|
|
|
[Fact]
|
|
public void CreateActionInvokerCallsIntoResolverInstanceAndCreatesANewOneIfNecessary()
|
|
{
|
|
// If IDependencyResolver is set, but empty, falls back and still creates.
|
|
var controller = new EmptyController();
|
|
Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
|
|
resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvoker))).Returns(null);
|
|
controller.Resolver = resolverMock.Object;
|
|
|
|
IActionInvoker ai = controller.CreateActionInvoker();
|
|
|
|
resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvoker)), Times.Once());
|
|
Assert.NotNull(ai);
|
|
}
|
|
|
|
[Fact]
|
|
public void CreateTempProviderWithResolver()
|
|
{
|
|
// Controller uses an IDependencyResolver to create an IActionInvoker.
|
|
var controller = new EmptyController();
|
|
Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
|
|
Mock<ITempDataProvider> tempMock = new Mock<ITempDataProvider>();
|
|
resolverMock.Setup(r => r.GetService(typeof(ITempDataProvider))).Returns(tempMock.Object);
|
|
controller.Resolver = resolverMock.Object;
|
|
|
|
ITempDataProvider temp = controller.CreateTempDataProvider();
|
|
|
|
resolverMock.Verify(r => r.GetService(typeof(ITempDataProvider)), Times.Once());
|
|
Assert.Same(tempMock.Object, temp);
|
|
}
|
|
|
|
private class TryValidateModelModel
|
|
{
|
|
[Range(10, 20, ErrorMessage = "Out of range!")]
|
|
public int IntegerProperty { get; set; }
|
|
}
|
|
|
|
// Helpers
|
|
|
|
private class SimpleController : Controller
|
|
{
|
|
public SimpleController()
|
|
{
|
|
ControllerContext = new ControllerContext { Controller = this };
|
|
}
|
|
|
|
public void SimpleAction()
|
|
{
|
|
}
|
|
}
|
|
|
|
private static ControllerContext GetControllerContext(string actionName)
|
|
{
|
|
RouteData rd = new RouteData();
|
|
rd.Values["action"] = actionName;
|
|
|
|
Mock<HttpContextBase> mockHttpContext = HttpContextHelpers.GetMockHttpContext();
|
|
mockHttpContext.Setup(c => c.Session).Returns((HttpSessionStateBase)null);
|
|
|
|
return new ControllerContext(mockHttpContext.Object, rd, new Mock<Controller>().Object);
|
|
}
|
|
|
|
private static ControllerContext GetControllerContext(string actionName, string controllerName)
|
|
{
|
|
RouteData rd = new RouteData();
|
|
rd.Values["action"] = actionName;
|
|
rd.Values["controller"] = controllerName;
|
|
|
|
Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
|
|
mockHttpContext.Setup(c => c.Session).Returns((HttpSessionStateBase)null);
|
|
|
|
return new ControllerContext(mockHttpContext.Object, rd, new Mock<Controller>().Object);
|
|
}
|
|
|
|
private static Controller GetEmptyController()
|
|
{
|
|
ControllerContext context = GetControllerContext("Foo");
|
|
var controller = new EmptyController()
|
|
{
|
|
ControllerContext = context,
|
|
RouteCollection = new RouteCollection(),
|
|
TempData = new TempDataDictionary(),
|
|
TempDataProvider = new SessionStateTempDataProvider()
|
|
};
|
|
return controller;
|
|
}
|
|
|
|
private static HttpSessionStateBase GetEmptySession()
|
|
{
|
|
HttpSessionStateMock mockSession = new HttpSessionStateMock();
|
|
return mockSession;
|
|
}
|
|
|
|
private sealed class HttpSessionStateMock : HttpSessionStateBase
|
|
{
|
|
private Hashtable _sessionData = new Hashtable(StringComparer.OrdinalIgnoreCase);
|
|
|
|
public override void Remove(string name)
|
|
{
|
|
Assert.Equal<string>(SessionStateTempDataProvider.TempDataSessionStateKey, name);
|
|
_sessionData.Remove(name);
|
|
}
|
|
|
|
public override object this[string name]
|
|
{
|
|
get
|
|
{
|
|
Assert.Equal<string>(SessionStateTempDataProvider.TempDataSessionStateKey, name);
|
|
return _sessionData[name];
|
|
}
|
|
set
|
|
{
|
|
Assert.Equal<string>(SessionStateTempDataProvider.TempDataSessionStateKey, name);
|
|
_sessionData[name] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Person
|
|
{
|
|
public string Name { get; set; }
|
|
public int Age { get; set; }
|
|
}
|
|
|
|
private class EmptyController : Controller
|
|
{
|
|
public new void HandleUnknownAction(string actionName)
|
|
{
|
|
base.HandleUnknownAction(actionName);
|
|
}
|
|
|
|
public void PublicInitialize(RequestContext requestContext)
|
|
{
|
|
base.Initialize(requestContext);
|
|
}
|
|
|
|
// Test can expose protected method as public.
|
|
public new IActionInvoker CreateActionInvoker()
|
|
{
|
|
return base.CreateActionInvoker();
|
|
}
|
|
|
|
public new ITempDataProvider CreateTempDataProvider()
|
|
{
|
|
return base.CreateTempDataProvider();
|
|
}
|
|
}
|
|
|
|
|
|
private sealed class UnknownActionController : Controller
|
|
{
|
|
public bool WasCalled;
|
|
|
|
protected override void HandleUnknownAction(string actionName)
|
|
{
|
|
WasCalled = true;
|
|
}
|
|
}
|
|
|
|
private sealed class TempDataHomeController : Controller
|
|
{
|
|
public ActionResult Index()
|
|
{
|
|
// Save UserID into TempData and redirect to greeting page
|
|
TempData["UserID"] = "user123";
|
|
return RedirectToAction("GreetUser");
|
|
}
|
|
|
|
public ActionResult GreetUser()
|
|
{
|
|
// Check that the UserID is present. If it's not
|
|
// there, redirect to error page. If it is, show
|
|
// the greet user view.
|
|
if (!TempData.ContainsKey("UserID"))
|
|
{
|
|
return RedirectToAction("ErrorPage");
|
|
}
|
|
ViewData["NewUserID"] = TempData["UserID"];
|
|
return View("GreetUser");
|
|
}
|
|
}
|
|
|
|
public class BrokenController : Controller
|
|
{
|
|
public BrokenController()
|
|
{
|
|
ActionInvoker = new ControllerActionInvoker()
|
|
{
|
|
DescriptorCache = new ControllerDescriptorCache()
|
|
};
|
|
}
|
|
|
|
public ActionResult Crash()
|
|
{
|
|
TempData["Key1"] = "Value1";
|
|
throw new InvalidOperationException("Crashing....");
|
|
}
|
|
}
|
|
|
|
private sealed class TestRouteController : Controller
|
|
{
|
|
public ActionResult Index()
|
|
{
|
|
return RedirectToAction("SomeAction");
|
|
}
|
|
}
|
|
|
|
[ModelBinder(typeof(MyModelBinder))]
|
|
private class MyModel
|
|
{
|
|
public ControllerContext ControllerContext;
|
|
public ModelBindingContext BindingContext;
|
|
}
|
|
|
|
private class MyModelSubclassed : MyModel
|
|
{
|
|
}
|
|
|
|
private class MyModelBinder : IModelBinder
|
|
{
|
|
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
|
|
{
|
|
MyModel myModel = (MyModel)bindingContext.Model;
|
|
myModel.ControllerContext = controllerContext;
|
|
myModel.BindingContext = bindingContext;
|
|
return myModel;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class EmptyTempDataProvider : ITempDataProvider
|
|
{
|
|
public void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
|
|
{
|
|
}
|
|
|
|
public IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
|
|
{
|
|
return new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
|
|
}
|
|
}
|
|
}
|