public void AttributeRouting_OptionalParametersGetRemoved()
{
// Arrange
var controllerTypes = new[] { typeof(OptionalParameterController) };
var routes = new RouteCollection();
routes.MapMvcAttributeRoutes(controllerTypes);
HttpContextBase context = GetContext("~/Create");
RouteData routeData = routes.GetRouteData(context);
RequestContext requestContext = new RequestContext(context, routeData);
MvcHandler handler = new MvcHandler(requestContext);
handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));
// Act
handler.ProcessRequest(context);
// Assert
ContentResult result = Assert.IsType <ContentResult>(context.Items[ResultKey]);
Assert.Equal("Create()", result.Content);
// The request context should be updated to to contain the routedata of the direct route
Assert.Equal("{action}/{id}", ((Route)requestContext.RouteData.Route).Url);
Assert.Null(requestContext.RouteData.Values["id"]);
}
public void ProcessRequestDisposesControllerIfExecuteDoesNotThrowException()
{
// Arrange
Mock <ControllerBase> mockController = new Mock <ControllerBase>();
mockController.Protected().Expect("Execute", ItExpr.IsAny <RequestContext>()).Verifiable();
mockController.As <IDisposable>().Expect(d => d.Dispose()).AtMostOnce().Verifiable();
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
Mock <HttpContextBase> contextMock = new Mock <HttpContextBase>();
Mock <HttpResponseBase> responseMock = new Mock <HttpResponseBase>();
responseMock.Expect(r => r.AppendHeader(MvcHandler.MvcVersionHeaderName, "1.0")).Verifiable();
contextMock.Expect(c => c.Response).Returns(responseMock.Object);
RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
requestContext.RouteData.Values["controller"] = "fooController";
MvcHandler handler = new MvcHandler(requestContext)
{
ControllerBuilder = builder
};
// Act
handler.ProcessRequest(requestContext.HttpContext);
// Assert
mockController.Verify();
responseMock.Verify();
}
public void ProcessRequestDisposesControllerIfExecuteThrowsException()
{
// Arrange
Mock <ControllerBase> mockController = new Mock <ControllerBase>(MockBehavior.Strict);
mockController.As <IDisposable>().Setup(d => d.Dispose()); // so that Verify can be called on Dispose later
mockController.Protected().Setup("Execute", ItExpr.IsAny <RequestContext>()).Throws(new Exception("some exception"));
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
Mock <HttpContextBase> contextMock = new Mock <HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader().Verifiable();
RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
requestContext.RouteData.Values["controller"] = "fooController";
MvcHandler handler = new MvcHandler(requestContext)
{
ControllerBuilder = builder
};
// Act
Assert.Throws <Exception>(
delegate { handler.ProcessRequest(requestContext.HttpContext); },
"some exception");
// Assert
mockController.Verify();
contextMock.Verify();
mockController.As <IDisposable>().Verify(d => d.Dispose(), Times.AtMostOnce());
}
public void ProcessRequestRemovesOptionalParametersFromRouteValueDictionary()
{
// Arrange
Mock <HttpContextBase> contextMock = new Mock <HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
rd.Values.Add("optional", UrlParameter.Optional);
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock <ControllerBase> controllerMock = new Mock <ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock <IControllerFactory> controllerFactoryMock = new Mock <IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
controllerMock.Verify();
Assert.False(rd.Values.ContainsKey("optional"));
}
public void AttributeRouting_MethodOverloads_WithDifferentActionNames(
Type controllerType,
string path,
string expectedAction
)
{
// Arrange
var controllerTypes = new[] { controllerType };
var routes = new RouteCollection();
AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);
HttpContextBase context = GetContext(path);
RouteData routeData = routes.GetRouteData(context);
RequestContext requestContext = new RequestContext(context, routeData);
MvcHandler handler = new MvcHandler(requestContext);
handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));
// Act
handler.ProcessRequest(context);
// Assert
ContentResult result = Assert.IsType <ContentResult>(context.Items[ResultKey]);
Assert.Equal(expectedAction, result.Content);
}
public void ProcessRequestAsync_AsyncController_DisposesControllerOnException()
{
// Arrange
Mock <IAsyncController> mockController = new Mock <IAsyncController>();
mockController
.Setup(
o =>
o.BeginExecute(
It.IsAny <RequestContext>(),
It.IsAny <AsyncCallback>(),
It.IsAny <object>()
)
)
.Throws(new Exception("Some exception text."));
mockController.As <IDisposable>().Setup(o => o.Dispose()).Verifiable();
MvcHandler handler = GetMvcHandler(mockController.Object);
// Act & assert
Assert.Throws <Exception>(
delegate
{
handler.BeginProcessRequest(handler.RequestContext.HttpContext, null, null);
},
@"Some exception text."
);
mockController.Verify();
}
public void ProcessRequestWithDisabledServerHeaderOnlyCallsExecute()
{
bool oldResponseHeaderValue = MvcHandler.DisableMvcResponseHeader;
try {
// Arrange
MvcHandler.DisableMvcResponseHeader = true;
Mock <HttpContextBase> contextMock = new Mock <HttpContextBase>();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock <ControllerBase> controllerMock = new Mock <ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock <IControllerFactory> controllerFactoryMock = new Mock <IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
controllerMock.Verify();
}
finally {
MvcHandler.DisableMvcResponseHeader = oldResponseHeaderValue;
}
}
private static HtmlHelper GetHtmlHelper(out Func <RequestContext> requestContextAccessor)
{
RequestContext requestContext = null;
HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary(), "/");
html.RouteCollection.MapRoute(null, "{*dummy}");
Mock.Get(html.ViewContext.HttpContext)
.Setup(
o =>
o.Server.Execute(
It.IsAny <IHttpHandler>(),
It.IsAny <TextWriter>(),
It.IsAny <bool>()
)
)
.Callback <IHttpHandler, TextWriter, bool>(
(_h, _w, _pf) =>
{
MvcHandler mvcHandler =
_h.GetType()
.GetProperty(
"InnerHandler",
BindingFlags.Instance | BindingFlags.NonPublic
)
.GetValue(_h, null) as MvcHandler;
requestContext = mvcHandler.RequestContext;
}
);
requestContextAccessor = () => requestContext;
return(html);
}
public void AttributeRouting_MixedWithGeneralRouting(Type controllerType, string path, string expectedAction)
{
// Arrange
var controllerTypes = new[] { controllerType };
var routes = new RouteCollection();
object defaults = new { controller = controllerType.Name.Substring(0, controllerType.Name.Length - 10) };
routes.Add(new Route("standard/{action}", new RouteValueDictionary(defaults), null));
routes.MapMvcAttributeRoutes(controllerTypes);
HttpContextBase context = GetContext(path);
RouteData routeData = routes.GetRouteData(context);
RequestContext requestContext = new RequestContext(context, routeData);
MvcHandler handler = new MvcHandler(requestContext);
handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));
if (expectedAction == null)
{
// Act & Assert
Assert.Throws <HttpException>(() => handler.ProcessRequest(context));
}
else
{
// Act
handler.ProcessRequest(context);
// Assert
ContentResult result = Assert.IsType <ContentResult>(context.Items[ResultKey]);
Assert.Equal(expectedAction, result.Content);
}
}
public void AttributeRouting_WithCustomizedRoutePrefixAttribute(string path, string expectedAction)
{
// Arrange
var controllerTypes = new[]
{
typeof(ControllersWithCustomizedRoutePrefixAttribute.NS1.HomeController),
typeof(ControllersWithCustomizedRoutePrefixAttribute.NS2.AccountController),
typeof(ControllersWithCustomizedRoutePrefixAttribute.NS3.OtherController),
};
var routes = new RouteCollection();
AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);
HttpContextBase context = GetContext(path);
RouteData routeData = routes.GetRouteData(context);
RequestContext requestContext = new RequestContext(context, routeData);
MvcHandler handler = new MvcHandler(requestContext);
handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));
// Act
handler.ProcessRequest(context);
// Assert
ContentResult result = Assert.IsType <ContentResult>(context.Items[ResultKey]);
Assert.Equal(expectedAction, result.Content);
}
public void ProcessRequestAddsServerHeaderCallsExecute()
{
// Arrange
Mock <HttpContextBase> contextMock = new Mock <HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader().Verifiable();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock <ControllerBase> controllerMock = new Mock <ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock <IControllerFactory> controllerFactoryMock = new Mock <IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
contextMock.Verify();
controllerMock.Verify();
}
public void AttributeRouting_WithActionNameSelectors(Type controllerType, string path, string expectedAction)
{
// Arrange
var controllerTypes = new[] { controllerType };
var routes = new RouteCollection();
routes.MapMvcAttributeRoutes(controllerTypes);
HttpContextBase context = GetContext(path);
RouteData routeData = routes.GetRouteData(context);
RequestContext requestContext = new RequestContext(context, routeData);
MvcHandler handler = new MvcHandler(requestContext);
handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));
if (expectedAction == null)
{
// Act & Assert
Assert.Throws <HttpException>(() => handler.ProcessRequest(context));
}
else
{
// Act
handler.ProcessRequest(context);
// Assert
ContentResult result = Assert.IsType <ContentResult>(context.Items[ResultKey]);
Assert.Equal(expectedAction, result.Content);
}
}
public void ProcessRequestRemovesOptionalParametersFromRouteValueDictionary()
{
// Arrange
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
rd.Values.Add("optional", UrlParameter.Optional);
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
controllerMock.Verify();
Assert.False(rd.Values.ContainsKey("optional"));
}
public void Configuration(IAppBuilder app)
{
app.UseErrorPage();
var serviceProvider = MvcServices.Create();
string appRoot = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
var fileSystem = new PhysicalFileSystem(appRoot);
serviceProvider.AddInstance <IFileSystem>(new VirtualFileSystem(fileSystem));
serviceProvider.AddInstance <ICompilationService>(new RazorCompilationService(new CscBasedCompilationService()));
serviceProvider.Add <IVirtualPathViewFactory, VirtualPathViewFactory>();
serviceProvider.Add <IViewEngine, RazorViewEngine>();
var handler = new MvcHandler(serviceProvider);
app.Run(async context =>
{
// Pretending to be routing
var routeData = new FakeRouteData(context);
await handler.ExecuteAsync(context, routeData);
});
}
internal void SetSessionStateMode(HttpContextBase context, IDynamicSessionStateConfigurator configurator)
{
MvcHandler mvcHandler = context.Handler as MvcHandler;
if (mvcHandler == null)
{
// Either MvcHttpHandler was called directly, Routing hasn't run, or Routing has run
// and the chosen handler isn't MVC. There's nothing we can do here.
return;
}
// Check to see that our factory is installed, otherwise the controller factory might be asked to
// create two instances of the controller for every request, which could lead to resource or
// scalability issues.
RequestContext requestContext = mvcHandler.RequestContext;
MvcDynamicSessionControllerFactory factory = ControllerBuilder.GetControllerFactory() as MvcDynamicSessionControllerFactory;
if (factory == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture,
MvcResources.MvcDynamicSessionModule_WrongControllerFactory, typeof(MvcDynamicSessionControllerFactory)));
}
context.Items[_controllerFactoryItemKey] = factory; // save a reference to this factory so that we can dispose of the cached controller
string controllerName = requestContext.RouteData.GetRequiredString("controller");
IController controller = factory.CreateCachedController(requestContext, controllerName);
ControllerSessionState sessionStateMode = GetSessionStateMode(controller);
configurator.ConfigureSessionState(sessionStateMode);
}
public void ProcessRequestAddsServerHeaderCallsExecute()
{
// Arrange
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader().Verifiable();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
contextMock.Verify();
controllerMock.Verify();
}
/// <summary>
/// Executes controller based on route data.
/// </summary>
/// <param name="context"></param>
/// <param name="routeData"></param>
/// <returns></returns>
private async Task ExecuteController(HttpContext context, RouteData routeData)
{
var wrapper = new HttpContextWrapper(context);
MvcHandler handler = new MvcHandler(new RequestContext(wrapper, routeData));
IHttpAsyncHandler asyncHandler = ((IHttpAsyncHandler)handler);
await Task.Factory.FromAsync(asyncHandler.BeginProcessRequest, asyncHandler.EndProcessRequest, context, null);
}
private void CacheRightsForNode(MvcSiteMapNode mvcNode, MvcHandler handler, string permissionCacheKey)
{
lock (this.padlock)
{
// double check
if (!permissionCache.ContainsKey(permissionCacheKey))
{
// check permission attributes and store required rights in the permission cache.
// It's an MvcSiteMapNode, try to figure out the controller class
IController controller = ControllerBuilder.Current.GetControllerFactory().CreateController(handler.RequestContext, mvcNode.Controller);
Type controllerType = controller.GetType();
// Find all AuthorizeAttributes on the controller class and action method
ArrayList controllerAttributes = new ArrayList(controllerType.GetCustomAttributes(typeof(PermissionFilterAttribute), true));
ArrayList actionAttributes = new ArrayList();
MethodInfo[] methods = controllerType.GetType().GetMethods(BindingFlags.Public);
foreach (MethodInfo method in methods)
{
object[] attributes = method.GetCustomAttributes(typeof(ActionNameAttribute), true);
if (
(attributes.Length == 0 && method.Name == mvcNode.Action) ||
(attributes.Length > 0 && ((ActionNameAttribute)attributes[0]).Name == mvcNode.Action)
)
{
actionAttributes.AddRange(method.GetCustomAttributes(typeof(PermissionFilterAttribute), true));
}
}
ICollection <string> rights = new List <string>();
// Attributes found?
if (controllerAttributes.Count > 0)
{
PermissionFilterAttribute attribute = controllerAttributes[0] as PermissionFilterAttribute;
foreach (string right in attribute.RightsArray)
{
if (!rights.Contains(right))
{
rights.Add(right);
}
}
}
if (actionAttributes.Count > 0)
{
PermissionFilterAttribute attribute = actionAttributes[0] as PermissionFilterAttribute;
foreach (string right in attribute.RightsArray)
{
if (!rights.Contains(right))
{
rights.Add(right);
}
}
}
permissionCache.Add(permissionCacheKey, rights.ToArray());
}
}
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
var routeData = requestContext.RouteData;
var action = routeData.Values["action"].ToString();
routeData.Values["action"] = action.Replace("-", "_");
var handler = new MvcHandler(requestContext);
return(handler);
}
public static void CurrentRoute(out string controller, out string action, out string area, out string routeName)
{
MvcHandler handler = MvcSiteMap.Handler;
if (handler != null)
{
CurrentRoute(handler.RequestContext, out controller, out action, out area, out routeName);
return;
}
controller = action = area = routeName = null;
}
public void Invoke(ControllerContext context)
{
RouteData rd = new RouteData(context.RouteData.Route, context.RouteData.RouteHandler);
foreach (var pair in RouteValues)
{
rd.Values.Add(pair.Key, pair.Value);
}
IHttpHandler handler = new MvcHandler(new RequestContext(context.HttpContext, rd));
handler.ProcessRequest(System.Web.HttpContext.Current);
}
public override void ProcessRequest(HttpContext context)
{
var contextWrapper = new HttpContextWrapper(HttpContext.Current);
var routeData = new RouteData();
routeData.Values.Add("controller", "Home");
routeData.Values.Add("action", "Index");
routeData.Values.Add("language", Localization.DefaultLanguage);
var requestContext = new RequestContext(contextWrapper, routeData);
var handler = new MvcHandler(requestContext) as IHttpHandler;
handler.ProcessRequest(context);
}
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
if (Thread.CurrentPrincipal.Identity.IsAuthenticated)
{
MvcHandler handler = httpContext.Handler as MvcHandler;
Route route = handler.RequestContext.RouteData.Route as Route;
if (route.Url.StartsWith("Admin"))
{
return(WebSecurity.IsInRole("Administrators"));
}
}
return(base.AuthorizeCore(httpContext));
}
public void RouteDataTokensIncludesParentActionViewContext()
{
// Arrange
MvcHandler mvcHandler = null;
httpContext.Setup(hc => hc.Server.Execute(It.IsAny <IHttpHandler>(), It.IsAny <TextWriter>(), It.IsAny <bool>()))
.Callback <IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);
// Act
ChildActionExtensions.ActionHelper(htmlHelper.Object, "actionName", null /* controllerName */, null /* routeValues */, null /* textWriter */);
// Assert
Assert.Same(viewContext, mvcHandler.RequestContext.RouteData.DataTokens[ControllerContext.ParentActionViewContextToken]);
}
public void PassedRouteValuesOverrideParentRequestRouteValues()
{
// Arrange
_originalRouteData.Values["name1"] = "value1";
_originalRouteData.Values["name2"] = "value2";
MvcHandler mvcHandler = null;
_httpContext
.Setup(
hc =>
hc.Server.Execute(
It.IsAny <IHttpHandler>(),
It.IsAny <TextWriter>(),
It.IsAny <bool>()
)
)
.Callback <IHttpHandler, TextWriter, bool>(
(handler, _, __) =>
mvcHandler = (MvcHandler)(
(HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler
).InnerHandler
);
// Act
ChildActionExtensions.ActionHelper(
_htmlHelper.Object,
"actionName",
null /* controllerName */
,
new RouteValueDictionary {
{ "name2", "newValue2" }
},
null /* textWriter */
);
// Assert
RouteData routeData = mvcHandler.RequestContext.RouteData;
Assert.Equal("value1", routeData.Values["name1"]);
Assert.Equal("newValue2", routeData.Values["name2"]);
Assert.Equal(
"newValue2",
(
routeData.Values[ChildActionValueProvider.ChildActionValuesKey]
as DictionaryValueProvider <object>
).GetValue("name2").RawValue
);
}
public void GetHttpHandlerReturnsMvcHandlerWithRouteData()
{
// Arrange
RequestContext context = new RequestContext(new Mock <HttpContextBase>().Object, new RouteData());
IRouteHandler rh = new MvcRouteHandler();
// Act
IHttpHandler httpHandler = rh.GetHttpHandler(context);
// Assert
MvcHandler h = httpHandler as MvcHandler;
Assert.IsNotNull(h, "The handler should be a valid MvcHandler instance");
Assert.AreEqual <RequestContext>(context, h.RequestContext);
}
private static RequestContext GetRequestContext()
{
Mock <HttpContextBase> mockHttpContext = new Mock <HttpContextBase>();
RouteData routeData = new RouteData();
routeData.Values["controller"] = "home";
RequestContext requestContext = new RequestContext(mockHttpContext.Object, routeData);
IHttpHandler currentHttpHandler = new MvcHandler(requestContext);
mockHttpContext.Expect(o => o.Handler).Returns(currentHttpHandler);
mockHttpContext.Expect(o => o.Items).Returns(new Hashtable());
return(requestContext);
}
public void NoChildActionValuesDictionaryCreatedIfNoRouteValuesPassed()
{
// Arrange
MvcHandler mvcHandler = null;
httpContext.Setup(hc => hc.Server.Execute(It.IsAny <IHttpHandler>(), It.IsAny <TextWriter>(), It.IsAny <bool>()))
.Callback <IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);
// Act
ChildActionExtensions.ActionHelper(htmlHelper.Object, "actionName", null /* controllerName */, null, null /* textWriter */);
// Assert
RouteData routeData = mvcHandler.RequestContext.RouteData;
Assert.Null(routeData.Values[ChildActionValueProvider.ChildActionValuesKey]);
}
public void RouteValuesIncludeNewActionName()
{
// Arrange
MvcHandler mvcHandler = null;
httpContext.Setup(hc => hc.Server.Execute(It.IsAny <IHttpHandler>(), It.IsAny <TextWriter>(), It.IsAny <bool>()))
.Callback <IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);
// Act
ChildActionExtensions.ActionHelper(htmlHelper.Object, "actionName", null /* controllerName */, null /* routeValues */, null /* textWriter */);
// Assert
RouteData routeData = mvcHandler.RequestContext.RouteData;
Assert.Equal("actionName", routeData.Values["action"]);
}
public void ProcessRequestWithRouteWithoutControllerThrows()
{
// Arrange
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader().Verifiable();
RouteData rd = new RouteData();
MvcHandler mvcHandler = new MvcHandler(new RequestContext(contextMock.Object, rd));
// Act
Assert.Throws<InvalidOperationException>(
delegate { mvcHandler.ProcessRequest(contextMock.Object); },
"The RouteData must contain an item named 'controller' with a non-empty string value.");
// Assert
contextMock.Verify();
}
protected override void DoRender(HtmlTextWriter output)
{
var rendering = global::Sitecore.Context.Page.GetRenderingReference(this);
if (rendering == null)
{
return;
}
var action = ControllerAction.GetControllerAction(MvcSubLayoutDataProvider.parentId, rendering.RenderingID);
if (action == null)
{
return;
}
var httpContext = new HttpContextWrapper(Context);
var existingRouteData = RouteTable.Routes.GetRouteData(httpContext);
var additionalRouteValues = existingRouteData == null ? new RouteValueDictionary() : existingRouteData.Values;
if (!string.IsNullOrEmpty(DataSource))
{
var item = rendering.Database.GetItem(DataSource);
if (item != null)
{
additionalRouteValues["_sitecoreitem"] = item;
}
}
additionalRouteValues["_sitecorerendering"] = rendering;
var parameters = WebUtil.ParseUrlParameters(Parameters);
foreach (var key in parameters.AllKeys)
{
additionalRouteValues[key] = parameters[key];
}
var routeData = MvcActionHelper.GetRouteData(
httpContext,
action.ActionName,
action.ControllerType.ControllerName,
additionalRouteValues,
true
);
var handler = new MvcHandler(new RequestContext(httpContext, routeData));
httpContext.Server.Execute(HttpHandlerUtil.WrapForServerExecute(handler), output, true /* preserveForm */);
}
public void RouteValuesDoesNotIncludeExplicitlyPassedAreaName()
{
// Arrange
Route route = _routes.MapRoute("my-area", "my-area");
route.DataTokens["area"] = "myArea";
MvcHandler mvcHandler = null;
_httpContext
.Setup(
hc =>
hc.Server.Execute(
It.IsAny <IHttpHandler>(),
It.IsAny <TextWriter>(),
It.IsAny <bool>()
)
)
.Callback <IHttpHandler, TextWriter, bool>(
(handler, _, __) =>
mvcHandler = (MvcHandler)(
(HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler
).InnerHandler
);
// Act
ChildActionExtensions.ActionHelper(
_htmlHelper.Object,
"actionName",
null /* controllerName */
,
new RouteValueDictionary {
{ "area", "myArea" }
},
null /* textWriter */
);
// Assert
RouteData routeData = mvcHandler.RequestContext.RouteData;
Assert.False(routeData.Values.ContainsKey("area"));
Assert.Null(
(
routeData.Values[ChildActionValueProvider.ChildActionValuesKey]
as DictionaryValueProvider <object>
).GetValue("area")
);
}
public void AttributeRouting_AmbiguousActions_ThrowsAmbiguousException(Type controllerType, string path)
{
// Arrange
var controllerTypes = new[] { controllerType };
var routes = new RouteCollection();
routes.MapMvcAttributeRoutes(controllerTypes);
HttpContextBase context = GetContext(path);
RouteData routeData = routes.GetRouteData(context);
RequestContext requestContext = new RequestContext(context, routeData);
MvcHandler handler = new MvcHandler(requestContext);
handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));
Assert.Throws <AmbiguousMatchException>(() => handler.ProcessRequest(context));
}
public void ProcessRequestDisposesControllerIfExecuteThrowsException()
{
// Arrange
Mock<ControllerBase> mockController = new Mock<ControllerBase>(MockBehavior.Strict);
mockController.As<IDisposable>().Setup(d => d.Dispose()); // so that Verify can be called on Dispose later
mockController.Protected().Setup("Execute", ItExpr.IsAny<RequestContext>()).Throws(new Exception("some exception"));
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader().Verifiable();
RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
requestContext.RouteData.Values["controller"] = "fooController";
MvcHandler handler = new MvcHandler(requestContext)
{
ControllerBuilder = builder
};
// Act
Assert.Throws<Exception>(
delegate { handler.ProcessRequest(requestContext.HttpContext); },
"some exception");
// Assert
mockController.Verify();
contextMock.Verify();
mockController.As<IDisposable>().Verify(d => d.Dispose(), Times.AtMostOnce());
}
public void ProcessRequestWithDisabledServerHeaderOnlyCallsExecute()
{
bool oldResponseHeaderValue = MvcHandler.DisableMvcResponseHeader;
try
{
// Arrange
MvcHandler.DisableMvcResponseHeader = true;
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
controllerMock.Verify();
}
finally
{
MvcHandler.DisableMvcResponseHeader = oldResponseHeaderValue;
}
}
