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