protected virtual IValidator CreateValidator(ModelValidatorProviderContext context) { if (IsValidatingProperty(context)) { return ValidatorFactory.GetValidator(context.ModelMetadata.ContainerType); } return ValidatorFactory.GetValidator(context.ModelMetadata.ModelType); }
public void GetValidators(ModelValidatorProviderContext context) { foreach (var validatorProvider in ValidatorProviders) { validatorProvider.GetValidators(context); } }
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 GetValidators(ModelValidatorProviderContext context) { foreach (var validatorProvider in ValidatorProviders) { validatorProvider.GetValidators(context); } }
private IList <IModelValidator> GetValidators(ModelMetadata metadata) { var context = new ModelValidatorProviderContext(metadata); _validatorProvider.GetValidators(context); return(context.Validators.OrderBy(v => v, ValidatorOrderComparer.Instance).ToList()); }
/// <inheritdoc /> public void GetValidators(ModelValidatorProviderContext context) { // Perf: Avoid allocations for (var i = 0; i < ValidatorProviders.Count; i++) { ValidatorProviders[i].GetValidators(context); } }
/// <inheritdoc /> public void GetValidators(ModelValidatorProviderContext context) { // Perf: Avoid allocations for (var i = 0; i < ValidatorProviders.Count; i++) { ValidatorProviders[i].GetValidators(context); } }
public void GetValidators(ModelValidatorProviderContext context) { IValidator validator = CreateValidator(context); if (! IsValidatingProperty(context)) { context.Validators.Add(new FluentValidationModelValidator(validator)); } }
public void GetValidators(ModelValidatorProviderContext context) { foreach (var attribute in context.ValidatorMetadata.OfType<ValidationAttribute>()) { context.Validators.Add(new DataAnnotationsModelValidator(attribute)); } // Produce a validator if the type supports IValidatableObject if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType)) { context.Validators.Add(new ValidatableObjectAdapter()); } }
public void GetValidators(ModelValidatorProviderContext context) { foreach (var attribute in context.ValidatorMetadata.OfType <ValidationAttribute>()) { context.Validators.Add(new DataAnnotationsModelValidator(attribute)); } // Produce a validator if the type supports IValidatableObject if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType)) { context.Validators.Add(new ValidatableObjectAdapter()); } }
public void IValidatableObjectGetsAValidator() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var mockValidatable = new Mock<IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.Object.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert Assert.Single(providerContext.Validators); }
public void UnknownValidationAttributeGetsDefaultAdapter() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var metadata = _metadataProvider.GetMetadataForType(typeof(DummyClassWithDummyValidationAttribute)); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = providerContext.Validators.Single(); Assert.IsType<DataAnnotationsModelValidator>(validator); }
public void IValidatableObjectGetsAValidator() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var mockValidatable = new Mock <IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.Object.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert Assert.Single(providerContext.Validators); }
public void GetValidators_ReturnsValidatorForIValidatableObject() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var mockValidatable = Mock.Of<IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = Assert.Single(providerContext.Validators); Assert.IsType<ValidatableObjectAdapter>(validator); }
public void UnknownValidationAttributeGetsDefaultAdapter() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var metadata = _metadataProvider.GetMetadataForType(typeof(DummyClassWithDummyValidationAttribute)); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = providerContext.Validators.Single(); Assert.IsType <DataAnnotationsModelValidator>(validator); }
public void GetValidators_DoesNotAddRequiredAttribute_ForNonNullableValueTypes_IfAttributeIsSpecifiedExplicitly() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var metadata = _metadataProvider.GetMetadataForProperty(typeof(DummyRequiredAttributeHelperClass), "WithAttribute"); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = Assert.Single(providerContext.Validators); var adapter = Assert.IsType<RequiredAttributeAdapter>(validator); Assert.Equal("Custom Required Message", adapter.Attribute.ErrorMessage); }
private bool ValidateElements(string currentKey, IEnumerable model, ValidationContext validationContext) { var elementType = GetElementType(model.GetType()); var elementMetadata = _modelMetadataProvider.GetMetadataForType(elementType); var validatorProvider = validationContext.ModelValidationContext.ValidatorProvider; var validatorProviderContext = new ModelValidatorProviderContext(elementMetadata); validatorProvider.GetValidators(validatorProviderContext); var validators = validatorProviderContext.Validators; // If there are no validators or the object is null we bail out quickly // when there are large arrays of null, this will save a significant amount of processing // with minimal impact to other scenarios. var anyValidatorsDefined = validators.Any(); var index = 0; var isValid = true; foreach (var element in model) { // If the element is non null, the recursive calls might find more validators. // If it's null, then a shallow validation will be performed. if (element != null || anyValidatorsDefined) { var elementExplorer = new ModelExplorer(_modelMetadataProvider, elementMetadata, element); var elementKey = ModelBindingHelper.CreateIndexModelName(currentKey, index); var elementValidationContext = new ValidationContext() { ModelValidationContext = ModelValidationContext.GetChildValidationContext( validationContext.ModelValidationContext, elementExplorer), Visited = validationContext.Visited }; if (!ValidateNonVisitedNodeAndChildren(elementKey, elementValidationContext, validators)) { isValid = false; } } index++; } return(isValid); }
public void IValidatableObjectGetsAValidator() { // Arrange var provider = new DataAnnotationsModelValidatorProvider( new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var mockValidatable = new Mock<IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.Object.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert Assert.Single(providerContext.Validators); }
public void IValidatableObjectGetsAValidator() { // Arrange var provider = new DataAnnotationsModelValidatorProvider( new TestOptionsManager <MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var mockValidatable = new Mock <IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.Object.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert Assert.Single(providerContext.Validators); }
public void GetValidators_ReturnsValidatorForIValidatableObject() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var mockValidatable = Mock.Of <IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = Assert.Single(providerContext.Validators); Assert.IsType <ValidatableObjectAdapter>(validator); }
public void GetValidators_ReturnsValidatorForIValidatableObject() { // Arrange var provider = new DataAnnotationsModelValidatorProvider( new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var mockValidatable = Mock.Of<IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = Assert.Single(providerContext.Validators); Assert.IsType<ValidatableObjectAdapter>(validator); }
public void GetValidators_ModelValidatorAttributeOnClass() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForType(typeof(ModelValidatorAttributeOnClass)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; var validator = Assert.IsType<CustomModelValidatorAttribute>(Assert.Single(validators)); Assert.Equal("Class", validator.Tag); }
public void GetValidators_DoesNotAddRequiredAttribute_ForNonNullableValueTypes_IfAttributeIsSpecifiedExplicitly() { // Arrange var provider = new DataAnnotationsModelValidatorProvider(); var metadata = _metadataProvider.GetMetadataForProperty(typeof(DummyRequiredAttributeHelperClass), "WithAttribute"); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = Assert.Single(providerContext.Validators); var adapter = Assert.IsType <RequiredAttributeAdapter>(validator); Assert.Equal("Custom Required Message", adapter.Attribute.ErrorMessage); }
public void UnknownValidationAttributeGetsDefaultAdapter() { // Arrange var provider = new DataAnnotationsModelValidatorProvider( new ValidationAttributeAdapterProvider(), new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var metadata = _metadataProvider.GetMetadataForType(typeof(DummyClassWithDummyValidationAttribute)); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = providerContext.Validators.Single(); Assert.IsType<DataAnnotationsModelValidator>(validator); }
public void GetValidators_ForIValidatableObject() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForType(typeof(ValidatableObject)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; var validator = Assert.Single(validators); Assert.IsType<ValidatableObjectAdapter>(validator); }
private IList <IModelValidator> GetValidators() { if (_context == null) { _context = new ModelValidatorProviderContext(_metadata); } else { // Reusing the context so we don't allocate a new context and list // for every property that gets validated. _context.ModelMetadata = _metadata; _context.Validators.Clear(); } _validatorProvider.GetValidators(_context); return(_context.Validators); }
public void GetValidators_DataAnnotationsAttribute_DefaultAdapter() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(CustomValidationAttributeOnProperty), nameof(CustomValidationAttributeOnProperty.Property)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; Assert.IsType <DataAnnotationsModelValidator>(Assert.Single(validators)); }
public void GetValidators_FromModelMetadataType_SingleValidator() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(ProductViewModel), nameof(ProductViewModel.Id)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; Assert.IsType <RangeAttributeAdapter>(Assert.Single(validators)); }
public void GetValidators_ForIValidatableObject() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForType(typeof(ValidatableObject)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; var validator = Assert.Single(validators); Assert.IsType <ValidatableObjectAdapter>(validator); }
public void UnknownValidationAttributeGetsDefaultAdapter() { // Arrange var provider = new DataAnnotationsModelValidatorProvider( new ValidationAttributeAdapterProvider(), new TestOptionsManager <MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var metadata = _metadataProvider.GetMetadataForType(typeof(DummyClassWithDummyValidationAttribute)); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = providerContext.Validators.Single(); Assert.IsType <DataAnnotationsModelValidator>(validator); }
public void GetValidators_ModelValidatorAttributeOnClass() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForType(typeof(ModelValidatorAttributeOnClass)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; var validator = Assert.IsType <CustomModelValidatorAttribute>(Assert.Single(validators)); Assert.Equal("Class", validator.Tag); }
public void GetValidators(ModelValidatorProviderContext context) { foreach (var attribute in context.ValidatorMetadata.OfType <ValidationAttribute>()) { DataAnnotationsModelValidationFactory factory; if (!_attributeFactories.TryGetValue(attribute.GetType(), out factory)) { factory = _defaultAttributeFactory; } context.Validators.Add(factory(attribute)); } // Produce a validator if the type supports IValidatableObject if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType)) { context.Validators.Add(_defaultValidatableFactory()); } }
public void GetValidators_ReturnsValidatorForIValidatableObject() { // Arrange var provider = new DataAnnotationsModelValidatorProvider( new TestOptionsManager <MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var mockValidatable = Mock.Of <IValidatableObject>(); var metadata = _metadataProvider.GetMetadataForType(mockValidatable.GetType()); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert var validator = Assert.Single(providerContext.Validators); Assert.IsType <ValidatableObjectAdapter>(validator); }
public void GetValidators(ModelValidatorProviderContext context) { IStringLocalizer stringLocalizer = null; if (_stringLocalizerFactory != null && _options.Value.DataAnnotationLocalizerProvider != null) { stringLocalizer = _options.Value.DataAnnotationLocalizerProvider( context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType, _stringLocalizerFactory); } for (var i = 0; i < context.ValidatorMetadata.Count; i++) { var attribute = context.ValidatorMetadata[i] as ValidationAttribute; if (attribute == null) { continue; } var validator = new DataAnnotationsModelValidator( _validationAttributeAdapterProvider, attribute, stringLocalizer); // Inserts validators based on whether or not they are 'required'. We want to run // 'required' validators first so that we get the best possible error message. if (attribute is RequiredAttribute) { context.Validators.Insert(0, validator); } else { context.Validators.Add(validator); } } // Produce a validator if the type supports IValidatableObject if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType)) { context.Validators.Add(new ValidatableObjectAdapter()); } }
public void GetValidators_InsertsRequiredValidatorsFirst() { var provider = new DataAnnotationsModelValidatorProvider( new ValidationAttributeAdapterProvider(), new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var metadata = _metadataProvider.GetMetadataForProperty( typeof(ClassWithProperty), "PropertyWithMultipleValidationAttributes"); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert Assert.Equal(4, providerContext.Validators.Count); Assert.IsAssignableFrom<RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Validators[0]).Attribute); Assert.IsAssignableFrom<RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Validators[1]).Attribute); }
public void GetValidators_InsertsRequiredValidatorsFirst() { var provider = new DataAnnotationsModelValidatorProvider( new ValidationAttributeAdapterProvider(), new TestOptionsManager <MvcDataAnnotationsLocalizationOptions>(), stringLocalizerFactory: null); var metadata = _metadataProvider.GetMetadataForProperty( typeof(ClassWithProperty), "PropertyWithMultipleValidationAttributes"); var providerContext = new ModelValidatorProviderContext(metadata); // Act provider.GetValidators(providerContext); // Assert Assert.Equal(4, providerContext.Validators.Count); Assert.IsAssignableFrom <RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Validators[0]).Attribute); Assert.IsAssignableFrom <RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Validators[1]).Attribute); }
public void GetValidators(ModelValidatorProviderContext context) { IStringLocalizer stringLocalizer = null; if (_stringLocalizerFactory != null && _options.Value.DataAnnotationLocalizerProvider != null) { stringLocalizer = _options.Value.DataAnnotationLocalizerProvider( context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType, _stringLocalizerFactory); } for (var i = 0; i < context.ValidatorMetadata.Count; i++) { var attribute = context.ValidatorMetadata[i] as ValidationAttribute; if (attribute == null) { continue; } var validator = new DataAnnotationsModelValidator( _validationAttributeAdapterProvider, attribute, stringLocalizer); // Inserts validators based on whether or not they are 'required'. We want to run // 'required' validators first so that we get the best possible error message. if (attribute is RequiredAttribute) { context.Validators.Insert(0, validator); } else { context.Validators.Add(validator); } } // Produce a validator if the type supports IValidatableObject if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType)) { context.Validators.Add(new ValidatableObjectAdapter()); } }
public void GetValidators_ClientModelValidatorAttributeOnPropertyAndClass() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(ModelValidatorAttributeOnPropertyAndClass), nameof(ModelValidatorAttributeOnPropertyAndClass.Property)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; Assert.Equal(2, validators.Count); Assert.Single(validators, v => Assert.IsType <CustomModelValidatorAttribute>(v).Tag == "Class"); Assert.Single(validators, v => Assert.IsType <CustomModelValidatorAttribute>(v).Tag == "Property"); }
public void GetValidators_FromModelMetadataType_MergedValidators() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(ProductViewModel), nameof(ProductViewModel.Name)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; Assert.Equal(2, validators.Count); Assert.Single(validators, v => ((DataAnnotationsModelValidator)v).Attribute is RegularExpressionAttribute); Assert.Single(validators, v => ((DataAnnotationsModelValidator)v).Attribute is StringLengthAttribute); }
public void GetValidators(ModelValidatorProviderContext context) { IStringLocalizer stringLocalizer = null; if (_options.Value.DataAnnotationLocalizerProvider != null && _stringLocalizerFactory != null) { stringLocalizer = _options.Value.DataAnnotationLocalizerProvider( context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType, _stringLocalizerFactory); } foreach (var attribute in context.ValidatorMetadata.OfType<ValidationAttribute>()) { context.Validators.Add(new DataAnnotationsModelValidator(attribute, stringLocalizer)); } // Produce a validator if the type supports IValidatableObject if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType)) { context.Validators.Add(new ValidatableObjectAdapter()); } }
public void GetValidators_ModelValidatorAttributeOnPropertyAndClass() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(ModelValidatorAttributeOnPropertyAndClass), nameof(ModelValidatorAttributeOnPropertyAndClass.Property)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; Assert.Equal(2, validators.Count); Assert.Single(validators, v => Assert.IsType<CustomModelValidatorAttribute>(v).Tag == "Class"); Assert.Single(validators, v => Assert.IsType<CustomModelValidatorAttribute>(v).Tag == "Property"); }
public void GetValidators(ModelValidatorProviderContext context) { IStringLocalizer stringLocalizer = null; if (_options.Value.DataAnnotationLocalizerProvider != null && _stringLocalizerFactory != null) { stringLocalizer = _options.Value.DataAnnotationLocalizerProvider( context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType, _stringLocalizerFactory); } foreach (var attribute in context.ValidatorMetadata.OfType <ValidationAttribute>()) { context.Validators.Add(new DataAnnotationsModelValidator(attribute, stringLocalizer)); } // Produce a validator if the type supports IValidatableObject if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType)) { context.Validators.Add(new ValidatableObjectAdapter()); } }
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()); }
private bool ValidateElements(string currentKey, IEnumerable model, ValidationContext validationContext) { var elementType = GetElementType(model.GetType()); var elementMetadata = _modelMetadataProvider.GetMetadataForType(elementType); var validatorProvider = validationContext.ModelValidationContext.ValidatorProvider; var validatorProviderContext = new ModelValidatorProviderContext(elementMetadata); validatorProvider.GetValidators(validatorProviderContext); var validators = validatorProviderContext.Validators; // If there are no validators or the object is null we bail out quickly // when there are large arrays of null, this will save a significant amount of processing // with minimal impact to other scenarios. var anyValidatorsDefined = validators.Any(); var index = 0; var isValid = true; foreach (var element in model) { // If the element is non null, the recursive calls might find more validators. // If it's null, then a shallow validation will be performed. if (element != null || anyValidatorsDefined) { var elementExplorer = new ModelExplorer(_modelMetadataProvider, elementMetadata, element); var elementKey = ModelBindingHelper.CreateIndexModelName(currentKey, index); var elementValidationContext = new ValidationContext() { ModelValidationContext = ModelValidationContext.GetChildValidationContext( validationContext.ModelValidationContext, elementExplorer), Visited = validationContext.Visited }; if (!ValidateNonVisitedNodeAndChildren(elementKey, elementValidationContext, validators)) { isValid = false; } } index++; } return isValid; }
private bool ValidateNonVisitedNodeAndChildren( string modelKey, ValidationContext validationContext, IList <IModelValidator> validators) { var modelValidationContext = validationContext.ModelValidationContext; var modelExplorer = modelValidationContext.ModelExplorer; // Recursion guard to avoid stack overflows RuntimeHelpers.EnsureSufficientExecutionStack(); var modelState = modelValidationContext.ModelState; var bindingSource = modelValidationContext.BindingSource; if (bindingSource != null && !bindingSource.IsFromRequest) { // Short circuit if the metadata represents something that was not bound using request data. // For example model bound using [FromServices]. Treat such objects as skipped. var validationState = modelState.GetFieldValidationState(modelKey); if (validationState == ModelValidationState.Unvalidated) { modelValidationContext.ModelState.MarkFieldSkipped(modelKey); } // For validation purposes this model is valid. return(true); } if (modelState.HasReachedMaxErrors) { // Short circuit if max errors have been recorded. In which case we treat this as invalid. return(false); } var isValid = true; if (validators == null) { // The validators are not null in the case of validating an array. Since the validators are // the same for all the elements of the array, we do not do GetValidators for each element, // instead we just pass them over. See ValidateElements function. var validatorProvider = modelValidationContext.ValidatorProvider; var validatorProviderContext = new ModelValidatorProviderContext(modelExplorer.Metadata); validatorProvider.GetValidators(validatorProviderContext); validators = validatorProviderContext.Validators; } // We don't need to recursively traverse the graph for null values if (modelExplorer.Model == null) { return(ShallowValidate(modelKey, modelExplorer, validationContext, validators)); } // We don't need to recursively traverse the graph for types that shouldn't be validated var modelType = modelExplorer.Model.GetType(); if (IsTypeExcludedFromValidation(_excludeFilterProvider.ExcludeFilters, modelType)) { var result = ShallowValidate(modelKey, modelExplorer, validationContext, validators); MarkPropertiesAsSkipped(modelKey, modelExplorer.Metadata, validationContext); return(result); } // Check to avoid infinite recursion. This can happen with cycles in an object graph. if (validationContext.Visited.Contains(modelExplorer.Model)) { return(true); } validationContext.Visited.Add(modelExplorer.Model); // Validate the children first - depth-first traversal var enumerableModel = modelExplorer.Model as IEnumerable; if (enumerableModel == null) { isValid = ValidateProperties(modelKey, modelExplorer, validationContext); } else { isValid = ValidateElements(modelKey, enumerableModel, validationContext); } if (isValid) { // Don't bother to validate this node if children failed. isValid = ShallowValidate(modelKey, modelExplorer, validationContext, validators); } // Pop the object so that it can be validated again in a different path validationContext.Visited.Remove(modelExplorer.Model); return(isValid); }
private IList<IModelValidator> GetValidators() { if (_context == null) { _context = new ModelValidatorProviderContext(_metadata); } else { // Reusing the context so we don't allocate a new context and list // for every property that gets validated. _context.ModelMetadata = _metadata; _context.Validators.Clear(); } _validatorProvider.GetValidators(_context); return _context.Validators; }
public void GetValidators_FromModelMetadataType_SingleValidator() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(ProductViewModel), nameof(ProductViewModel.Id)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; var adapter = Assert.IsType<DataAnnotationsModelValidator>(Assert.Single(validators)); Assert.IsType<RangeAttribute>(adapter.Attribute); }
public void GetValidators(ModelValidatorProviderContext context) { }
public void SetProperty_PropertyIsSettable_CallsSetter() { // Arrange var model = new Person(); var bindingContext = CreateContext(GetMetadataForType(model.GetType()), model); var metadataProvider = bindingContext.OperationBindingContext.MetadataProvider; var modelExplorer = metadataProvider.GetModelExplorerForType(typeof(Person), model); var propertyMetadata = bindingContext.ModelMetadata.Properties["DateOfBirth"]; var dtoResult = new ModelBindingResult( new DateTime(2001, 1, 1), key: "foo", isModelSet: true); var validatorProvider = bindingContext.OperationBindingContext.ValidatorProvider; var validatorProviderContext = new ModelValidatorProviderContext(propertyMetadata); validatorProvider.GetValidators(validatorProviderContext); var requiredValidator = validatorProviderContext.Validators.FirstOrDefault(v => v.IsRequired); var testableBinder = new TestableMutableObjectModelBinder(); // Act testableBinder.SetProperty( bindingContext, modelExplorer, propertyMetadata, dtoResult, requiredValidator); // Assert Assert.True(bindingContext.ModelState.IsValid); Assert.Equal(new DateTime(2001, 1, 1), model.DateOfBirth); }
public void GetValidators_FromModelMetadataType_MergedValidators() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(ProductViewModel), nameof(ProductViewModel.Name)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; Assert.Equal(2, validators.Count); Assert.Single(validators, v => ((DataAnnotationsModelValidator)v).Attribute is RegularExpressionAttribute); Assert.Single(validators, v => ((DataAnnotationsModelValidator)v).Attribute is StringLengthAttribute); }
private bool ValidateNonVisitedNodeAndChildren( string modelKey, ValidationContext validationContext, IList<IModelValidator> validators) { var modelValidationContext = validationContext.ModelValidationContext; var modelExplorer = modelValidationContext.ModelExplorer; // Recursion guard to avoid stack overflows RuntimeHelpers.EnsureSufficientExecutionStack(); var modelState = modelValidationContext.ModelState; var bindingSource = modelValidationContext.BindingSource; if (bindingSource != null && !bindingSource.IsFromRequest) { // Short circuit if the metadata represents something that was not bound using request data. // For example model bound using [FromServices]. Treat such objects as skipped. var validationState = modelState.GetFieldValidationState(modelKey); if (validationState == ModelValidationState.Unvalidated) { modelValidationContext.ModelState.MarkFieldSkipped(modelKey); } // For validation purposes this model is valid. return true; } if (modelState.HasReachedMaxErrors) { // Short circuit if max errors have been recorded. In which case we treat this as invalid. return false; } var isValid = true; if (validators == null) { // The validators are not null in the case of validating an array. Since the validators are // the same for all the elements of the array, we do not do GetValidators for each element, // instead we just pass them over. See ValidateElements function. var validatorProvider = modelValidationContext.ValidatorProvider; var validatorProviderContext = new ModelValidatorProviderContext(modelExplorer.Metadata); validatorProvider.GetValidators(validatorProviderContext); validators = validatorProviderContext.Validators; } // We don't need to recursively traverse the graph for null values if (modelExplorer.Model == null) { return ShallowValidate(modelKey, modelExplorer, validationContext, validators); } // We don't need to recursively traverse the graph for types that shouldn't be validated var modelType = modelExplorer.Model.GetType(); if (IsTypeExcludedFromValidation(_excludeFilterProvider.ExcludeFilters, modelType)) { var result = ShallowValidate(modelKey, modelExplorer, validationContext, validators); MarkPropertiesAsSkipped(modelKey, modelExplorer.Metadata, validationContext); return result; } // Check to avoid infinite recursion. This can happen with cycles in an object graph. if (validationContext.Visited.Contains(modelExplorer.Model)) { return true; } validationContext.Visited.Add(modelExplorer.Model); // Validate the children first - depth-first traversal var enumerableModel = modelExplorer.Model as IEnumerable; if (enumerableModel == null) { isValid = ValidateProperties(modelKey, modelExplorer, validationContext); } else { isValid = ValidateElements(modelKey, enumerableModel, validationContext); } if (isValid) { // Don't bother to validate this node if children failed. isValid = ShallowValidate(modelKey, modelExplorer, validationContext, validators); } // Pop the object so that it can be validated again in a different path validationContext.Visited.Remove(modelExplorer.Model); return isValid; }
private static IModelValidator GetRequiredValidator(ModelBindingContext bindingContext, ModelMetadata propertyMetadata) { var validatorProvider = bindingContext.OperationBindingContext.ValidatorProvider; var validatorProviderContext = new ModelValidatorProviderContext(propertyMetadata); validatorProvider.GetValidators(validatorProviderContext); return validatorProviderContext.Validators.FirstOrDefault(v => v.IsRequired); }
protected virtual bool IsValidatingProperty(ModelValidatorProviderContext context) { return context.ModelMetadata.ContainerType != null && !string.IsNullOrEmpty(context.ModelMetadata.PropertyName); }
internal static PropertyValidationInfo GetPropertyValidationInfo(ModelBindingContext bindingContext) { var validationInfo = new PropertyValidationInfo(); var modelTypeInfo = bindingContext.ModelType.GetTypeInfo(); var typeAttribute = modelTypeInfo.GetCustomAttribute<BindingBehaviorAttribute>(); var properties = bindingContext.ModelType.GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (var property in properties) { var propertyName = property.Name; var propertyMetadata = bindingContext.ModelMetadata.Properties[propertyName]; if (propertyMetadata == null) { // Skip indexer properties and others ModelMetadata ignores. continue; } var validatorProviderContext = new ModelValidatorProviderContext(propertyMetadata); bindingContext.OperationBindingContext.ValidatorProvider.GetValidators(validatorProviderContext); var requiredValidator = validatorProviderContext.Validators .FirstOrDefault(v => v != null && v.IsRequired); if (requiredValidator != null) { validationInfo.RequiredValidators[propertyName] = requiredValidator; } var propertyAttribute = property.GetCustomAttribute<BindingBehaviorAttribute>(); var bindingBehaviorAttribute = propertyAttribute ?? typeAttribute; if (bindingBehaviorAttribute != null) { switch (bindingBehaviorAttribute.Behavior) { case BindingBehavior.Required: validationInfo.RequiredProperties.Add(propertyName); break; case BindingBehavior.Never: validationInfo.SkipProperties.Add(propertyName); break; } } else if (requiredValidator != null) { validationInfo.RequiredProperties.Add(propertyName); } } return validationInfo; }
public void GetValidators_DataAnnotationsAttribute_DefaultAdapter() { // Arrange var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider(); var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider(); var metadata = metadataProvider.GetMetadataForProperty( typeof(CustomValidationAttributeOnProperty), nameof(CustomValidationAttributeOnProperty.Property)); var context = new ModelValidatorProviderContext(metadata); // Act validatorProvider.GetValidators(context); // Assert var validators = context.Validators; Assert.IsType<DataAnnotationsModelValidator>(Assert.Single(validators)); }