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