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 context = new Mock<HttpContext>(); context.SetupGet(c => c.Items) .Returns(new Dictionary<object, 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<ControllerContext>())) .Returns(new TestController()); var metadataProvider = new EmptyModelMetadataProvider(); var invoker = new ControllerActionInvoker( actionContext, CreateFilterCache(), controllerFactory.Object, actionDescriptor, new IInputFormatter[0], new ControllerArgumentBinder( metadataProvider, TestModelBinderFactory.CreateDefault(metadataProvider), new DefaultObjectValidator(metadataProvider, new ValidatorCache())), new IModelValidatorProvider[0], new IValueProviderFactory[0], new NullLoggerFactory().CreateLogger<ControllerActionInvoker>(), new DiagnosticListener("Microsoft.AspNetCore"), 200); // Act await invoker.InvokeAsync(); // Assert Assert.Equal(5, context.Object.Items["Result"]); }
public void CreateController_IgnoresPropertiesThatAreNotDecoratedWithAttribute() { // Arrange var actionDescriptor = new ControllerActionDescriptor { ControllerTypeInfo = typeof(ControllerWithoutAttributes).GetTypeInfo() }; var context = new ControllerContext() { ActionDescriptor = actionDescriptor, HttpContext = new DefaultHttpContext() { RequestServices = GetServices(), }, }; var factory = CreateControllerFactory(new DefaultControllerActivator(new TypeActivatorCache())); // Act var result = factory.CreateController(context); // Assert var controller = Assert.IsType<ControllerWithoutAttributes>(result); Assert.Null(controller.ActionContext); }
public void ExecutingAction_ForControllerAction_WithGivenRouteValues_LogsActionAndRouteData(string expectedRouteValuesLogMessage, params KeyValuePair <string, string>[] routeValues) { // Arrange var testSink = new TestSink(); var loggerFactory = new TestLoggerFactory(testSink, enabled: true); var logger = loggerFactory.CreateLogger("test"); var action = new Controllers.ControllerActionDescriptor { // Using a generic type to verify the use of a clean name ControllerTypeInfo = typeof(ValueTuple <int, string>).GetTypeInfo(), MethodInfo = typeof(object).GetMethod(nameof(ToString)), }; foreach (var routeValue in routeValues) { action.RouteValues.Add(routeValue); } // Act logger.ExecutingAction(action); // Assert var write = Assert.Single(testSink.Writes); Assert.Equal( $"Route matched with {expectedRouteValuesLogMessage}. " + "Executing controller action with signature System.String ToString() on controller System.ValueTuple<int, string> (System.Private.CoreLib).", write.State.ToString()); }
public ControllerActionInvoker( ActionContext actionContext, ControllerActionInvokerCache controllerActionInvokerCache, IControllerFactory controllerFactory, ControllerActionDescriptor descriptor, IReadOnlyList<IInputFormatter> inputFormatters, IControllerActionArgumentBinder argumentBinder, IReadOnlyList<IModelValidatorProvider> modelValidatorProviders, IReadOnlyList<IValueProviderFactory> valueProviderFactories, ILogger logger, DiagnosticSource diagnosticSource, int maxModelValidationErrors) : base( actionContext, controllerActionInvokerCache, inputFormatters, modelValidatorProviders, valueProviderFactories, logger, diagnosticSource, maxModelValidationErrors) { if (controllerFactory == null) { throw new ArgumentNullException(nameof(controllerFactory)); } if (descriptor == null) { throw new ArgumentNullException(nameof(descriptor)); } if (argumentBinder == null) { throw new ArgumentNullException(nameof(argumentBinder)); } _controllerFactory = controllerFactory; _descriptor = descriptor; _argumentBinder = argumentBinder; if (descriptor.MethodInfo == null) { throw new ArgumentException( Resources.FormatPropertyOfTypeCannotBeNull( nameof(descriptor.MethodInfo), typeof(ControllerActionDescriptor)), nameof(descriptor)); } }
public ModelBindingActionInvoker( ActionContext actionContext, ControllerActionInvokerCache controllerActionInvokerCache, IControllerFactory controllerFactory, ControllerActionDescriptor descriptor, IReadOnlyList<IInputFormatter> inputFormatters, IControllerActionArgumentBinder controllerActionArgumentBinder, IReadOnlyList<IModelValidatorProvider> modelValidatorProviders, IReadOnlyList<IValueProviderFactory> valueProviderFactories, ILogger logger, DiagnosticSource diagnosticSource, int maxModelValidationErrors) : base(actionContext, controllerActionInvokerCache, controllerFactory, descriptor, inputFormatters, controllerActionArgumentBinder, modelValidatorProviders, valueProviderFactories, logger, diagnosticSource, maxModelValidationErrors) { this.controllerActionDescriptor = descriptor; }
public IActionInvoker CreateModelBindingActionInvoker( ActionContext actionContext, ControllerActionDescriptor controllerActionDescriptor) { return new ModelBindingActionInvoker( actionContext, this.controllerActionInvokerCache, this.controllerFactory, controllerActionDescriptor, this.inputFormatters, this.argumentBinder, this.modelValidatorProviders, this.valueProviderFactories, this.logger, this.diagnosticSource, this.maxModelValidationErrors); }
public Func <ControllerContext, object> CreateControllerFactory(ControllerActionDescriptor descriptor) { if (descriptor == null) { throw new ArgumentNullException(nameof(descriptor)); } var controllerType = descriptor.ControllerTypeInfo?.AsType(); if (controllerType == null) { throw new ArgumentException(Resources.FormatPropertyOfTypeCannotBeNull( nameof(descriptor.ControllerTypeInfo), nameof(descriptor)), nameof(descriptor)); } if (_factoryCreateController != null) { return(_factoryCreateController); } var controllerActivator = _activatorProvider.CreateActivator(descriptor); var propertyActivators = GetPropertiesToActivate(descriptor); object CreateController(ControllerContext controllerContext) { var controller = controllerActivator(controllerContext); for (var i = 0; i < propertyActivators.Length; i++) { var propertyActivator = propertyActivators[i]; propertyActivator(controllerContext, controller); } return(controller); } return(CreateController); }
public void CreateReleaser_InvokesIControllerActivator_IfItIsNotDefaultControllerActivator() { // Arrange var expected = new object(); var activator = new Mock <IControllerActivator>(); activator.Setup(a => a.Release(It.IsAny <ControllerContext>(), expected)) .Verifiable(); var activatorProvider = new ControllerActivatorProvider(activator.Object); var descriptor = new ControllerActionDescriptor { ControllerTypeInfo = typeof(object).GetTypeInfo(), }; // Act var releaseDelegate = activatorProvider.CreateReleaser(descriptor); releaseDelegate(new ControllerContext(), expected); // Assert activator.Verify(); }
/// <inheritdoc/> public Func <ControllerContext, object, ValueTask>?CreateAsyncReleaser(ControllerActionDescriptor descriptor) { if (descriptor == null) { throw new ArgumentNullException(nameof(descriptor)); } if (_controllerActivatorReleaseAsync != null) { return(_controllerActivatorReleaseAsync); } if (typeof(IAsyncDisposable).GetTypeInfo().IsAssignableFrom(descriptor.ControllerTypeInfo)) { return(_disposeAsync); } if (typeof(IDisposable).GetTypeInfo().IsAssignableFrom(descriptor.ControllerTypeInfo)) { return(_syncDisposeAsync); } return(null); }
public Action <ControllerContext, object> CreateControllerReleaser(ControllerActionDescriptor descriptor) { if (descriptor == null) { throw new ArgumentNullException(nameof(descriptor)); } var controllerType = descriptor.ControllerTypeInfo?.AsType(); if (controllerType == null) { throw new ArgumentException(Resources.FormatPropertyOfTypeCannotBeNull( nameof(descriptor.ControllerTypeInfo), nameof(descriptor)), nameof(descriptor)); } if (_factoryReleaseController != null) { return(_factoryReleaseController); } return(_activatorProvider.CreateReleaser(descriptor)); }
public void CreateControllerFactory_UsesControllerActivatorAndPropertyActivator() { // Arrange var expectedProperty1 = new object(); var expectedProperty2 = new object(); var expectedController = new TestController(); var factory = new DefaultControllerFactory( Mock.Of <IControllerActivator>(), Enumerable.Empty <IControllerPropertyActivator>()); var activatorProvider = new Mock <IControllerActivatorProvider>(); activatorProvider.Setup(p => p.CreateActivator(It.IsAny <ControllerActionDescriptor>())) .Returns(_ => expectedController) .Verifiable(); var propertyActivator1 = new Mock <IControllerPropertyActivator>(); propertyActivator1.Setup(p => p.GetActivatorDelegate(It.IsAny <ControllerActionDescriptor>())) .Returns((context, controllerObject) => { ((TestController)controllerObject).ActivatedValue1 = expectedProperty1; }) .Verifiable(); var propertyActivator2 = new Mock <IControllerPropertyActivator>(); propertyActivator2.Setup(p => p.GetActivatorDelegate(It.IsAny <ControllerActionDescriptor>())) .Returns((context, controllerObject) => { ((TestController)controllerObject).ActivatedValue2 = expectedProperty2; }) .Verifiable(); var propertyActivators = new[] { propertyActivator1.Object, propertyActivator2.Object, }; var provider = new ControllerFactoryProvider( activatorProvider.Object, factory, propertyActivators); var descriptor = new ControllerActionDescriptor { ControllerTypeInfo = typeof(TestController).GetTypeInfo(), }; // Act var factoryDelegate = provider.CreateControllerFactory(descriptor); var controller = factoryDelegate(new ControllerContext()); // Assert var actual = Assert.IsType <TestController>(controller); Assert.Same(expectedController, actual); Assert.Same(expectedProperty1, actual.ActivatedValue1); Assert.Same(expectedProperty2, actual.ActivatedValue2); activatorProvider.Verify(); propertyActivator1.Verify(); propertyActivator2.Verify(); }
public void WithCustomControllerContextShouldSetItToAccessor() { MyMvc .IsUsingDefaultConfiguration() .WithServices(services => { services.AddActionContextAccessor(); }); var actionDescriptor = new ControllerActionDescriptor { Name = "Test" }; var actionContext = new ControllerContext { ActionDescriptor = actionDescriptor }; MyMvc .Controller<ActionContextController>() .WithControllerContext(actionContext) .ShouldPassFor() .TheController(controller => { Assert.NotNull(controller); Assert.NotNull(controller.Context); Assert.Equal("Test", controller.Context.ActionDescriptor.Name); }); MyMvc.IsUsingDefaultConfiguration(); }
public TestControllerActionInvoker( ActionContext actionContext, IFilterProvider[] filterProviders, MockControllerFactory controllerFactory, ControllerActionDescriptor descriptor, IReadOnlyList<IInputFormatter> inputFormatters, IControllerActionArgumentBinder controllerActionArgumentBinder, IReadOnlyList<IModelValidatorProvider> modelValidatorProviders, IReadOnlyList<IValueProviderFactory> valueProviderFactories, ILogger logger, DiagnosticSource diagnosticSource, int maxAllowedErrorsInModelState) : base( actionContext, CreateFilterCache(filterProviders), controllerFactory, descriptor, inputFormatters, controllerActionArgumentBinder, modelValidatorProviders, valueProviderFactories, logger, diagnosticSource, maxAllowedErrorsInModelState) { ControllerFactory = controllerFactory; }
public async Task ValidationIsTriggered_OnFromBodyModels(List<ParameterDescriptor> parameters) { // Arrange var actionDescriptor = new ControllerActionDescriptor() { BoundProperties = new List<ParameterDescriptor>(), Parameters = parameters }; var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(); var testContext = ModelBindingTestHelper.GetTestContext( request => { request.QueryString = new QueryString("?accountId=30"); request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{\"accountId\": 15,\"amount\": 250.0}")); request.ContentType = "application/json"; }, actionDescriptor: actionDescriptor); var arguments = new Dictionary<string, object>(StringComparer.Ordinal); var modelState = testContext.ModelState; // Act await argumentBinder.BindArgumentsAsync(testContext, new TestController(), arguments); // Assert Assert.False(modelState.IsValid); var entry = Assert.Single( modelState, e => string.Equals(e.Key, "AccountId", StringComparison.OrdinalIgnoreCase)).Value; var error = Assert.Single(entry.Errors); Assert.Equal("The field AccountId must be between 25 and 50.", error.ErrorMessage); }
public async Task MultipleActionParameter_ValidModelState(List<ParameterDescriptor> parameters) { // Since validation attribute is only present on the FromBody model's property(TransferInfo's AccountId), // validation should not trigger for the parameter which is bound from Uri. // Arrange var actionDescriptor = new ControllerActionDescriptor() { BoundProperties = new List<ParameterDescriptor>(), Parameters = parameters }; var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(); var testContext = ModelBindingTestHelper.GetTestContext( request => { request.QueryString = new QueryString("?accountId=10"); request.Body = new MemoryStream(Encoding.UTF8.GetBytes("{\"accountId\": 40,\"amount\": 250.0}")); request.ContentType = "application/json"; }, actionDescriptor: actionDescriptor); var arguments = new Dictionary<string, object>(StringComparer.Ordinal); var modelState = testContext.ModelState; // Act await argumentBinder.BindArgumentsAsync(testContext, new TestController(), arguments); // Assert Assert.True(modelState.IsValid); object value; Assert.True(arguments.TryGetValue("accountId", out value)); var accountId = Assert.IsType<int>(value); Assert.Equal(10, accountId); Assert.True(arguments.TryGetValue("transferInfo", out value)); var transferInfo = Assert.IsType<TransferInfo>(value); Assert.NotNull(transferInfo); Assert.Equal(40, transferInfo.AccountId); Assert.Equal(250.0, transferInfo.Amount); }
public void CreateController_UsesControllerActivatorToInstantiateController() { // Arrange var expected = new MyController(); var actionDescriptor = new ControllerActionDescriptor { ControllerTypeInfo = typeof(MyController).GetTypeInfo() }; var context = new ControllerContext() { ActionDescriptor = actionDescriptor, HttpContext = new DefaultHttpContext() { RequestServices = GetServices(), }, }; var activator = new Mock<IControllerActivator>(); activator.Setup(a => a.Create(context)) .Returns(expected) .Verifiable(); var controllerFactory = CreateControllerFactory(activator.Object); // Act var result = controllerFactory.CreateController(context); // Assert var controller = Assert.IsType<MyController>(result); Assert.Same(expected, controller); activator.Verify(); }
public static string?AreaName(this ControllerActionDescriptor actionDescriptor) => actionDescriptor.ControllerTypeInfo.GetCustomAttribute <AreaAttribute>()?.RouteValue;
public static (string?areaName, string controllerName, string actionName, string path) GetAreaControllerAction(this ControllerActionDescriptor actionDescriptor) { var area = actionDescriptor.AreaName(); var controller = actionDescriptor.ControllerName; var action = actionDescriptor.ActionName; var separator = Path.AltDirectorySeparatorChar; return(area, controller, action, $"{separator}{area}{separator}{controller}{separator}{action}"); }
public void CreateController_SetsControllerContext() { // Arrange var actionDescriptor = new ControllerActionDescriptor { ControllerTypeInfo = typeof(ControllerWithAttributes).GetTypeInfo() }; var context = new ControllerContext() { ActionDescriptor = actionDescriptor, HttpContext = new DefaultHttpContext() { RequestServices = GetServices(), }, }; var factory = CreateControllerFactory(new DefaultControllerActivator(new TypeActivatorCache())); // Act var result = factory.CreateController(context); // Assert var controller = Assert.IsType<ControllerWithAttributes>(result); Assert.Same(context, controller.ControllerContext); }
private static IDictionary<string, object> GetRouteValues( MethodInfo methodInfo, MethodCallExpression methodCallExpression, ControllerActionDescriptor controllerActionDescriptor, bool considerParameterDescriptors) { var result = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); var arguments = methodCallExpression.Arguments; if (arguments.Count == 0) { return result; } var methodParameters = methodInfo.GetParameters(); var parameterDescriptors = new Dictionary<string, string>(); if (considerParameterDescriptors) { var parameters = controllerActionDescriptor.Parameters; for (int i = 0; i < parameters.Count; i++) { var parameter = parameters[i]; if (parameter.BindingInfo != null) { parameterDescriptors.Add(parameter.Name, parameter.BindingInfo.BinderModelName); } } } for (var i = 0; i < arguments.Count; i++) { var methodParameterName = methodParameters[i].Name; if (considerParameterDescriptors && parameterDescriptors.ContainsKey(methodParameterName)) { methodParameterName = parameterDescriptors[methodParameterName] ?? methodParameterName; } var value = ExpressionParser.ResolveExpressionValue(arguments[i]); if (value == null) { continue; } result[methodParameterName] = value; } return result; }
public void WithControllerContextFuncShouldSetItToAccessor() { MyApplication .StartsFrom<DefaultStartup>() .WithServices(services => { services.AddActionContextAccessor(); }); var actionDescriptor = new ControllerActionDescriptor { DisplayName = "Test" };; MyController<ActionContextController> .Instance() .WithControllerContext(controllerContext => { controllerContext.ActionDescriptor = actionDescriptor; }) .ShouldPassForThe<ActionContextController>(controller => { Assert.NotNull(controller); Assert.NotNull(controller.Context); Assert.Equal("Test", controller.Context.ActionDescriptor.DisplayName); }); MyApplication.StartsFrom<DefaultStartup>(); }
public IActionInvoker CreateModelBindingActionInvoker(ActionContext actionContext, ControllerActionDescriptor controllerActionDescriptor) { return null; }
public static ControllerBinderDelegate CreateBinderDelegate( ParameterBinder parameterBinder, IModelBinderFactory modelBinderFactory, IModelMetadataProvider modelMetadataProvider, ControllerActionDescriptor actionDescriptor, MvcOptions mvcOptions) { if (parameterBinder == null) { throw new ArgumentNullException(nameof(parameterBinder)); } if (modelBinderFactory == null) { throw new ArgumentNullException(nameof(modelBinderFactory)); } if (modelMetadataProvider == null) { throw new ArgumentNullException(nameof(modelMetadataProvider)); } if (actionDescriptor == null) { throw new ArgumentNullException(nameof(actionDescriptor)); } if (mvcOptions == null) { throw new ArgumentNullException(nameof(mvcOptions)); } var parameterBindingInfo = GetParameterBindingInfo( modelBinderFactory, modelMetadataProvider, actionDescriptor, mvcOptions); var propertyBindingInfo = GetPropertyBindingInfo(modelBinderFactory, modelMetadataProvider, actionDescriptor); if (parameterBindingInfo == null && propertyBindingInfo == null) { return(null); } return(Bind); async Task Bind(ControllerContext controllerContext, object controller, Dictionary <string, object> arguments) { var valueProvider = await CompositeValueProvider.CreateAsync(controllerContext); var parameters = actionDescriptor.Parameters; for (var i = 0; i < parameters.Count; i++) { var parameter = parameters[i]; var bindingInfo = parameterBindingInfo[i]; var modelMetadata = bindingInfo.ModelMetadata; if (!modelMetadata.IsBindingAllowed) { continue; } var result = await parameterBinder.BindModelAsync( controllerContext, bindingInfo.ModelBinder, valueProvider, parameter, modelMetadata, value : null); if (result.IsModelSet) { arguments[parameter.Name] = result.Model; } } var properties = actionDescriptor.BoundProperties; for (var i = 0; i < properties.Count; i++) { var property = properties[i]; var bindingInfo = propertyBindingInfo[i]; var modelMetadata = bindingInfo.ModelMetadata; if (!modelMetadata.IsBindingAllowed) { continue; } var result = await parameterBinder.BindModelAsync( controllerContext, bindingInfo.ModelBinder, valueProvider, property, modelMetadata, value : null); if (result.IsModelSet) { PropertyValueSetter.SetValue(bindingInfo.ModelMetadata, controller, result.Model); } } } }
public void CreateController_ThrowsIConstructorCannotBeActivated() { // Arrange var actionDescriptor = new ControllerActionDescriptor { ControllerTypeInfo = typeof(ControllerThatCannotBeActivated).GetTypeInfo() }; var context = new ControllerContext() { ActionDescriptor = actionDescriptor, HttpContext = new DefaultHttpContext() { RequestServices = GetServices(), }, }; var factory = CreateControllerFactory(new DefaultControllerActivator(new TypeActivatorCache())); // Act and Assert var exception = Assert.Throws<InvalidOperationException>(() => factory.CreateController(context)); Assert.Equal( $"Unable to resolve service for type '{typeof(TestService).FullName}' while attempting to activate " + $"'{typeof(ControllerThatCannotBeActivated).FullName}'.", exception.Message); }
private static ActionDescriptor CreateAction(string area, string controller, string action) { var actionDescriptor = new ControllerActionDescriptor() { ActionName = string.Format("Area: {0}, Controller: {1}, Action: {2}", area, controller, action), Parameters = new List<ParameterDescriptor>(), }; actionDescriptor.RouteValues.Add("area", area); actionDescriptor.RouteValues.Add("controller", controller); actionDescriptor.RouteValues.Add("action", action); return actionDescriptor; }
//public static (string areaName, string controllerName, string actionName, string path) MvcRoutePath(this ControllerActionDescriptor actionDescriptor) { #region "DebugObject" public static ControllerActionDescriptorDebugObject GetDebugObject(this ControllerActionDescriptor controllerActionDescriptor) => new ControllerActionDescriptorDebugObject(controllerActionDescriptor);
public static ControllerBinderDelegate?CreateBinderDelegate( ParameterBinder parameterBinder, IModelBinderFactory modelBinderFactory, IModelMetadataProvider modelMetadataProvider, ControllerActionDescriptor actionDescriptor, MvcOptions mvcOptions) { if (parameterBinder == null) { throw new ArgumentNullException(nameof(parameterBinder)); } if (modelBinderFactory == null) { throw new ArgumentNullException(nameof(modelBinderFactory)); } if (modelMetadataProvider == null) { throw new ArgumentNullException(nameof(modelMetadataProvider)); } if (actionDescriptor == null) { throw new ArgumentNullException(nameof(actionDescriptor)); } if (mvcOptions == null) { throw new ArgumentNullException(nameof(mvcOptions)); } var parameterBindingInfo = GetParameterBindingInfo( modelBinderFactory, modelMetadataProvider, actionDescriptor); var propertyBindingInfo = GetPropertyBindingInfo(modelBinderFactory, modelMetadataProvider, actionDescriptor); if (parameterBindingInfo == null && propertyBindingInfo == null) { return(null); } var parameters = actionDescriptor.Parameters switch { List <ParameterDescriptor> list => list.ToArray(), _ => actionDescriptor.Parameters.ToArray() }; var properties = actionDescriptor.BoundProperties switch { List <ParameterDescriptor> list => list.ToArray(), _ => actionDescriptor.BoundProperties.ToArray() }; return(Bind); async Task Bind(ControllerContext controllerContext, object controller, Dictionary <string, object?> arguments) { var(success, valueProvider) = await CompositeValueProvider.TryCreateAsync(controllerContext, controllerContext.ValueProviderFactories); if (!success) { return; } Debug.Assert(valueProvider is not null); for (var i = 0; i < parameters.Length; i++) { var parameter = parameters[i]; var bindingInfo = parameterBindingInfo ![i]; var modelMetadata = bindingInfo.ModelMetadata; if (!modelMetadata.IsBindingAllowed) { continue; } var result = await parameterBinder.BindModelAsync( controllerContext, bindingInfo.ModelBinder, valueProvider, parameter, modelMetadata, value : null, container : null); // Parameters do not have containers. if (result.IsModelSet) { arguments[parameter.Name] = result.Model; } } for (var i = 0; i < properties.Length; i++) { var property = properties[i]; var bindingInfo = propertyBindingInfo ![i];
private TestControllerActionInvoker CreateInvoker( IFilterMetadata[] filters, bool actionThrows = false, int maxAllowedErrorsInModelState = 200) { var actionDescriptor = new ControllerActionDescriptor() { FilterDescriptors = new List<FilterDescriptor>(), Parameters = new List<ParameterDescriptor>(), }; if (actionThrows) { actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod("ThrowingActionMethod"); } else { actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod("ActionMethod"); } actionDescriptor.ControllerTypeInfo = typeof(ControllerActionInvokerTest).GetTypeInfo(); var httpContext = new Mock<HttpContext>(MockBehavior.Loose); var http = GetHttpContext(); var httpRequest = http.Request; var httpResponse = http.Response; httpContext.SetupGet(c => c.Request).Returns(httpRequest); httpContext.SetupGet(c => c.Response).Returns(httpResponse); httpContext .Setup(o => o.RequestServices.GetService(typeof(ILoggerFactory))) .Returns(NullLoggerFactory.Instance); httpResponse.Body = new MemoryStream(); var formatter = new Mock<IOutputFormatter>(); formatter .Setup(f => f.CanWriteResult(It.IsAny<OutputFormatterCanWriteContext>())) .Returns(true); formatter .Setup(f => f.WriteAsync(It.IsAny<OutputFormatterWriteContext>())) .Returns<OutputFormatterWriteContext>(async c => { await c.HttpContext.Response.WriteAsync(c.Object.ToString()); }); var options = new MvcOptions(); options.OutputFormatters.Add(formatter.Object); var optionsAccessor = new Mock<IOptions<MvcOptions>>(); optionsAccessor .SetupGet(o => o.Value) .Returns(options); httpContext .Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>))) .Returns(optionsAccessor.Object); var actionContext = new ActionContext( httpContext: httpContext.Object, routeData: new RouteData(), actionDescriptor: actionDescriptor); var filterProvider = new Mock<IFilterProvider>(MockBehavior.Strict); filterProvider .Setup(fp => fp.OnProvidersExecuting(It.IsAny<FilterProviderContext>())) .Callback<FilterProviderContext>(context => { foreach (var filterMetadata in filters) { context.Results.Add(new FilterItem(new FilterDescriptor(filterMetadata, FilterScope.Action)) { Filter = filterMetadata, }); } }); filterProvider .Setup(fp => fp.OnProvidersExecuted(It.IsAny<FilterProviderContext>())) .Verifiable(); var actionArgumentsBinder = new Mock<IControllerActionArgumentBinder>(); actionArgumentsBinder.Setup( b => b.BindActionArgumentsAsync(It.IsAny<ControllerContext>(), It.IsAny<object>())) .Returns(Task.FromResult<IDictionary<string, object>>(new Dictionary<string, object>())); filterProvider .SetupGet(fp => fp.Order) .Returns(-1000); var invoker = new TestControllerActionInvoker( actionContext, new[] { filterProvider.Object }, new MockControllerFactory(this), actionDescriptor, new IInputFormatter[0], actionArgumentsBinder.Object, new IModelValidatorProvider[0], new IValueProviderFactory[0], new NullLoggerFactory().CreateLogger<ControllerActionInvoker>(), new DiagnosticListener("Microsoft.AspNetCore"), maxAllowedErrorsInModelState); return invoker; }