public void should_return_not_found_if_no_method_found()
{
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
new ActionDescriptor(new ControllerWithoutAction(), "GET", HttpMethod.Get));
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public void should_return_method_not_allowed_if_method_mismatches()
{
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
new ActionDescriptor(new ControllerWithMismatchedMethod(), "Post", HttpMethod.Post));
Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode);
}
public void should_only_invoke_public_instance_method()
{
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
new ActionDescriptor(new ControllerWithNonPublicAction(), "GET", HttpMethod.Get));
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public void should_invoke_case_insensitively()
{
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
new ActionDescriptor(new ControllerWithPublicAction(), "GET", HttpMethod.Get));
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public static ControllerInfo Create(Type controllerType, RegisterSettings registerSettings, CodeRoutingProvider provider)
{
ControllerDescriptor controllerDescr = null;
if (createActionInvoker != null)
{
Controller instance = null;
try {
instance = (Controller)FormatterServices.GetUninitializedObject(controllerType);
} catch (SecurityException) { }
if (instance != null)
{
ControllerActionInvoker actionInvoker = createActionInvoker(instance) as ControllerActionInvoker;
if (actionInvoker != null)
{
controllerDescr = getControllerDescriptor(actionInvoker, new ControllerContext {
Controller = instance
});
}
}
}
if (controllerDescr != null)
{
return(new DescribedMvcControllerInfo(controllerDescr, controllerType, registerSettings, provider));
}
return(new ReflectedMvcControllerInfo(controllerType, registerSettings, provider));
}
public void should_get_internal_server_error_when_exception_occurs()
{
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
new ActionDescriptor(new ControllerWithErrorAction(), "Get", HttpMethod.Get));
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
public void OnProvidersExecuting(ActionInvokerProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.ActionContext.ActionDescriptor is ControllerActionDescriptor)
{
var controllerContext = new ControllerContext(context.ActionContext)
{
// PERF: These are rarely going to be changed, so let's go copy-on-write.
ValueProviderFactories = new CopyOnWriteList <IValueProviderFactory>(_valueProviderFactories)
};
controllerContext.ModelState.MaxAllowedErrors = _maxModelValidationErrors;
var(cacheEntry, filters) = _controllerActionInvokerCache.GetCachedResult(controllerContext);
var invoker = new ControllerActionInvoker(
_logger,
_diagnosticListener,
_actionContextAccessor,
_mapper,
controllerContext,
cacheEntry,
filters);
context.Result = invoker;
}
}
public bool InvokeAction(ControllerContext controllerContext, string actionName)
{
if (controllerContext.RequestContext.HttpContext.Request.IsLocal)
{
ControllerActionInvoker invoker = new ControllerActionInvoker();
invoker.InvokeAction(controllerContext, actionName);
return(true);
}
return(false);
}
public void should_invoke_method_with_multiple_methods(string method)
{
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
new ActionDescriptor(
new ControllerWithMultipleMethodAnnotation(),
"Invoke",
new HttpMethod(method)));
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public static void RenderPartial <TController>(string action, object model, TController controller, RouteData routeData)
where TController : Controller
{
var httpContextBase = new HttpContextWrapper(HttpContext.Current);
var controllerContext = new ControllerContext(new RequestContext(httpContextBase, routeData), controller);
controllerContext.Controller.ControllerContext = new ControllerContext(new RequestContext(httpContextBase, routeData), controller);
ControllerActionInvoker invoker = new ControllerActionInvoker();
invoker.InvokeAction(controllerContext, action);
}
public void should_only_register_public_controller()
{
var matchedRoute = new HttpRoute(typeof(NonPublicController), "Get", HttpMethod.Get);
var controllerTypeResolver = new DefaultHttpControllerTypeResolver();
var resolver = new DefaultDependencyResolver(controllerTypeResolver.GetControllerTypes(ControllerAssemblies));
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, resolver);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
public void should_only_invoke_public_instance_method()
{
var matchedRoute = new HttpRoute(typeof(ControllerWithNonPublicAction), "Get", HttpMethod.Get);
var controllerTypeResolver = new DefaultHttpControllerTypeResolver();
var resolver = new DefaultDependencyResolver(controllerTypeResolver.GetControllerTypes(ControllerAssemblies));
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, resolver);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public void should_return_method_not_allowed_if_method_mismatches()
{
var matchedRoute = new HttpRoute(typeof(ControllerWithMismatchedMethod), "Post", HttpMethod.Post);
var controllerTypeResolver = new DefaultHttpControllerTypeResolver();
var resolver = new DefaultDependencyResolver(controllerTypeResolver.GetControllerTypes(ControllerAssemblies));
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, resolver);
Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode);
}
public void should_get_internal_server_error_when_exception_occurs()
{
var matchedRoute = new HttpRoute(typeof(ControllerWithErrorAction), "Get", HttpMethod.Get);
var controllerTypeResolver = new DefaultHttpControllerTypeResolver();
var resolver = new DefaultDependencyResolver(controllerTypeResolver.GetControllerTypes(ControllerAssemblies));
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, resolver);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
public void should_invoke_case_insensitively()
{
var matchedRoute = new HttpRoute(typeof(ControllerWithPublicAction), "GET", HttpMethod.Get);
var controllerTypeResolver = new DefaultHttpControllerTypeResolver();
var resolver = new DefaultDependencyResolver(controllerTypeResolver.GetControllerTypes(ControllerAssemblies));
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, resolver);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public void should_return_internal_server_error_if_no_controller_is_found()
{
var matchedRoute = new HttpRoute(typeof(ControllerWithoutAction), "Get", HttpMethod.Get);
var controllerTypeResolver = new DefaultHttpControllerTypeResolver();
var resolver = new DefaultDependencyResolver(
controllerTypeResolver.GetControllerTypes(new[] { Assembly.GetExecutingAssembly() }));
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, resolver);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
public void should_invoke_method_with_multiple_methods(string method)
{
var matchedRoute = new HttpRoute(
typeof(ControllerWithMultipleMethodAnnotation),
"Invoke",
new HttpMethod(method));
var controllerTypeResolver = new DefaultHttpControllerTypeResolver();
var resolver = new DefaultDependencyResolver(controllerTypeResolver.GetControllerTypes(ControllerAssemblies));
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, resolver);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public void should_invoke_case_insensitively()
{
var matchedRoute = new HttpRoute("ControllerWithPublicAction", "GET", HttpMethod.Get);
ICollection <Type> controllerTypes = new DefaultHttpControllerTypeResolver()
.GetControllerTypes(ControllerAssemblies);
var resolver = new DefaultDependencyResolver(controllerTypes);
var factory = new DefaultControllerFactory();
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, controllerTypes, resolver, factory);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public void should_only_invoke_public_instance_method()
{
var matchedRoute = new HttpRoute("ControllerWithNonPublicAction", "Get", HttpMethod.Get);
ICollection <Type> controllerTypes = new DefaultHttpControllerTypeResolver()
.GetControllerTypes(ControllerAssemblies);
var resolver = new DefaultDependencyResolver(controllerTypes);
var factory = new DefaultControllerFactory();
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, controllerTypes, resolver, factory);
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public void should_only_register_public_controller()
{
var matchedRoute = new HttpRoute("NonPublicController", "Get", HttpMethod.Get);
ICollection <Type> controllerTypes = new DefaultHttpControllerTypeResolver()
.GetControllerTypes(ControllerAssemblies);
var resolver = new DefaultDependencyResolver(controllerTypes);
var factory = new DefaultControllerFactory();
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, controllerTypes, resolver, factory);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
public void should_return_method_not_allowed_for_non_annotated_method()
{
var matchedRoute = new HttpRoute("ControllerWithoutMethodAnnotation", "Get", HttpMethod.Get);
ICollection <Type> controllerTypes = new DefaultHttpControllerTypeResolver()
.GetControllerTypes(ControllerAssemblies);
var resolver = new DefaultDependencyResolver(controllerTypes);
var factory = new DefaultControllerFactory();
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, controllerTypes, resolver, factory);
Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode);
}
public void should_invoke_method_with_multiple_methods(string method)
{
var matchedRoute = new HttpRoute(
"ControllerWithMultipleMethodAnnotation",
"Invoke",
new HttpMethod(method));
ICollection <Type> controllerTypes = new DefaultHttpControllerTypeResolver()
.GetControllerTypes(ControllerAssemblies);
var resolver = new DefaultDependencyResolver(controllerTypes);
var factory = new DefaultControllerFactory();
HttpResponseMessage response = ControllerActionInvoker.InvokeAction(
matchedRoute, controllerTypes, resolver, factory);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public RequestDelegate CreateRequestDelegate(ActionDescriptor actionDescriptor, RouteValueDictionary dataTokens)
{
// Fallback to action invoker extensibility so that invokers can override any default behaviors
if (!_enableActionInvokers && actionDescriptor is ControllerActionDescriptor)
{
return(context =>
{
RouteData routeData = null;
if (dataTokens is null or {
Count : 0
})
{
routeData = new RouteData(context.Request.RouteValues);
}
else
{
routeData = new RouteData();
routeData.PushState(router: null, context.Request.RouteValues, dataTokens);
}
var actionContext = new ActionContext(context, routeData, actionDescriptor);
var controllerContext = new ControllerContext(actionContext)
{
// PERF: These are rarely going to be changed, so let's go copy-on-write.
ValueProviderFactories = new CopyOnWriteList <IValueProviderFactory>(_valueProviderFactories)
};
controllerContext.ModelState.MaxAllowedErrors = _maxModelValidationErrors;
var(cacheEntry, filters) = _controllerActionInvokerCache.GetCachedResult(controllerContext);
var invoker = new ControllerActionInvoker(
_logger,
_diagnosticListener,
_actionContextAccessor,
_mapper,
controllerContext,
cacheEntry,
filters);
return invoker.InvokeAsync();
});
public IController CreateController(RequestContext requestContext, string controllerName)
{
IController ic = _inner.CreateController(requestContext, controllerName);
Controller c = ic as Controller;
if (c != null && WebApiEnabledAttribute.IsDefined(c))
{
IActionInvoker iai = c.ActionInvoker;
ControllerActionInvoker cai = iai as ControllerActionInvoker;
if (cai != null)
{
c.ActionInvoker = new ResourceControllerActionInvoker();
string actionName = requestContext.RouteData.Values["action"] as string;
if (String.IsNullOrEmpty(actionName))
{
// set it to a well known dummy value to avoid not having an action as that would prevent the fixup
// code in ResourceControllerActionInvoker, which is based on ActionDescriptor, from running
requestContext.RouteData.Values["action"] = RestActionToken;
}
}
}
return(ic);
}
/// <summary>
///
/// </summary>
/// <param name="self"></param>
/// <param name="arguments"></param>
/// <param name="actionMethodExecutor"></param>
/// <returns></returns>
public static object[] PrepareArguments(this ControllerActionInvoker self, Dictionary <string, object> arguments, ObjectMethodExecutor actionMethodExecutor)
{
return((object[])_prepareArgumentsMethodInfo.Invoke(self, new[] { arguments, actionMethodExecutor.Value }));
}
public BrokenController() {
ActionInvoker = new ControllerActionInvoker() {
DescriptorCache = new ControllerDescriptorCache()
};
}
/// <summary>
/// Determine if a node is accessible for a user
/// </summary>
/// <param name="context">Current HttpContext</param>
/// <param name="node">Sitemap node</param>
/// <returns>True/false if the node is accessible</returns>
public override bool IsAccessibleToUser(HttpContext context, SiteMapNode node)
{
// Is security trimming enabled?
if (!this.SecurityTrimmingEnabled)
{
return(true);
}
// Is it a regular node? No need for more things to do!
MvcSiteMapNode mvcNode = node as MvcSiteMapNode;
if (mvcNode == null)
{
return(base.IsAccessibleToUser(context, node));
}
// Find current handler
MvcHandler handler = context.Handler as MvcHandler;
if (handler != null)
{
// It's an MvcSiteMapNode, try to figure out the controller class
IController controller = ControllerBuilder.Current.GetControllerFactory().CreateController(handler.RequestContext, mvcNode.Controller);
// Find all AuthorizeAttributes on the controller class and action method
ControllerActionInvoker i = new ControllerActionInvoker();
ArrayList controllerAttributes = new ArrayList(controller.GetType().GetCustomAttributes(typeof(AuthorizeAttribute), true));
ArrayList actionAttributes = new ArrayList();
MethodInfo[] methods = controller.GetType().GetMethods();
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(AuthorizeAttribute), true));
}
}
// Attributes found?
if (controllerAttributes.Count == 0 && actionAttributes.Count == 0)
{
return(true);
}
// Find out current principal
IPrincipal principal = handler.RequestContext.HttpContext.User;
// Find out configuration
string roles = "";
string users = "";
if (controllerAttributes.Count > 0)
{
AuthorizeAttribute attribute = controllerAttributes[0] as AuthorizeAttribute;
roles += attribute.Roles;
users += attribute.Users;
}
if (actionAttributes.Count > 0)
{
AuthorizeAttribute attribute = actionAttributes[0] as AuthorizeAttribute;
roles += attribute.Roles;
users += attribute.Users;
}
// Still need security trimming?
if (string.IsNullOrEmpty(roles) && string.IsNullOrEmpty(users) && principal.Identity.IsAuthenticated)
{
return(true);
}
// Determine if the current user is allowed to access the current node
string[] roleArray = roles.Split(',');
string[] usersArray = users.Split(',');
foreach (string role in roleArray)
{
if (role != "*" && !principal.IsInRole(role))
{
return(false);
}
}
foreach (string user in usersArray)
{
if (user != "*" && (principal.Identity.Name == "" || principal.Identity.Name != user))
{
return(false);
}
}
return(true);
}
return(false);
}
public async Task Invoke_UsesDefaultValuesIfNotBound()
{
// Arrange
var actionDescriptor = new ControllerActionDescriptor
{
ControllerTypeInfo = typeof(TestController).GetTypeInfo(),
BoundProperties = new List<ParameterDescriptor>(),
MethodInfo = typeof(TestController).GetTypeInfo()
.DeclaredMethods
.First(m => m.Name.Equals("ActionMethodWithDefaultValues", StringComparison.Ordinal)),
Parameters = new List<ParameterDescriptor>
{
new ParameterDescriptor
{
Name = "value",
ParameterType = typeof(int),
BindingInfo = new BindingInfo(),
}
},
FilterDescriptors = new List<FilterDescriptor>()
};
var binder = new Mock<IModelBinder>();
binder.Setup(b => b.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Returns(Task.FromResult<ModelBindingResult>(result: null));
var context = new Mock<HttpContext>();
context.SetupGet(c => c.Items)
.Returns(new Dictionary<object, object>());
context.Setup(c => c.RequestServices.GetService(typeof(ITempDataDictionary)))
.Returns(new Mock<ITempDataDictionary>().Object);
context.Setup(c => c.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(new NullLoggerFactory());
var actionContext = new ActionContext(context.Object, new RouteData(), actionDescriptor);
var controllerFactory = new Mock<IControllerFactory>();
controllerFactory.Setup(c => c.CreateController(It.IsAny<ActionContext>()))
.Returns(new TestController());
var metadataProvider = new EmptyModelMetadataProvider();
var invoker = new ControllerActionInvoker(
actionContext,
new List<IFilterProvider>(),
controllerFactory.Object,
actionDescriptor,
new IInputFormatter[0],
new IOutputFormatter[0],
new DefaultControllerActionArgumentBinder(
metadataProvider,
new DefaultObjectValidator(new IExcludeTypeValidationFilter[0], metadataProvider)),
new IModelBinder[] { binder.Object },
new IModelValidatorProvider[0],
new IValueProviderFactory[0],
new MockScopedInstance<ActionBindingContext>(),
Mock.Of<ITempDataDictionary>(),
new NullLoggerFactory(),
200);
// Act
await invoker.InvokeAsync();
// Assert
Assert.Equal(5, context.Object.Items["Result"]);
}
