public async Task BindModel() { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); ModelBindingContext bindingContext = new ModelBindingContext { ModelMetadata = metadataProvider.GetMetadataForType(typeof(IDictionary<int, string>)), ModelName = "someName", ValueProvider = new SimpleHttpValueProvider { { "someName[0]", new KeyValuePair<int, string>(42, "forty-two") }, { "someName[1]", new KeyValuePair<int, string>(84, "eighty-four") } }, OperationBindingContext = new OperationBindingContext { ModelBinder = CreateKvpBinder(), MetadataProvider = metadataProvider } }; var binder = new DictionaryModelBinder<int, string>(); // Act var retVal = await binder.BindModelAsync(bindingContext); // Assert Assert.NotNull(retVal); var dictionary = Assert.IsAssignableFrom<IDictionary<int, string>>(retVal.Model); Assert.NotNull(dictionary); Assert.Equal(2, dictionary.Count); Assert.Equal("forty-two", dictionary[42]); Assert.Equal("eighty-four", dictionary[84]); }
public void GetModelValidator_DoesNotReadPropertyValues() { ModelValidatorProvider[] originalProviders = ModelValidatorProviders.Providers.ToArray(); try { // Arrange ModelValidatorProviders.Providers.Clear(); ModelValidatorProviders.Providers.Add(new ObservableModelValidatorProvider()); ObservableModel model = new ObservableModel(); ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(ObservableModel)); ControllerContext controllerContext = new ControllerContext(); // Act ModelValidator validator = ModelValidator.GetModelValidator(metadata, controllerContext); ModelValidationResult[] results = validator.Validate(model).ToArray(); // Assert Assert.False(model.PropertyWasRead()); } finally { ModelValidatorProviders.Providers.Clear(); foreach (ModelValidatorProvider provider in originalProviders) { ModelValidatorProviders.Providers.Add(provider); } } }
public void GetModelValidators_ReturnsValidatorsFromAllProviders() { // Arrange var validator1 = Mock.Of<IModelValidator>(); var validator2 = Mock.Of<IModelValidator>(); var validator3 = Mock.Of<IModelValidator>(); var provider1 = new Mock<IModelValidatorProvider>(); provider1.Setup(p => p.GetValidators(It.IsAny<ModelValidatorProviderContext>())) .Callback<ModelValidatorProviderContext>(c => { c.Validators.Add(validator1); c.Validators.Add(validator2); }); var provider2 = new Mock<IModelValidatorProvider>(); provider2.Setup(p => p.GetValidators(It.IsAny<ModelValidatorProviderContext>())) .Callback<ModelValidatorProviderContext>(c => { c.Validators.Add(validator3); }); var compositeModelValidator = new CompositeModelValidatorProvider(new[] { provider1.Object, provider2.Object }); var modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(string)); // Act var validatorProviderContext = new ModelValidatorProviderContext(modelMetadata); compositeModelValidator.GetValidators(validatorProviderContext); // Assert Assert.Equal( new[] { validator1, validator2, validator3 }, validatorProviderContext.Validators.ToArray()); }
public void DefaultValues() { // Arrange var provider = new EmptyModelMetadataProvider(); var detailsProvider = new DefaultCompositeMetadataDetailsProvider( Enumerable.Empty<IMetadataDetailsProvider>()); var key = ModelMetadataIdentity.ForType(typeof(string)); var cache = new DefaultMetadataDetails(key, new ModelAttributes(new object[0])); // Act var metadata = new DefaultModelMetadata(provider, detailsProvider, cache); // Assert Assert.NotNull(metadata.AdditionalValues); Assert.Empty(metadata.AdditionalValues); Assert.Equal(typeof(string), metadata.ModelType); Assert.True(metadata.ConvertEmptyStringToNull); Assert.False(metadata.HasNonDefaultEditFormat); Assert.False(metadata.HideSurroundingHtml); Assert.True(metadata.HtmlEncode); Assert.False(metadata.IsBindingRequired); Assert.False(metadata.IsComplexType); Assert.False(metadata.IsCollectionType); Assert.False(metadata.IsEnum); Assert.False(metadata.IsFlagsEnum); Assert.False(metadata.IsNullableValueType); Assert.False(metadata.IsReadOnly); Assert.False(metadata.IsRequired); Assert.True(metadata.ShowForDisplay); Assert.True(metadata.ShowForEdit); Assert.Null(metadata.DataTypeName); Assert.Null(metadata.Description); Assert.Null(metadata.DisplayFormatString); Assert.Null(metadata.DisplayName); Assert.Null(metadata.EditFormatString); Assert.Null(metadata.EnumDisplayNamesAndValues); Assert.Null(metadata.EnumNamesAndValues); Assert.Null(metadata.NullDisplayText); Assert.Null(metadata.TemplateHint); Assert.Null(metadata.SimpleDisplayProperty); Assert.Equal(10000, ModelMetadata.DefaultOrder); Assert.Equal(ModelMetadata.DefaultOrder, metadata.Order); Assert.Null(metadata.BinderModelName); Assert.Null(metadata.BinderType); Assert.Null(metadata.BindingSource); Assert.Null(metadata.PropertyBindingPredicateProvider); }
private static DefaultModelBindingContext GetBindingContext(Type modelType, HttpContext httpContext) { var metadataProvider = new EmptyModelMetadataProvider(); var bindingContext = new DefaultModelBindingContext { ActionContext = new ActionContext() { HttpContext = httpContext, }, ModelMetadata = metadataProvider.GetMetadataForType(modelType), ModelName = "file", ValidationState = new ValidationStateDictionary(), }; return bindingContext; }
private static DefaultModelBindingContext GetBindingContext(Type modelType) { var metadataProvider = new EmptyModelMetadataProvider(); DefaultModelBindingContext bindingContext = new DefaultModelBindingContext { ActionContext = new ActionContext() { HttpContext = new DefaultHttpContext(), }, ModelMetadata = metadataProvider.GetMetadataForType(modelType), ModelName = "someName", ValueProvider = new SimpleValueProvider(), ValidationState = new ValidationStateDictionary(), }; return bindingContext; }
public void CreateMetadataForType() { // Arrange var provider = new EmptyModelMetadataProvider(); var detailsProvider = new DefaultCompositeMetadataDetailsProvider( Enumerable.Empty<IMetadataDetailsProvider>()); var key = ModelMetadataIdentity.ForType(typeof(Exception)); var cache = new DefaultMetadataDetailsCache(key, new object[0]); // Act var metadata = new DefaultModelMetadata(provider, detailsProvider, cache); // Assert Assert.Equal(typeof(Exception), metadata.ModelType); Assert.Null(metadata.PropertyName); Assert.Null(metadata.ContainerType); }
private static ModelBindingContext GetBindingContext(Type modelType) { var metadataProvider = new EmptyModelMetadataProvider(); ModelBindingContext bindingContext = new ModelBindingContext { ModelMetadata = metadataProvider.GetMetadataForType(modelType), ModelName = "someName", ValueProvider = new SimpleHttpValueProvider(), OperationBindingContext = new OperationBindingContext { ModelBinder = new CancellationTokenModelBinder(), MetadataProvider = metadataProvider, HttpContext = new DefaultHttpContext(), } }; return bindingContext; }
public void GenerateErrorMessage_ErrorMessageOnContextAndModelStateUsesContextError_ReturnsContent() { // Arrange var tagHelperContext = new TagHelperContext( tagName: "test", allAttributes: new TagHelperAttributeList(), items: new Dictionary <object, object>(), uniqueId: "test"); var formGroupContext = new TestFormGroupContext(); formGroupContext.SetErrorMessage(visuallyHiddenText: "vht", attributes: null, content: new HtmlString("Context error")); var modelExplorer = new EmptyModelMetadataProvider().GetModelExplorerForType(typeof(Model), new Model()) .GetExplorerForProperty(nameof(Model.SimpleProperty)); var viewContext = new ViewContext(); var modelExpression = nameof(Model.SimpleProperty); var modelHelper = new Mock <IModelHelper>(); modelHelper.Setup(mock => mock.GetValidationMessage(viewContext, modelExplorer, modelExpression)).Returns("ModelState error"); var tagHelper = new TestFormGroupTagHelper(new ComponentGenerator(), modelHelper.Object) { AspFor = new ModelExpression(modelExpression, modelExplorer), Id = "test", ViewContext = viewContext }; // Act var errorMessage = tagHelper.GenerateErrorMessage(tagHelperContext, formGroupContext); // Assert Assert.NotNull(errorMessage); Assert.Contains("Context error", errorMessage.RenderToString()); }
public override async Task OnExceptionAsync(ExceptionContext context) { var exception = context.Exception; string message = string.Empty; if (exception.InnerException != null) { message = exception.InnerException.Message; } else { message = exception.Message; } // log exception here.... var result = new ViewResult { ViewName = "SinjulMSBHError" }; var modelMetadata = new EmptyModelMetadataProvider(); result.ViewData = new ViewDataDictionary(modelMetadata, context.ModelState); result.ViewData.Add("Exception", message); context.Result = result; context.ExceptionHandled = true; }
public async Task ProcessAsync_ThrowsIfActionAndPageProvided() { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var anchorTagHelper = new AnchorTagHelper(htmlGenerator) { Action = "Action", Page = "Page", }; var output = new TagHelperOutput( "a", attributes: new TagHelperAttributeList(), getChildContentAsync: (useCachedResult, encoder) => Task.FromResult <TagHelperContent>(null)); var expectedErrorMessage = string.Join( Environment.NewLine, "Cannot determine the 'href' attribute for <a>. The following attributes are mutually exclusive:", "asp-route", "asp-controller, asp-action", "asp-page, asp-page-handler"); var context = new TagHelperContext( tagName: "test", allAttributes: new TagHelperAttributeList( Enumerable.Empty <TagHelperAttribute>()), items: new Dictionary <object, object>(), uniqueId: "test"); // Act & Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>( () => anchorTagHelper.ProcessAsync(context, output)); Assert.Equal(expectedErrorMessage, ex.Message); }
public async Task OnPostCreateLoanApplicationAsync_ReturnsAPageResult_WhenModelStateIsInValid() { // Arrange var authorizationService = new Mock <IAuthorizationService>(); authorizationService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <IEnumerable <IAuthorizationRequirement> >())) .ReturnsAsync(AuthorizationResult.Success()); var store = new Mock <IUserStore <IdentityUser> >(); var mgr = new Mock <UserManager <IdentityUser> >(store.Object, null, null, null, null, null, null, null, null); var httpContext = new DefaultHttpContext(); var modelState = new ModelStateDictionary(); var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState); var modelMetadataProvider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary(modelMetadataProvider, modelState); var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()); var pageContext = new PageContext(actionContext) { ViewData = viewData }; var pageModel = new CreateModel(AppDbContext, authorizationService.Object, mgr.Object) { PageContext = pageContext, TempData = tempData, Url = new UrlHelper(actionContext), LoanApplication = new LoanApplication() }; pageModel.ModelState.AddModelError("LoanApplication.Purpose", "Loan purpose is required."); // Act var result = await pageModel.OnPostAsync(); // Assert Assert.IsType <PageResult>(result); }
public void OnPost_ReturnsPageResult_WhenModelStateIsInvalid() { // Arrange var mockRegionsRepo = new Mock <IRegionsRepository>(); var mockWeatherRepo = new Mock <IWeatherRepository>(); var expectedRegions = new RegionsRepository().GetRegionsSelectList(); mockRegionsRepo.Setup(x => x.GetRegionsSelectList()).Returns(expectedRegions); var httpContext = new DefaultHttpContext(); var modelState = new ModelStateDictionary(); var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState); var modelMetadataProvider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary(modelMetadataProvider, modelState); var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()); var pageContext = new PageContext(actionContext) { ViewData = viewData }; var pageModel = new IndexModel(mockRegionsRepo.Object, mockWeatherRepo.Object) { PageContext = pageContext, TempData = tempData, Url = new UrlHelper(actionContext) }; pageModel.ModelState.AddModelError("ZipCode.Text", "The Text field is required."); // Act var result = pageModel.OnPost(); // Assert var pageResult = result as PageResult; Assert.IsNotNull(pageResult, "OnPost returns Null PageResult when Model State is Invalid"); Assert.IsNull(pageModel.WeatherInfo, "OnPost returns NON-Null WeatherInfo when Model State is Invalid"); }
public async Task JsonFormatterReadsSimpleTypes(string content, Type type, object expected) { // Arrange var logger = GetLogger(); var formatter = new JsonInputFormatter(logger); var contentBytes = Encoding.UTF8.GetBytes(content); var httpContext = GetHttpContext(contentBytes); var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForType(type); var context = new InputFormatterContext( httpContext, modelName: string.Empty, modelState: new ModelStateDictionary(), metadata: metadata, readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader); // Act var result = await formatter.ReadAsync(context); // Assert Assert.False(result.HasError); Assert.Equal(expected, result.Model); }
public void GetModelValidator_DoesNotReadPropertyValues() { ModelValidatorProvider[] originalProviders = ModelValidatorProviders.Providers.ToArray(); try { // Arrange ModelValidatorProviders.Providers.Clear(); ModelValidatorProviders.Providers.Add(new ObservableModelValidatorProvider()); ObservableModel model = new ObservableModel(); ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType( () => model, typeof(ObservableModel) ); ControllerContext controllerContext = new ControllerContext(); // Act ModelValidator validator = ModelValidator.GetModelValidator( metadata, controllerContext ); ModelValidationResult[] results = validator.Validate(model).ToArray(); // Assert Assert.False(model.PropertyWasRead()); } finally { ModelValidatorProviders.Providers.Clear(); foreach (ModelValidatorProvider provider in originalProviders) { ModelValidatorProviders.Providers.Add(provider); } } }
public void GenerateHint_HintOnContextAndModelMetadataDescriptionUsesContextHint_ReturnsContent() { // Arrange var formGroupContext = new TestFormGroupContext(); formGroupContext.SetHint(attributes: null, content: new HtmlString("Context hint")); var tagHelperContext = new TagHelperContext( tagName: "test", allAttributes: new TagHelperAttributeList(), items: new Dictionary <object, object>(), uniqueId: "test"); var modelExplorer = new EmptyModelMetadataProvider().GetModelExplorerForType(typeof(Model), new Model()) .GetExplorerForProperty(nameof(Model.SimpleProperty)); var viewContext = new ViewContext(); var modelExpression = nameof(Model.SimpleProperty); var modelHelper = new Mock <IModelHelper>(); modelHelper.Setup(mock => mock.GetDescription(modelExplorer)).Returns("ModelState hint"); var tagHelper = new TestFormGroupTagHelper(new ComponentGenerator(), modelHelper.Object) { AspFor = new ModelExpression(modelExpression, modelExplorer), Id = "test", ViewContext = viewContext }; // Act var hint = tagHelper.GenerateHint(tagHelperContext, formGroupContext); // Assert Assert.NotNull(hint); Assert.Contains("Context hint", hint.RenderToString()); }
public void ModelSetter_DifferentType_UpdatesModelMetadata(Type originalMetadataType) { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var metadata = metadataProvider.GetMetadataForType(originalMetadataType); var explorer = new ModelExplorer(metadataProvider, metadata, model: null); var viewData = new TestViewDataDictionary(metadataProvider) { ModelExplorer = explorer, }; // Act viewData.Model = true; // Assert Assert.NotNull(viewData.ModelExplorer); Assert.NotNull(viewData.ModelMetadata); Assert.NotSame(explorer, viewData.ModelExplorer); Assert.Equal(typeof(bool), viewData.ModelMetadata.ModelType); var model = Assert.IsType <bool>(viewData.Model); Assert.True(model); }
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState() { // Arrange var content = "{name: 'Person Name', Age: 'not-an-age'}"; var formatter = new JsonInputFormatter(); var contentBytes = Encoding.UTF8.GetBytes(content); var actionContext = GetActionContext(contentBytes); var metadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(User)); var context = new InputFormatterContext(actionContext, metadata.ModelType); actionContext.ModelState.MaxAllowedErrors = 3; actionContext.ModelState.AddModelError("key1", "error1"); actionContext.ModelState.AddModelError("key2", "error2"); // Act var model = await formatter.ReadAsync(context); // Assert Assert.False(actionContext.ModelState.ContainsKey("age")); var error = Assert.Single(actionContext.ModelState[""].Errors); Assert.IsType <TooManyModelErrorsException>(error.Exception); }
public async Task OnPostAsync_ReturnsAPageResult_WhenModelStateIsInvalid(int resourceId) { // Arrange var optionsBuilder = new DbContextOptionsBuilder <ClippyContext>() .UseInMemoryDatabase("InMemoryDb"); var mockContext = new Mock <ClippyContext>(optionsBuilder.Options); var expectedResource = DatabaseInitializer.GetSeedingResources().Single(r => r.Id == resourceId); mockContext.Setup(db => db.GetResourceAsync(resourceId)).Returns(Task.FromResult(expectedResource)); var httpContext = new DefaultHttpContext(); var modelState = new ModelStateDictionary(); var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState); var modelMetadataProvider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary(modelMetadataProvider, modelState); var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()); var pageContext = new PageContext(actionContext) { ViewData = viewData }; var pageModel = new EditModel(mockContext.Object) { PageContext = pageContext, TempData = tempData, Url = new UrlHelper(actionContext) }; pageModel.ModelState.AddModelError("Title", "Title is required."); // Act var result = await pageModel.OnPostAsync(resourceId); // Assert Assert.IsType <PageResult>(result); }
public async Task BindModelAsync_ReturnsNullWhenResponseCannotBeFound() { // Arrange var binder = new OpenIddictModelBinder(); var provider = new EmptyModelMetadataProvider(); var context = new DefaultModelBindingContext { ActionContext = new ActionContext() { HttpContext = new DefaultHttpContext(), }, ModelMetadata = provider.GetMetadataForType(typeof(OpenIdConnectResponse)), ValidationState = new ValidationStateDictionary() }; // Act await binder.BindModelAsync(context); // Assert Assert.True(context.Result.IsModelSet); Assert.Null(context.Result.Model); }
public void Validate_SkipsRemainingValidationIfModelStateIsInvalid() { // Because a property validator fails, the model validator shouldn't run // Arrange List <string> log = new List <string>(); LoggingDataErrorInfoModel model = new LoggingDataErrorInfoModel(log); ModelMetadata modelMetadata = GetModelMetadata(model); ControllerContext controllerContext = new ControllerContext() { Controller = new EmptyController() }; ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey"); ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(() => model, model.GetType(), "InvalidStringProperty"); node.ChildNodes.Add(new ModelValidationNode(childMetadata, "theKey.InvalidStringProperty")); node.Validating += delegate { log.Add("In OnValidating()"); }; node.Validated += delegate { log.Add("In OnValidated()"); }; // Act node.Validate(controllerContext); // Assert CollectionAssert.AreEqual( new string[] { "In OnValidating()", "In IDataErrorInfo.get_Item('InvalidStringProperty')", "In OnValidated()" }, log); Assert.AreEqual("Sample error message", controllerContext.Controller.ViewData.ModelState["theKey.InvalidStringProperty"].Errors[0].ErrorMessage); }
private static ModelBindingContext GetBindingContext( IValueProvider valueProvider, IModelBinder innerBinder = null, Type keyValuePairType = null) { var metataProvider = new EmptyModelMetadataProvider(); var bindingContext = new ModelBindingContext { ModelMetadata = metataProvider.GetMetadataForType(keyValuePairType ?? typeof(KeyValuePair <int, string>)), ModelName = "someName", ModelState = new ModelStateDictionary(), ValueProvider = valueProvider, OperationBindingContext = new OperationBindingContext { ModelBinder = innerBinder ?? CreateIntBinder(), MetadataProvider = metataProvider, ValidatorProvider = new DataAnnotationsModelValidatorProvider( new TestOptionsManager <MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null) } }; return(bindingContext); }
public async Task CustomSerializerSettingsObject_TakesEffect() { // Arrange // missing password property here var contentBytes = Encoding.UTF8.GetBytes("{ \"UserName\" : \"John\"}"); var logger = GetLogger(); // by default we ignore missing members, so here explicitly changing it var serializerSettings = new JsonSerializerSettings { MissingMemberHandling = MissingMemberHandling.Error }; var jsonFormatter = new JsonInputFormatter(logger, serializerSettings, ArrayPool <char> .Shared, _objectPoolProvider); var modelState = new ModelStateDictionary(); var httpContext = GetHttpContext(contentBytes, "application/json;charset=utf-8"); var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForType(typeof(UserLogin)); var inputFormatterContext = new InputFormatterContext( httpContext, modelName: string.Empty, modelState: modelState, metadata: metadata, readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader); // Act var result = await jsonFormatter.ReadAsync(inputFormatterContext); // Assert Assert.True(result.HasError); Assert.False(modelState.IsValid); var modelErrorMessage = modelState.Values.First().Errors[0].ErrorMessage; Assert.Contains("Required property 'Password' not found in JSON", modelErrorMessage); }
// Adds one or more errors for all properties in OrderedModel. But adds errors out of order. private void AddOrderedErrors(ModelStateDictionary modelState) { var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForProperty(typeof(OrderedModel), nameof(OrderedModel.Property3)); modelState.AddModelError("Property3", "This is an error for Property3."); modelState.AddModelError("Property3", new InvalidCastException("An ignored Exception."), metadata); modelState.AddModelError("Property2", "This is an error for Property2."); modelState.AddModelError("Property2", "This is another error for Property2."); modelState.AddModelError("OrderedProperty3", "This is an error for OrderedProperty3."); modelState.AddModelError("OrderedProperty2", "This is an error for OrderedProperty2."); modelState.AddModelError("OrderedProperty2", "This is another error for OrderedProperty2."); modelState.AddModelError("LastProperty", "This is an error for LastProperty."); modelState.AddModelError("Property1", "This is an error for Property1."); modelState.AddModelError("Property1", "This is another error for Property1."); modelState.AddModelError("OrderedProperty1", "This is an error for OrderedProperty1."); modelState.AddModelError("OrderedProperty2", "This is yet-another error for OrderedProperty2."); }
public async Task BindModelAsync_DoesNotTrimValue() { ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForProperty(typeof(AllTypesView), nameof(AllTypesView.StringField)); DefaultModelBindingContext context = new DefaultModelBindingContext(); NotTrimmedAttribute attribute = new NotTrimmedAttribute(); context.ModelMetadata = metadata; context.ActionContext = new ActionContext(); context.ModelState = new ModelStateDictionary(); context.ModelName = nameof(AllTypesView.StringField); context.ValueProvider = Substitute.For <IValueProvider>(); context.ActionContext.HttpContext = new DefaultHttpContext(); context.HttpContext.RequestServices = Substitute.For <IServiceProvider>(); context.ValueProvider.GetValue(context.ModelName).Returns(ValueProviderResult.None); context.ValueProvider.GetValue(nameof(AllTypesView.StringField)).Returns(new ValueProviderResult(" Value ")); context.HttpContext.RequestServices.GetService(typeof(ILoggerFactory)).Returns(Substitute.For <ILoggerFactory>()); await attribute.BindModelAsync(context); ModelBindingResult expected = ModelBindingResult.Success(" Value "); ModelBindingResult actual = context.Result; Assert.Equal(expected, actual); }
// Adds errors for various parts of the model, including the root. private void AddMultipleErrors(ModelStateDictionary modelState) { modelState.AddModelError("Property3.Property2", "This is an error for Property3.Property2."); modelState.AddModelError("Property3.OrderedProperty3", "This is an error for Property3.OrderedProperty3."); modelState.AddModelError("Property3.OrderedProperty2", "This is an error for Property3.OrderedProperty2."); modelState.SetModelValue("Property3.Empty", rawValue: null, attemptedValue: null); modelState.MarkFieldValid("Property3.Empty"); var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForProperty(typeof(ValidationModel), nameof(ValidationModel.Property3)); modelState.AddModelError("Property3", "This is an error for Property3."); modelState.AddModelError("Property3", new InvalidCastException("Exception will be ignored."), metadata); metadata = provider.GetMetadataForProperty(typeof(ValidationModel), nameof(ValidationModel.Property2)); modelState.AddModelError("Property2", "This is an error for Property2."); modelState.AddModelError("Property2", "This is another error for Property2."); modelState.AddModelError("Property2", new OverflowException("Produces invalid value message"), metadata); metadata = provider.GetMetadataForType(typeof(ValidationModel)); modelState.AddModelError(string.Empty, "This is an error for the model root."); modelState.AddModelError(string.Empty, "This is another error for the model root."); modelState.AddModelError(string.Empty, new InvalidOperationException("Another ignored Exception."), metadata); }
public void CopyConstructorUsesPassedInModel() { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var model = new TestModel(); var source = new ViewDataDictionary(metadataProvider) { Model = "string model" }; source["key1"] = "value1"; // Act var viewData = new ViewDataDictionary(source, model); // Assert Assert.NotNull(viewData.ModelState); Assert.NotNull(viewData.TemplateInfo); Assert.Same(model, viewData.Model); Assert.NotNull(viewData.ModelMetadata); Assert.Equal(typeof(TestModel), viewData.ModelMetadata.ModelType); Assert.Equal("value1", viewData["key1"]); Assert.IsType <CopyOnWriteDictionary <string, object> >(viewData.Data); }
public void Properties_UsesRuntimeType() { // Arrange var provider = new EmptyModelMetadataProvider(); var modelExplorer = provider.GetModelExplorerForType(typeof(BaseClass), new DerivedClass()); // Act var properties = modelExplorer.Properties.ToArray(); // Assert Assert.Equal(2, properties.Length); var baseProperty = Assert.Single(properties, p => p.Metadata.PropertyName == "Base1"); Assert.Equal(typeof(int), baseProperty.Metadata.ModelType); Assert.Equal(typeof(DerivedClass), baseProperty.Metadata.ContainerType); Assert.Same(modelExplorer, baseProperty.Container); var derivedProperty = Assert.Single(properties, p => p.Metadata.PropertyName == "Derived1"); Assert.Equal(typeof(string), derivedProperty.Metadata.ModelType); Assert.Equal(typeof(DerivedClass), derivedProperty.Metadata.ContainerType); Assert.Same(modelExplorer, derivedProperty.Container); }
public async Task ProcessAsync_ThrowsIfRouteAndActionOrControllerProvided(string propertyName) { // Arrange var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var anchorTagHelper = new AnchorTagHelper(htmlGenerator) { Route = "Default", }; typeof(AnchorTagHelper).GetProperty(propertyName).SetValue(anchorTagHelper, "Home"); var output = new TagHelperOutput( "a", attributes: new TagHelperAttributeList()); var expectedErrorMessage = "Cannot determine an 'href' attribute for <a>. An <a> with a specified " + "'asp-route' must not have an 'asp-action' or 'asp-controller' attribute."; // Act & Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>( () => anchorTagHelper.ProcessAsync(context: null, output: output)); Assert.Equal(expectedErrorMessage, ex.Message); }
public async Task ReadAsync_AcceptsUTF16Characters() { // Arrange var expectedInt = 10; var expectedString = "TestString"; var input = "<?xml version=\"1.0\" encoding=\"UTF-16\"?>" + "<TestLevelOne><SampleInt>" + expectedInt + "</SampleInt>" + "<sampleString>" + expectedString + "</sampleString></TestLevelOne>"; var formatter = new XmlDataContractSerializerInputFormatter(new MvcOptions()); var contentBytes = Encoding.Unicode.GetBytes(input); var modelState = new ModelStateDictionary(); var httpContext = GetHttpContext(contentBytes, contentType: "application/xml; charset=utf-16"); var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForType(typeof(TestLevelOne)); var context = new InputFormatterContext( httpContext, modelName: string.Empty, modelState: modelState, metadata: metadata, readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader); // Act var result = await formatter.ReadAsync(context); // Assert Assert.NotNull(result); Assert.False(result.HasError); var model = Assert.IsType <TestLevelOne>(result.Model); Assert.Equal(expectedInt, model.SampleInt); Assert.Equal(expectedString, model.sampleString); }
public void Constructor_SerializesErrorsFromModelStateDictionary_AddsDefaultMessage() { // Arrange var modelStateDictionary = new ModelStateDictionary(); var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length)); modelStateDictionary.AddModelError("unsafeError", new Exception("This message should not be returned to clients"), metadata); // Act var problemDescription = new ValidationProblemDetails(modelStateDictionary); // Assert Assert.Equal("One or more validation errors occurred.", problemDescription.Title); Assert.Collection( problemDescription.Errors, item => { Assert.Equal("unsafeError", item.Key); Assert.Equal(new[] { "The input was not valid." }, item.Value); }); }
public override void OnException(ExceptionContext context) { _logger.LogError(default(int), context.Exception, context.Exception.Message); var result = new ViewResult { ViewName = "~/Views/Home/Error.cshtml" }; var modelMetadata = new EmptyModelMetadataProvider(); result.ViewData = new ViewDataDictionary( modelMetadata, context.ModelState) { { "Exception", context.Exception } }; result.ViewData.Model = new ErrorViewModel { RequestId = Activity.Current?.Id ?? context.HttpContext.TraceIdentifier }; result.StatusCode = (int)HttpStatusCode.InternalServerError; context.Result = result; context.ExceptionHandled = true; }
public void CanRead_ReturnsTrueForAnySupportedContentType(string requestContentType, bool expectedCanRead) { // Arrange var formatter = new XmlSerializerInputFormatter(); var contentBytes = Encoding.UTF8.GetBytes("content"); var modelState = new ModelStateDictionary(); var httpContext = GetHttpContext(contentBytes, contentType: requestContentType); var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForType(typeof(string)); var formatterContext = new InputFormatterContext( httpContext, modelName: string.Empty, modelState: modelState, metadata: metadata, readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader); // Act var result = formatter.CanRead(formatterContext); // Assert Assert.Equal(expectedCanRead, result); }
public void DropDownListFor_NullSelectListFindsListFromViewData() { // Arrange var expectedHtml = "<select id=\"HtmlEncode[[Property1]]\" name=\"HtmlEncode[[Property1]]\">" + "<option selected=\"HtmlEncode[[selected]]\" value=\"HtmlEncode[[0]]\">HtmlEncode[[Zero]]</option>" + Environment.NewLine + "<option value=\"HtmlEncode[[1]]\">HtmlEncode[[One]]</option>" + Environment.NewLine + "<option value=\"HtmlEncode[[2]]\">HtmlEncode[[Two]]</option>" + Environment.NewLine + "<option value=\"HtmlEncode[[3]]\">HtmlEncode[[Three]]</option>" + Environment.NewLine + "</select>"; var metadataProvider = new EmptyModelMetadataProvider(); var helper = DefaultTemplatesUtilities.GetHtmlHelper(new ViewDataDictionary <TestModel>(metadataProvider)); helper.ViewContext.ClientValidationEnabled = false; helper.ViewData["Property1"] = BasicSelectList; helper.ViewData.Model = new TestModel { Property1 = 0 }; // Act var dropDownListForResult = helper.DropDownListFor(m => m.Property1, selectList: null); // Assert Assert.Equal(expectedHtml, HtmlContentUtilities.HtmlContentToString(dropDownListForResult)); }
private static ModelBindingContext GetBindingContext(IValueProvider valueProvider, IModelBinder innerBinder = null) { var metataProvider = new EmptyModelMetadataProvider(); var bindingContext = new ModelBindingContext { ModelMetadata = metataProvider.GetMetadataForType(null, typeof(KeyValuePair<int, string>)), ModelName = "someName", ValueProvider = valueProvider, ModelBinder = innerBinder ?? CreateIntBinder(), MetadataProvider = metataProvider, ValidatorProviders = Enumerable.Empty<IModelValidatorProvider>() }; return bindingContext; }
public void CreateMetadataForProperty() { // Arrange var provider = new EmptyModelMetadataProvider(); var detailsProvider = new EmptyCompositeMetadataDetailsProvider(); var key = ModelMetadataIdentity.ForProperty(typeof(string), "Message", typeof(Exception)); var cache = new DefaultMetadataDetailsCache(key, new object[0]); // Act var metadata = new DefaultModelMetadata(provider, detailsProvider, cache); // Assert Assert.Equal(typeof(string), metadata.ModelType); Assert.Equal("Message", metadata.PropertyName); Assert.Equal(typeof(Exception), metadata.ContainerType); }
private static DefaultModelBindingContext GetBindingContext( Type modelType, IEnumerable<IInputFormatter> inputFormatters = null, HttpContext httpContext = null, IModelMetadataProvider metadataProvider = null) { if (httpContext == null) { httpContext = new DefaultHttpContext(); } if (inputFormatters == null) { inputFormatters = Enumerable.Empty<IInputFormatter>(); } if (metadataProvider == null) { metadataProvider = new EmptyModelMetadataProvider(); } var operationBindingContext = new OperationBindingContext { ActionContext = new ActionContext() { HttpContext = httpContext, }, InputFormatters = inputFormatters.ToList(), MetadataProvider = metadataProvider, }; var bindingContext = new DefaultModelBindingContext { FieldName = "someField", IsTopLevelObject = true, ModelMetadata = metadataProvider.GetMetadataForType(modelType), ModelName = "someName", ValueProvider = Mock.Of<IValueProvider>(), ModelState = new ModelStateDictionary(), OperationBindingContext = operationBindingContext, BindingSource = BindingSource.Body, }; return bindingContext; }
public void PropertiesEnumerationEvaluatedOnce() { // Arrange var provider = new EmptyModelMetadataProvider(); var detailsProvider = new EmptyCompositeMetadataDetailsProvider(); var key = ModelMetadataIdentity.ForType(typeof(string)); var cache = new DefaultMetadataDetailsCache(key, new object[0]); var metadata = new DefaultModelMetadata(provider, detailsProvider, cache); // Act var firstPropertiesEvaluation = metadata.Properties.ToList(); var secondPropertiesEvaluation = metadata.Properties.ToList(); // Assert // Identical ModelMetadata objects every time we run through the Properties collection. Assert.Equal(firstPropertiesEvaluation, secondPropertiesEvaluation); }
public async Task ProcessAsync_DoesNotUseGenerator_IfSelectedNullOrNoSelectedValues( string originalContent, string selected, string value, ICollection <string> currentValues, TagHelperOutput _) { // Arrange var originalAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, }; var originalTagName = "not-option"; var contextAttributes = new TagHelperAttributeList { { "label", "my-label" }, { "selected", selected }, { "value", value }, }; var originalPreContent = "original pre-content"; var originalPostContent = "original post-content"; var tagHelperContext = new TagHelperContext( tagName: "option", allAttributes: contextAttributes, items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( originalTagName, originalAttributes, getChildContentAsync: (useCachedResult, encoder) => { var tagHelperContent = new DefaultTagHelperContent(); tagHelperContent.SetContent(originalContent); return(Task.FromResult <TagHelperContent>(tagHelperContent)); }) { TagMode = TagMode.StartTagAndEndTag, }; output.PreContent.SetContent(originalPreContent); output.Content.SetContent(originalContent); output.PostContent.SetContent(originalPostContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); tagHelperContext.Items[typeof(SelectTagHelper)] = currentValues == null ? null : new CurrentValues(currentValues); var tagHelper = new OptionTagHelper(htmlGenerator) { Value = value, ViewContext = viewContext, }; // Act & Assert (does not throw) // Tag helper would throw an NRE if it used Generator value. await tagHelper.ProcessAsync(tagHelperContext, output); }
private static ModelBindingContext GetBindingContext(IValueProvider valueProvider, Type modelType) { var metadataProvider = new EmptyModelMetadataProvider(); var bindingContext = new ModelBindingContext { ModelMetadata = metadataProvider.GetMetadataForType(modelType), ModelName = "foo", ModelState = new ModelStateDictionary(), ValueProvider = valueProvider, OperationBindingContext = new OperationBindingContext { MetadataProvider = metadataProvider, } }; return bindingContext; }
public void GetMetadataForPropertiesContainerTest() { // Arrange PropertyModel model = new PropertyModel { LocalAttributes = 42, MetadataAttributes = "hello", MixedAttributes = 21.12 }; EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider(); // Act List<ModelMetadata> metadata = provider.GetMetadataForProperties(model, typeof(PropertyModel)).ToList(); // Assert Assert.Equal(3, metadata.Count()); Assert.Same(model, metadata[0].Container); Assert.Same(model, metadata[1].Container); Assert.Same(model, metadata[2].Container); }
private static DefaultModelBindingContext GetBindingContext( Type modelType, HttpContext httpContext = null, IModelMetadataProvider metadataProvider = null) { if (httpContext == null) { httpContext = new DefaultHttpContext(); } if (metadataProvider == null) { metadataProvider = new EmptyModelMetadataProvider(); } var bindingContext = new DefaultModelBindingContext { ActionContext = new ActionContext() { HttpContext = httpContext, }, FieldName = "someField", IsTopLevelObject = true, ModelMetadata = metadataProvider.GetMetadataForType(modelType), ModelName = "someName", ValueProvider = Mock.Of<IValueProvider>(), ModelState = new ModelStateDictionary(), BindingSource = BindingSource.Body, }; return bindingContext; }
private static ModelBindingContext GetBindingContext( IValueProvider valueProvider, IModelBinder innerBinder = null, Type keyValuePairType = null) { var metataProvider = new EmptyModelMetadataProvider(); var bindingContext = new ModelBindingContext { ModelMetadata = metataProvider.GetMetadataForType(keyValuePairType ?? typeof(KeyValuePair<int, string>)), ModelName = "someName", ValueProvider = valueProvider, OperationBindingContext = new OperationBindingContext { ModelBinder = innerBinder ?? CreateIntBinder(), MetadataProvider = metataProvider, ValidatorProvider = new DataAnnotationsModelValidatorProvider() } }; return bindingContext; }
private static ModelBindingContext GetBindingContext(IValueProvider valueProvider) { var metadataProvider = new EmptyModelMetadataProvider(); ModelBindingContext bindingContext = new ModelBindingContext { ModelMetadata = metadataProvider.GetMetadataForType(null, typeof(int[])), ModelName = "someName", ValueProvider = valueProvider, ModelBinder = CreateIntBinder(), MetadataProvider = metadataProvider }; return bindingContext; }
private static ModelBindingContext GetModelBindingContext(IValueProvider valueProvider) { var metadataProvider = new EmptyModelMetadataProvider(); var bindingContext = new ModelBindingContext { ModelMetadata = metadataProvider.GetMetadataForType(typeof(int)), ModelName = "someName", ValueProvider = valueProvider, OperationBindingContext = new OperationBindingContext { ModelBinder = CreateIntBinder(), MetadataProvider = metadataProvider } }; return bindingContext; }
public void SimpleDisplayTextReturnsFirstPropertyValueForNonNullModel() { // Arrange SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString { FirstProperty = "First Property Value" }; EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null); // Act string result = metadata.SimpleDisplayText; // Assert Assert.Equal(model.FirstProperty, result); }
private static ModelMetadata GetMetadata() { ModelMetadataProvider provider = new EmptyModelMetadataProvider(); return provider.GetMetadataForType(null, typeof(object)); }
public void SimpleDisplayTextReturnsEmptyStringForNonNullModelWithNoVisibleProperties() { // Arrange SimpleDisplayTextModelWithNoProperties model = new SimpleDisplayTextModelWithNoProperties(); EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithNoProperties), null); // Act string result = metadata.SimpleDisplayText; // Assert Assert.Equal(String.Empty, result); }
public void AddValidation_ExistingInteger() { IModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = provider.GetMetadataForType(typeof(Int64)); Dictionary <String, String> attributes = new() { ["data-val-integer"] = "Test" };
private static ModelValidationNode GetValidationNode() { var provider = new EmptyModelMetadataProvider(); var metadata = provider.GetMetadataForType(null, typeof(object)); return new ModelValidationNode(metadata, "someKey"); }
public void SimpleDisplayTextReturnsToStringValueWhenOverridden() { // Arrange SimpleDisplayTextModelWithToString model = new SimpleDisplayTextModelWithToString(); EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider(); ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithToString), null); // Act string result = metadata.SimpleDisplayText; // Assert Assert.Equal(model.ToString(), result); }
public void CreateMetadataForParameter() { // Arrange var provider = new EmptyModelMetadataProvider(); var detailsProvider = new EmptyCompositeMetadataDetailsProvider(); var methodInfo = GetType().GetMethod( "ActionMethod", BindingFlags.Instance | BindingFlags.NonPublic); var parameterInfo = methodInfo.GetParameters().Where(p => p.Name == "input").Single(); var key = ModelMetadataIdentity.ForParameter(parameterInfo); var cache = new DefaultMetadataDetailsCache(key, new object[0]); // Act var metadata = new DefaultModelMetadata(provider, detailsProvider, cache); Assert.Equal(typeof(string), metadata.ModelType); Assert.Equal("input", metadata.PropertyName); Assert.Null(metadata.ContainerType); }
public void SimpleDisplayTextReturnsFirstPropertyNullDisplayTextForNonNullModelWithNullDisplayColumnPropertyValue() { // Arrange SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString(); EmptyModelMetadataProvider propertyProvider = new EmptyModelMetadataProvider(); ModelMetadata propertyMetadata = propertyProvider.GetMetadataForProperty(() => model.FirstProperty, typeof(SimpleDisplayTextModelWithoutToString), "FirstProperty"); propertyMetadata.NullDisplayText = "Null Display Text"; Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>(); provider.Setup(p => p.GetMetadataForProperties(model, typeof(SimpleDisplayTextModelWithoutToString))) .Returns(new[] { propertyMetadata }); ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null); // Act string result = metadata.SimpleDisplayText; // Assert Assert.Equal(propertyMetadata.NullDisplayText, result); }
public void IsRequired_ReturnsTrue_ForNonNullableTypes(Type modelType) { // Arrange var provider = new EmptyModelMetadataProvider(); var detailsProvider = new EmptyCompositeMetadataDetailsProvider(); var key = ModelMetadataIdentity.ForType(modelType); var cache = new DefaultMetadataDetailsCache(key, new object[0]); var metadata = new DefaultModelMetadata(provider, detailsProvider, cache); // Act var isRequired = metadata.IsRequired; // Assert Assert.True(isRequired); }
public async Task ProcessAsync_GeneratesExpectedOutput( string originalContent, string selected, string value, ICollection <string> currentValues, TagHelperOutput expectedTagHelperOutput) { // Arrange var originalAttributes = new TagHelperAttributeList { { "label", "my-label" }, }; if (selected != null) { originalAttributes.Add("selected", selected); } var contextAttributes = new TagHelperAttributeList(originalAttributes); if (value != null) { contextAttributes.Add("value", value); } var tagHelperContext = new TagHelperContext( tagName: "option", allAttributes: contextAttributes, items: new Dictionary <object, object>(), uniqueId: "test"); var output = new TagHelperOutput( expectedTagHelperOutput.TagName, originalAttributes, getChildContentAsync: (useCachedResult, encoder) => { // GetChildContentAsync should not be invoked since we are setting the content below. Assert.True(false); return(Task.FromResult <TagHelperContent>(null)); }) { TagMode = TagMode.StartTagAndEndTag }; output.Content.SetContent(originalContent); var metadataProvider = new EmptyModelMetadataProvider(); var htmlGenerator = new TestableHtmlGenerator(metadataProvider); var viewContext = TestableHtmlGenerator.GetViewContext( model: null, htmlGenerator: htmlGenerator, metadataProvider: metadataProvider); tagHelperContext.Items[typeof(SelectTagHelper)] = currentValues == null ? null : new CurrentValues(currentValues); var tagHelper = new OptionTagHelper(htmlGenerator) { Value = value, ViewContext = viewContext, }; // Act await tagHelper.ProcessAsync(tagHelperContext, output); // Assert Assert.Equal(expectedTagHelperOutput.TagName, output.TagName); Assert.Equal(expectedTagHelperOutput.Content.GetContent(), output.Content.GetContent()); Assert.Equal(expectedTagHelperOutput.Attributes.Count, output.Attributes.Count); foreach (var attribute in output.Attributes) { Assert.Contains(attribute, expectedTagHelperOutput.Attributes); } }
public void PropertiesSetOnce() { // Arrange var provider = new EmptyModelMetadataProvider(); var detailsProvider = new EmptyCompositeMetadataDetailsProvider(); var key = ModelMetadataIdentity.ForType(typeof(string)); var cache = new DefaultMetadataDetailsCache(key, new object[0]); var metadata = new DefaultModelMetadata(provider, detailsProvider, cache); // Act var firstPropertiesEvaluation = metadata.Properties; var secondPropertiesEvaluation = metadata.Properties; // Assert // Same IEnumerable<ModelMetadata> object. Assert.Same(firstPropertiesEvaluation, secondPropertiesEvaluation); }
private static ModelMetadata GetMetadata() { ModelMetadataProvider provider = new EmptyModelMetadataProvider(); return(provider.GetMetadataForType(null, typeof(object))); }
private static ModelBindingContext GetBindingContext( IValueProvider valueProvider, IModelBinder innerBinder = null, Type keyValuePairType = null) { var metataProvider = new EmptyModelMetadataProvider(); var bindingContext = new ModelBindingContext { ModelMetadata = metataProvider.GetMetadataForType( keyValuePairType ?? typeof(KeyValuePair<int, string>)), ModelName = "someName", ModelState = new ModelStateDictionary(), ValueProvider = valueProvider, OperationBindingContext = new OperationBindingContext { ModelBinder = innerBinder ?? CreateIntBinder(), MetadataProvider = metataProvider, ValidatorProvider = new DataAnnotationsModelValidatorProvider( new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null) } }; return bindingContext; }