public void CreateValidators_ForInteger(Type type)
{
ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(type);
ClientValidatorProviderContext context = new ClientValidatorProviderContext(metadata, new List<ClientValidatorItem>());
new ClientValidatorProvider().CreateValidators(context);
ClientValidatorItem actual = context.Results.Single();
Assert.IsType<IntegerValidator>(actual.Validator);
Assert.Null(actual.ValidatorMetadata);
Assert.True(actual.IsReusable);
}
/// <summary>
/// Creates the client validation validators
/// </summary>
/// <param name="context"></param>
public void CreateValidators(ClientValidatorProviderContext context)
{
bool shouldAddRequiredValidator = !(context.Results.Any(x => x.GetType().Equals(typeof(RequiredAttributeAdapter))));
foreach (var validator in GetValidators(context.ModelMetadata, false).OfType <IClientModelValidator>())
{
var clientValidatorItem = new ClientValidatorItem();
clientValidatorItem.Validator = validator;
clientValidatorItem.IsReusable = false;
context.Results.Add(clientValidatorItem);
}
}
public void CreateValidators_DoesNotAddDuplicateValidators()
{
// Arrange
var provider = new NumericClientModelValidatorProvider();
var metadata = _metadataProvider.GetMetadataForType(typeof(float));
var items = GetValidatorItems(metadata);
var expectedValidatorItem = new ClientValidatorItem
{
Validator = new NumericClientModelValidator(),
IsReusable = true
};
items.Add(expectedValidatorItem);
var providerContext = new ClientValidatorProviderContext(metadata, items);
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = Assert.Single(providerContext.Results);
Assert.Same(expectedValidatorItem.Validator, validatorItem.Validator);
}
/// <inheritdoc />
public void CreateValidators(ClientValidatorProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
IStringLocalizer stringLocalizer = null;
if (_options.Value.DataAnnotationLocalizerProvider != null && _stringLocalizerFactory != null)
{
// This will pass first non-null type (either containerType or modelType) to delegate.
// Pass the root model type(container type) if it is non null, else pass the model type.
stringLocalizer = _options.Value.DataAnnotationLocalizerProvider(
context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType,
_stringLocalizerFactory);
}
var hasRequiredAttribute = false;
var metadata = context.ModelMetadata;
var isPropertyValidation = metadata.ContainerType != null && !String.IsNullOrEmpty(metadata.PropertyName);
var rules = ValidationManager.GetValidationRules(metadata.ContainerType, metadata.PropertyName);
if (rules == null)
{
return;
}
foreach (var rule in rules)
{
var validationAttribute = rule.CreateValidationAttribute();
if (validationAttribute == null)
{
continue;
}
var validatorItem = new ClientValidatorItem(validationAttribute);
if (validatorItem.Validator != null)
{
// Check if a required attribute is already cached.
hasRequiredAttribute |= validatorItem.Validator is RequiredAttributeAdapter;
continue;
}
hasRequiredAttribute |= validationAttribute is RequiredAttribute;
var adapter = _validationAttributeAdapterProvider.GetAttributeAdapter(validationAttribute, stringLocalizer);
if (adapter != null)
{
validatorItem.Validator = adapter;
validatorItem.IsReusable = true;
}
context.Results.Add(validatorItem);
}
if (!hasRequiredAttribute && context.ModelMetadata.IsRequired)
{
// Add a default '[Required]' validator for generating HTML if necessary.
context.Results.Add(new ClientValidatorItem
{
Validator = _validationAttributeAdapterProvider.GetAttributeAdapter(
new RequiredAttribute(),
stringLocalizer),
IsReusable = true
});
}
}
