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; } }