public static DefaultControllerActionArgumentBinder GetArgumentBinder(MvcOptions options = null) { var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); return new DefaultControllerActionArgumentBinder( metadataProvider, GetObjectValidator(options)); }
public void DefaultModelBindersProvider_ProvidesInstancesOfModelBinders() { // Arrange var service = Mock.Of<ITestService>(); var binder = new TypeMatchModelBinder(); var options = new MvcOptions(); options.ModelBinders.Add(binder); options.ModelBinders.Add(typeof(TestModelBinder)); var optionsAccessor = new Mock<IOptionsAccessor<MvcOptions>>(); optionsAccessor.SetupGet(o => o.Options) .Returns(options); var activator = new TypeActivator(); var serviceProvider = new Mock<IServiceProvider>(); serviceProvider.Setup(p => p.GetService(typeof(ITestService))) .Returns(service); var provider = new DefaultModelBindersProvider(optionsAccessor.Object, activator, serviceProvider.Object); // Act var binders = provider.ModelBinders; // Assert Assert.Equal(2, binders.Count); Assert.Same(binder, binders[0]); var testModelBinder = Assert.IsType<TestModelBinder>(binders[1]); Assert.Same(service, testModelBinder.Service); }
public void ViewEngine_ReturnsInstantiatedListOfViewEngines() { // Arrange var service = Mock.Of<ITestService>(); var valueProviderFactory = Mock.Of<IValueProviderFactory>(); var type = typeof(TestValueProviderFactory); var typeActivator = new TypeActivator(); var serviceProvider = new Mock<IServiceProvider>(); serviceProvider.Setup(p => p.GetService(typeof(ITestService))) .Returns(service); var options = new MvcOptions(); options.ValueProviderFactories.Add(valueProviderFactory); options.ValueProviderFactories.Add(type); var accessor = new Mock<IOptionsAccessor<MvcOptions>>(); accessor.SetupGet(a => a.Options) .Returns(options); var provider = new DefaultValueProviderFactoryProvider(accessor.Object, typeActivator, serviceProvider.Object); // Act var result = provider.ValueProviderFactories; // Assert Assert.Equal(2, result.Count); Assert.Same(valueProviderFactory, result[0]); var testValueProviderFactory = Assert.IsType<TestValueProviderFactory>(result[1]); Assert.Same(service, testValueProviderFactory.Service); }
public void ValidationProviders_ReturnsInstantiatedListOfValueProviders() { // Arrange var service = Mock.Of<ITestService>(); var validationProvider = Mock.Of<IModelValidatorProvider>(); var type = typeof(TestModelValidationProvider); var serviceProvider = new Mock<IServiceProvider>(); serviceProvider.Setup(p => p.GetService(typeof(ITestService))) .Returns(service); var typeActivatorCache = new DefaultTypeActivatorCache(); var options = new MvcOptions(); options.ModelValidatorProviders.Add(type); options.ModelValidatorProviders.Add(validationProvider); var accessor = new Mock<IOptions<MvcOptions>>(); accessor.SetupGet(a => a.Options) .Returns(options); var provider = new DefaultModelValidatorProviderProvider(accessor.Object, typeActivatorCache, serviceProvider.Object); // Act var result = provider.ModelValidatorProviders; // Assert Assert.Equal(2, result.Count); var testModelValidationProvider = Assert.IsType<TestModelValidationProvider>(result[0]); Assert.Same(service, testModelValidationProvider.Service); Assert.Same(validationProvider, result[1]); }
public void MaxValidationError_ThrowsIfValueIsOutOfRange() { // Arrange var options = new MvcOptions(); // Act & Assert var ex = Assert.Throws<ArgumentOutOfRangeException>(() => options.MaxModelValidationErrors = -1); Assert.Equal("value", ex.ParamName); }
public static IObjectModelValidator GetObjectValidator(MvcOptions options = null) { options = options ?? new TestMvcOptions().Value; options.MaxModelValidationErrors = 5; var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); return new DefaultObjectValidator( options.ValidationExcludeFilters, metadataProvider); }
public void AntiForgeryOptions_SettingNullValue_Throws() { // Arrange var options = new MvcOptions(); // Act & Assert var ex = Assert.Throws<ArgumentNullException>(() => options.AntiForgeryOptions = null); Assert.Equal("The 'AntiForgeryOptions' property of 'Microsoft.AspNet.Mvc.MvcOptions' must not be null." + Environment.NewLine + "Parameter name: value", ex.Message); }
public void InputFormatters_InstanceOf_ThrowsInvalidOperationExceptionIfNoInstance() { // Arrange var formatters = new MvcOptions().InputFormatters; formatters.Add(Mock.Of<IInputFormatter>()); formatters.Add(typeof(JsonInputFormatter)); // Act & Assert Assert.Throws<InvalidOperationException>(() => formatters.InstanceOf<JsonInputFormatter>()); }
public void ThrowsWhenMultipleCacheProfilesWithSameNameAreAdded() { // Arrange var options = new MvcOptions(); options.CacheProfiles.Add("HelloWorld", new CacheProfile { Duration = 10 }); // Act & Assert var ex = Assert.Throws<ArgumentException>( () => options.CacheProfiles.Add("HelloWorld", new CacheProfile { Duration = 5 })); Assert.Equal("An item with the same key has already been added.", ex.Message); }
public void InputFormatters_InstanceOfOrDefault_ThrowsInvalidOperationExceptionIfMoreThanOnceInstance() { // Arrange var formatters = new MvcOptions().InputFormatters; formatters.Add(new JsonInputFormatter()); formatters.Add(Mock.Of<IInputFormatter>()); formatters.Add(new JsonInputFormatter()); // Act & Assert Assert.Throws<InvalidOperationException>(() => formatters.InstanceOfOrDefault<JsonInputFormatter>()); }
public async Task BindParameter_WithTypeProperty_IsNotBound() { // Arrange var options = new MvcOptions(); var setup = new MvcCoreMvcOptionsSetup(new TestHttpRequestStreamReaderFactory()); // Adding a custom model binder for Type to ensure it doesn't get called options.ModelBinderProviders.Insert(0, new TypeModelBinderProvider()); setup.Configure(options); var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(options); var parameter = new ParameterDescriptor() { Name = "Parameter1", BindingInfo = new BindingInfo(), ParameterType = typeof(TypesBundle), }; var testContext = ModelBindingTestHelper.GetTestContext(request => { request.Form = new FormCollection(new Dictionary<string, StringValues> { { "name", new[] { "Fred" } }, { "type", new[] { "SomeType" } }, { "typeArray", new[] { "SomeType1", "SomeType2" } }, { "typeList", new[] { "SomeType1", "SomeType2" } }, { "typeDictionary", new[] { "parameter[0].Key=key", "parameter[0].Value=value" } }, { "methodInfo", new[] { "value" } }, { "func", new[] { "value" } }, }); }); var modelState = testContext.ModelState; // Act var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext); // Assert // ModelBindingResult Assert.True(modelBindingResult.IsModelSet); // Model var boundPerson = Assert.IsType<TypesBundle>(modelBindingResult.Model); Assert.NotNull(boundPerson); Assert.Equal("Fred", boundPerson.Name); // ModelState // The TypeModelBinder should not be called Assert.True(modelState.IsValid); }
public static DefaultControllerActionArgumentBinder GetArgumentBinder(MvcOptions options = null) { if (options == null) { var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); return GetArgumentBinder(metadataProvider); } else { var metadataProvider = TestModelMetadataProvider.CreateProvider(options.ModelMetadataDetailsProviders); return GetArgumentBinder(metadataProvider); } }
public void InputFormatters_InstanceOfOrDefault_ReturnsNullIfNoInstance() { // Arrange var formatters = new MvcOptions().InputFormatters; formatters.Add(Mock.Of<IInputFormatter>()); formatters.Add(typeof(JsonInputFormatter)); // Act var formatter = formatters.InstanceOfOrDefault<JsonInputFormatter>(); // Assert Assert.Null(formatter); }
public void InputFormatters_InstanceOf_ReturnsInstanceOfIInputFormatterIfOneExists() { // Arrange var formatters = new MvcOptions().InputFormatters; formatters.Add(Mock.Of<IInputFormatter>()); var jsonFormatter = new JsonInputFormatter(); formatters.Add(jsonFormatter); formatters.Add(typeof(JsonInputFormatter)); // Act var formatter = formatters.InstanceOf<JsonInputFormatter>(); // Assert Assert.NotNull(formatter); Assert.IsType<JsonInputFormatter>(formatter); Assert.Same(jsonFormatter, formatter); }
public void DefaultActionModelConvention_AppliesToAllActionsInApp() { // Arrange var options = new MvcOptions(); var app = new ApplicationModel(); app.Controllers.Add(new ControllerModel(typeof(HelloController).GetTypeInfo(), new List<object>())); app.Controllers.Add(new ControllerModel(typeof(WorldController).GetTypeInfo(), new List<object>())); options.Conventions.Add(new SimpleActionConvention()); // Act options.Conventions[0].Apply(app); // Assert foreach (var controller in app.Controllers) { foreach (var action in controller.Actions) { Assert.True(action.Properties.ContainsKey("TestProperty")); } } }
public void Add_WithTypeName_RegistersTypesAndDerivedType_ToBeExcluded(Type type) { // Arrange var options = new MvcOptions(); options.ValidationExcludeFilters.Add(type.FullName); var optionsAccessor = new Mock<IOptions<MvcOptions>>(); optionsAccessor.SetupGet(o => o.Options) .Returns(options); var typeActivatorCache = new Mock<ITypeActivatorCache>(); var service = Mock.Of<ITestService>(); var serviceProvider = new Mock<IServiceProvider>(); serviceProvider.Setup(p => p.GetService(typeof(ITestService))) .Returns(service); var provider = new DefaultValidationExcludeFiltersProvider(optionsAccessor.Object, typeActivatorCache.Object, serviceProvider.Object); // Act var filters = provider.ExcludeFilters; // Assert Assert.Equal(1, filters.Count); Assert.True(filters[0].IsTypeExcluded(type)); }
private void AddXmlDataContract(MvcOptions options) { options?.OutputFormatters.Add(new XmlDataContractSerializerOutputFormatter()); }
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"); } 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) { var filter = new FilterItem( new FilterDescriptor(filterMetadata, FilterScope.Action), filterMetadata); context.Results.Add(filter); } }); 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 IModelBinder[0], new IModelValidatorProvider[0], new IValueProviderFactory[0], new NullLoggerFactory().CreateLogger<ControllerActionInvoker>(), new DiagnosticListener("Microsoft.AspNet"), maxAllowedErrorsInModelState); return invoker; }
public static void UseCentralRoutePrefix(this MvcOptions opts, IRouteTemplateProvider routeAttribute) { // 添加我们自定义 实现IApplicationModelConvention的RouteConvention opts.Conventions.Insert(0, new RouteConvention(routeAttribute)); }
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); } } } }
private static MvcOptions MvcOption(this MvcOptions option) { option.OutputFormatters.Add(new XmlDataContractSerializerOutputFormatter()); return(option); }
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];
protected override void AddMvcOptions(MvcOptions options) { options.SuppressAsyncSuffixInActionNames = false; options.Filters.Add <Destiny.Core.Flow.API.Filters.PermissionAuthorizationFilter>(); //options.Filters.Add<AuditLogFilter>(); }
public static void UseFromBodyBinding(this MvcOptions opts, Func <ControllerModel, bool> controllerPredicate = null, Func <ActionModel, bool> actionPredicate = null, Func <ParameterModel, bool> parameterPredicate = null) { opts.Conventions.Insert(0, new FromBodyApplicationModelConvention(controllerPredicate, actionPredicate, parameterPredicate)); }
/// <summary> /// Registers a Validation action filter as application model convention, which applies this filter to POST, PUT, and DELETE actions. /// </summary> /// <param name="controllerPredicate">A controller predicate for more granular application of the filter.</param> /// <param name="actionPredicate">An action predicate for more granular application of the filter.</param> public static void UseValidationFilter(this MvcOptions opts, Func <ControllerModel, bool> controllerPredicate = null, Func <ActionModel, bool> actionPredicate = null) => UseValidationFilter(opts, new ValidationAttribute(), controllerPredicate, actionPredicate);
private static DefaultOutputFormatterSelector CreateSelector(MvcOptions options) { return(new DefaultOutputFormatterSelector(Options.Create(options), NullLoggerFactory.Instance)); }
public static void UseGlobalRoutePrefix(this MvcOptions opts, string routeTemplate) { opts.Conventions.Insert(0, new GlobalRoutePrefixConvention(new RouteAttribute(routeTemplate))); }
private static void AddMetadataProviders(MvcOptions options, IServiceCollection services) { options.ModelMetadataDetailsProviders.Add( new AbpDataAnnotationAutoLocalizationMetadataDetailsProvider(services) ); }
private static void AddModelBinders(MvcOptions options) { options.ModelBinderProviders.Insert(0, new AbpDateTimeModelBinderProvider()); options.ModelBinderProviders.Insert(0, new AbpExtraPropertiesDictionaryModelBinderProvider()); }
private static void AddConventions(MvcOptions options, IServiceCollection services) { options.Conventions.Add(new AbpServiceConventionWrapper(services)); }
public void AddedParameterConvention_AppliesToAllPropertiesAndParameters() { // Arrange var app = new ApplicationModel(); var controllerType1 = typeof(HelloController).GetTypeInfo(); var parameterModel1 = new ParameterModel( controllerType1.GetMethod(nameof(HelloController.GetInfo)).GetParameters()[0], Array.Empty <object>()); var actionMethod1 = controllerType1.GetMethod(nameof(HelloController.GetInfo)); var property1 = controllerType1.GetProperty(nameof(HelloController.Property1)); var controllerModel1 = new ControllerModel(controllerType1, Array.Empty <object>()) { ControllerProperties = { new PropertyModel(property1, Array.Empty <object>()), }, Actions = { new ActionModel(actionMethod1, Array.Empty <object>()) { Parameters = { parameterModel1, } } } }; var controllerType2 = typeof(WorldController).GetTypeInfo(); var property2 = controllerType2.GetProperty(nameof(WorldController.Property2)); var controllerModel2 = new ControllerModel(controllerType2, Array.Empty <object>()) { ControllerProperties = { new PropertyModel(property2, Array.Empty <object>()), }, }; app.Controllers.Add(controllerModel1); app.Controllers.Add(controllerModel2); var options = new MvcOptions(); var convention = new SimplePropertyConvention(); options.Conventions.Add(convention); // Act ApplicationModelConventions.ApplyConventions(app, options.Conventions); // Assert var kvp = Assert.Single(controllerModel1.ControllerProperties[0].Properties); Assert.Equal("TestProperty", kvp.Key); Assert.Equal("TestValue", kvp.Value); kvp = Assert.Single(controllerModel2.ControllerProperties[0].Properties); Assert.Equal("TestProperty", kvp.Key); Assert.Equal("TestValue", kvp.Value); kvp = Assert.Single(controllerModel1.Actions[0].Parameters[0].Properties); Assert.Equal("TestProperty", kvp.Key); Assert.Equal("TestValue", kvp.Value); }
/// <summary> /// Initializes an instance of <see cref="FormatFilter"/>. /// </summary> /// <param name="options">The <see cref="IOptions{MvcOptions}"/></param> public FormatFilter(IOptions<MvcOptions> options) { _options = options.Value; }
protected override void ConfigureMvcOptions(MvcOptions options) { options.EnableEndpointRouting = false; }
private static void SetupMvc(MvcOptions options) { //options.ModelBinderProviders.Insert(0, new EnumModelBinderProvider()) }
public AngularJsonOnlyConfigurationFilter(ArrayPool <char> arrayPool, IOptionsSnapshot <MvcOptions> options) { _arrayPool = arrayPool; _options = options.Value; }
/// <summary> /// Initializes an instance of <see cref="FormatFilter"/>. /// </summary> /// <param name="options">The <see cref="IOptions{MvcOptions}"/></param> public FormatFilter(IOptions <MvcOptions> options) { _options = options.Value; }
public static void UseCentralRoutePrefix(this MvcOptions opts, IRouteTemplateProvider routeAttribute) { opts.Conventions.Insert(0, new RouteConvention(routeAttribute)); }
// this exists as a virtual to let us disable the SetClaimsFilter in some tests public virtual void ConfigureMvcOptions(MvcOptions options) { // this filter adds claims, just stops us having to wire up to a real auth provider in this sample options.Filters.Add <SetClaimsFilter>(); }
public virtual void ConfigureMvcOptionsService(MvcOptions options) { }
/// <summary> /// 配置MVC功能 /// </summary> /// <param name="mvcOptions"></param> public void ConfigureMvc(MvcOptions mvcOptions) { }
private static void ConfigureMvcOptions(MvcOptions options) { options.Conventions.Add(new ApiPaginationApplicationModelConvention()); }
private static ActionBindingContext GetActionBindingContext(MvcOptions options, ActionContext actionContext) { var valueProviderFactoryContext = new ValueProviderFactoryContext( actionContext.HttpContext, actionContext.RouteData.Values); var valueProvider = CompositeValueProvider.CreateAsync( options.ValueProviderFactories, valueProviderFactoryContext).Result; return new ActionBindingContext() { InputFormatters = options.InputFormatters, OutputFormatters = options.OutputFormatters, // Not required for model binding. ValidatorProvider = new TestModelValidatorProvider(options.ModelValidatorProviders), ModelBinder = new CompositeModelBinder(options.ModelBinders), ValueProvider = valueProvider }; }
private static ControllerContext GetControllerContext(MvcOptions options, ActionContext context) { var valueProviders = new List<IValueProvider>(); foreach (var factory in options.ValueProviderFactories) { var valueProvider = factory.GetValueProviderAsync(context).Result; if (valueProvider != null) { valueProviders.Add(valueProvider); } } return new ControllerContext(context) { InputFormatters = options.InputFormatters, ValidatorProviders = options.ModelValidatorProviders, ModelBinders = options.ModelBinders, ValueProviders = valueProviders }; }
public void OutputFormatters_InstancesOf_ReturnsNonEmptyCollectionIfSomeExist() { // Arrange var formatters = new MvcOptions().OutputFormatters; formatters.Add(typeof(JsonOutputFormatter)); var formatter1 = new JsonOutputFormatter(); var formatter2 = Mock.Of<IOutputFormatter>(); var formatter3 = new JsonOutputFormatter(); var formatter4 = Mock.Of<IOutputFormatter>(); formatters.Add(formatter1); formatters.Add(formatter2); formatters.Add(formatter3); formatters.Add(formatter4); var expectedFormatters = new List<JsonOutputFormatter> { formatter1, formatter3 }; // Act var jsonFormatters = formatters.InstancesOf<JsonOutputFormatter>().ToList(); // Assert Assert.NotEmpty(jsonFormatters); Assert.Equal(jsonFormatters, expectedFormatters); }
public static void UseGeneralRoutePrefix(this MvcOptions opts, string prefix) { opts.UseGeneralRoutePrefix(new RouteAttribute(prefix)); }
protected virtual void ConfigureMvcOptions(MvcOptions options) { }
private IReadOnlyList<ApiDescription> GetApiDescriptions( ActionDescriptor action, List<MockFormatter> formatters) { var context = new ApiDescriptionProviderContext(new ActionDescriptor[] { action }); var options = new MvcOptions(); foreach (var formatter in formatters) { options.OutputFormatters.Add(formatter); } var optionsAccessor = new Mock<IOptions<MvcOptions>>(); optionsAccessor.SetupGet(o => o.Value) .Returns(options); var constraintResolver = new Mock<IInlineConstraintResolver>(); constraintResolver.Setup(c => c.ResolveConstraint("int")) .Returns(new IntRouteConstraint()); var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var provider = new DefaultApiDescriptionProvider( optionsAccessor.Object, constraintResolver.Object, modelMetadataProvider); provider.OnProvidersExecuting(context); provider.OnProvidersExecuted(context); return new ReadOnlyCollection<ApiDescription>(context.Results); }
public static MvcOptions AddModelMetadataDetailsProviderFor(this MvcOptions options, Type type) { options.ModelMetadataDetailsProviders.Add(new SuppressChildValidationMetadataProvider(type)); return(options); }
/// <summary> /// Registers a filter as global application model convention. /// </summary> /// <param name="filter">A custom filter to register.</param> /// <param name="controllerPredicate">A controller predicate for more granular application of the filter.</param> /// <param name="actionPredicate">An action predicate for more granular application of the filter.</param> /// <param name="selectorPredicate">A selector predicate for more granular application of the filter.</param> public static void AddGlobalFilter(this MvcOptions opts, IFilterMetadata filter, Func <ControllerModel, bool> controllerPredicate = null, Func <ActionModel, bool> actionPredicate = null, Func <SelectorModel, bool> selectorPredicate = null) { opts.Conventions.Insert(0, new GlobalFilterApplicationModelConvention(controllerPredicate, actionPredicate, selectorPredicate, filter)); }
private static void ConfigureController(MvcOptions options) { options.Filters.Add <ValidationFilterAttribute>(); }
public NewtonsoftJsonOutputFormatter( JsonSerializerSettings serializerSettings, ArrayPool <char> charPool, MvcOptions mvcOptions) : this(serializerSettings, charPool, mvcOptions, jsonOptions : null) { }
public static void UseGeneralRoutePrefix(this MvcOptions opts, IRouteTemplateProvider routeAttribute) { opts.Conventions.Add(new RoutePrefixConvention(routeAttribute)); }
private static IServiceProvider GetServiceProvider() { var options = new MvcOptions(); var optionsAccessor = new Mock<IOptions<MvcOptions>>(); optionsAccessor.SetupGet(o => o.Options).Returns(options); var serviceCollection = new ServiceCollection(); serviceCollection.AddInstance(optionsAccessor.Object); return serviceCollection.BuildServiceProvider(); }
public void OutputFormatters_InstancesOf_ReturnsEmptyCollectionIfNoneExist() { // Arrange var formatters = new MvcOptions().OutputFormatters; formatters.Add(Mock.Of<IOutputFormatter>()); formatters.Add(typeof(JsonOutputFormatter)); // Act var jsonFormatters = formatters.InstancesOf<JsonOutputFormatter>(); // Assert Assert.Empty(jsonFormatters); }