public void CreateValidators(ModelValidatorProviderContext context)
{
for (var i = 0; i < context.Results.Count; i++)
{
var validatorItem = context.Results[i];
if (validatorItem.Validator != null)
{
continue;
}
var attribute = validatorItem.ValidatorMetadata as ValidationAttribute;
if (attribute == null)
{
continue;
}
var validator = new DataAnnotationsModelValidator(
new ValidationAttributeAdapterProvider(),
attribute,
stringLocalizer: null);
validatorItem.Validator = validator;
if (attribute is RequiredAttribute)
{
validatorItem.IsReusable = true;
}
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
for (var i = 0; i < context.Results.Count; i++)
{
var validatorItem = context.Results[i];
if (validatorItem.Validator != null)
{
continue;
}
var attribute = validatorItem.ValidatorMetadata as ValidationAttribute;
if (attribute == null)
{
continue;
}
var validator = new DataAnnotationsModelValidator(
new ValidationAttributeAdapterProvider(),
attribute,
stringLocalizer: null);
validatorItem.Validator = validator;
if (attribute is RequiredAttribute)
{
validatorItem.IsReusable = true;
}
}
}
/// <inheritdoc />
public void CreateValidators(ModelValidatorProviderContext context)
{
// Perf: Avoid allocations
for (var i = 0; i < ValidatorProviders.Count; i++)
{
ValidatorProviders[i].CreateValidators(context);
}
}
public void CreateValidators(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.Results.Count; i++)
{
var validatorItem = context.Results[i];
if (validatorItem.Validator != null)
{
continue;
}
var attribute = validatorItem.ValidatorMetadata as ValidationAttribute;
if (attribute == null)
{
continue;
}
var validator = new DataAnnotationsModelValidator(
_validationAttributeAdapterProvider,
attribute,
stringLocalizer);
validatorItem.Validator = validator;
validatorItem.IsReusable = true;
// 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.Results.Remove(validatorItem);
context.Results.Insert(0, validatorItem);
}
}
// Produce a validator if the type supports IValidatableObject
if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType))
{
context.Results.Add(new ValidatorItem
{
Validator = new ValidatableObjectAdapter(),
IsReusable = true
});
}
}
public void CreateValidators_ForIValidatableObject()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForType(typeof(ValidatableObject));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var validatorItem = Assert.Single(validatorItems);
Assert.IsType<ValidatableObjectAdapter>(validatorItem.Validator);
}
public void IValidatableObjectGetsAValidator()
{
// Arrange
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(),
stringLocalizerFactory: null);
var mockValidatable = new Mock<IValidatableObject>();
var metadata = _metadataProvider.GetMetadataForType(mockValidatable.Object.GetType());
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
Assert.Single(providerContext.Results);
}
public void CreateValidators_ModelValidatorAttributeOnClass()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForType(typeof(ModelValidatorAttributeOnClass));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var validator = Assert.IsType <CustomModelValidatorAttribute>(Assert.Single(validatorItems).Validator);
Assert.Equal("Class", validator.Tag);
}
public void CreateValidators_ForIValidatableObject()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForType(typeof(ValidatableObject));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var validatorItem = Assert.Single(validatorItems);
Assert.IsType <ValidatableObjectAdapter>(validatorItem.Validator);
}
public void CreateValidators_ClientModelValidatorAttributeOnClass()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForType(typeof(ModelValidatorAttributeOnClass));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var validatorItem = Assert.Single(validatorItems);
var customModelValidator = Assert.IsType<CustomModelValidatorAttribute>(validatorItem.Validator);
Assert.Equal("Class", customModelValidator.Tag);
}
public void CreateValidators_ReturnsValidatorForIValidatableObject()
{
// Arrange
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(),
stringLocalizerFactory: null);
var mockValidatable = Mock.Of<IValidatableObject>();
var metadata = _metadataProvider.GetMetadataForType(mockValidatable.GetType());
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = Assert.Single(providerContext.Results);
Assert.IsType<ValidatableObjectAdapter>(validatorItem.Validator);
}
public void CreateValidators_InsertsRequiredValidatorsFirst()
{
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
new TestOptionsManager<MvcDataAnnotationsLocalizationOptions>(),
stringLocalizerFactory: null);
var metadata = _metadataProvider.GetMetadataForProperty(
typeof(ClassWithProperty),
"PropertyWithMultipleValidationAttributes");
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
Assert.Equal(4, providerContext.Results.Count);
Assert.IsAssignableFrom<RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Results[0].Validator).Attribute);
Assert.IsAssignableFrom<RequiredAttribute>(((DataAnnotationsModelValidator)providerContext.Results[1].Validator).Attribute);
}
public void CreateValidators_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, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var adapter = Assert.IsType<DataAnnotationsModelValidator>(Assert.Single(validatorItems).Validator);
Assert.IsType<RangeAttribute>(adapter.Attribute);
}
public void CreateValidators(ModelValidatorProviderContext context)
{
//Perf: Avoid allocations here
for (var i = 0; i < context.Results.Count; i++)
{
var validatorItem = context.Results[i];
// Don't overwrite anything that was done by a previous provider.
if (validatorItem.Validator != null)
{
continue;
}
if (validatorItem.ValidatorMetadata is IModelValidator validator)
{
validatorItem.Validator = validator;
validatorItem.IsReusable = true;
}
}
}
public void CreateValidators_ModelValidatorAttributeOnPropertyAndClass()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForProperty(
typeof(ModelValidatorAttributeOnPropertyAndClass),
nameof(ModelValidatorAttributeOnPropertyAndClass.Property));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
Assert.Equal(2, validatorItems.Count);
Assert.Single(validatorItems, v => Assert.IsType <CustomModelValidatorAttribute>(v.Validator).Tag == "Class");
Assert.Single(validatorItems, v => Assert.IsType <CustomModelValidatorAttribute>(v.Validator).Tag == "Property");
}
public void CreateValidators_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, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var adapter = Assert.IsType <DataAnnotationsModelValidator>(Assert.Single(validatorItems).Validator);
Assert.IsType <RangeAttribute>(adapter.Attribute);
}
public void CreateValidators_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, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
Assert.Equal(2, validatorItems.Count);
Assert.Single(validatorItems, v => ((DataAnnotationsModelValidator)v.Validator).Attribute is RegularExpressionAttribute);
Assert.Single(validatorItems, v => ((DataAnnotationsModelValidator)v.Validator).Attribute is StringLengthAttribute);
}
public void CreateValidators_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, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
Assert.Equal(2, validatorItems.Count);
Assert.Single(validatorItems, v => ((DataAnnotationsModelValidator)v.Validator).Attribute is RegularExpressionAttribute);
Assert.Single(validatorItems, v => ((DataAnnotationsModelValidator)v.Validator).Attribute is StringLengthAttribute);
}
public void CreateValidators_ClientModelValidatorAttributeOnPropertyAndClass()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForProperty(
typeof(ModelValidatorAttributeOnPropertyAndClass),
nameof(ModelValidatorAttributeOnPropertyAndClass.Property));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
Assert.Equal(2, validatorItems.Count);
Assert.Single(validatorItems, v => Assert.IsType<CustomModelValidatorAttribute>(v.Validator).Tag == "Class");
Assert.Single(validatorItems, v => Assert.IsType<CustomModelValidatorAttribute>(v.Validator).Tag == "Property");
}
/// <inheritdoc />
public void CreateValidators(ModelValidatorProviderContext context)
{
//Perf: Avoid allocations here
for (var i = 0; i < context.Results.Count; i++)
{
var validatorItem = context.Results[i];
// Don't overwrite anything that was done by a previous provider.
if (validatorItem.Validator != null)
{
continue;
}
var validator = validatorItem.ValidatorMetadata as IModelValidator;
if (validator != null)
{
validatorItem.Validator = validator;
validatorItem.IsReusable = true;
}
}
}
public void GetModelValidators_ReturnsValidatorsFromAllProviders()
{
// Arrange
var validatorMetadata = new object();
var validator1 = new ValidatorItem(validatorMetadata);
var validator2 = new ValidatorItem(validatorMetadata);
var validator3 = new ValidatorItem(validatorMetadata);
var provider1 = new Mock <IModelValidatorProvider>();
provider1.Setup(p => p.CreateValidators(It.IsAny <ModelValidatorProviderContext>()))
.Callback <ModelValidatorProviderContext>(c =>
{
c.Results.Add(validator1);
c.Results.Add(validator2);
});
var provider2 = new Mock <IModelValidatorProvider>();
provider2.Setup(p => p.CreateValidators(It.IsAny <ModelValidatorProviderContext>()))
.Callback <ModelValidatorProviderContext>(c =>
{
c.Results.Add(validator3);
});
var compositeModelValidator = new CompositeModelValidatorProvider(new[] { provider1.Object, provider2.Object });
var modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(string));
// Act
var validatorProviderContext = new ModelValidatorProviderContext(modelMetadata, new List <ValidatorItem>());
compositeModelValidator.CreateValidators(validatorProviderContext);
// Assert
Assert.Equal(
new[] { validator1, validator2, validator3 },
validatorProviderContext.Results.ToArray());
}
private void ExecuteProvider(IModelValidatorProvider validatorProvider, ModelMetadata metadata, List <ValidatorItem> items)
{
var context = new ModelValidatorProviderContext(metadata, items);
validatorProvider.CreateValidators(context);
}
public void CreateValidators(ModelValidatorProviderContext context)
{
throw new NotImplementedException();
}
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, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = providerContext.Results.Single();
Assert.IsType<DataAnnotationsModelValidator>(validatorItem.Validator);
}
private void ExecuteProvider(IModelValidatorProvider validatorProvider, ModelMetadata metadata, List<ValidatorItem> items)
{
var context = new ModelValidatorProviderContext(metadata, items);
validatorProvider.CreateValidators(context);
}
public void CreateValidators_ModelValidatorAttributeOnProperty()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForProperty(
typeof(ModelValidatorAttributeOnProperty),
nameof(ModelValidatorAttributeOnProperty.Property));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var validator = Assert.IsType<CustomModelValidatorAttribute>(Assert.Single(validatorItems).Validator);
Assert.Equal("Property", validator.Tag);
}
