public void GetClientValidationRules_ReturnsValidationParameters_Localize() { // Arrange var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var attribute = new RequiredAttribute(); var expectedProperties = new object[] { "Length" }; var message = "This paramter is required."; var expectedMessage = "FR This parameter is required."; attribute.ErrorMessage = message; var stringLocalizer = new Mock<IStringLocalizer>(); stringLocalizer.Setup(s => s[attribute.ErrorMessage, expectedProperties]) .Returns(new LocalizedString(attribute.ErrorMessage, expectedMessage)); var adapter = new RequiredAttributeAdapter(attribute, stringLocalizer: stringLocalizer.Object); var actionContext = new ActionContext(); var context = new ClientModelValidationContext(actionContext, metadata, provider); // Act var rules = adapter.GetClientValidationRules(context); // Assert var rule = Assert.Single(rules); Assert.Equal("required", rule.ValidationType); Assert.Empty(rule.ValidationParameters); Assert.Equal(expectedMessage, rule.ErrorMessage); }
public void AddValidation_AddsValidation_Localize() { // Arrange var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var attribute = new RequiredAttribute(); var expectedProperties = new object[] { "Length" }; var message = "This paramter is required."; var expectedMessage = "FR This parameter is required."; attribute.ErrorMessage = message; var stringLocalizer = new Mock<IStringLocalizer>(); stringLocalizer.Setup(s => s[attribute.ErrorMessage, expectedProperties]) .Returns(new LocalizedString(attribute.ErrorMessage, expectedMessage)); var adapter = new RequiredAttributeAdapter(attribute, stringLocalizer: stringLocalizer.Object); var actionContext = new ActionContext(); var context = new ClientModelValidationContext(actionContext, metadata, provider, new AttributeDictionary()); // Act adapter.AddValidation(context); // Assert Assert.Collection( context.Attributes, kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("true", kvp.Value); }, kvp => { Assert.Equal("data-val-required", kvp.Key); Assert.Equal(expectedMessage, kvp.Value); }); }
public void AddValidation_DoesNotTrounceExistingAttributes() { // Arrange var expectedMessage = ValidationAttributeUtil.GetRequiredErrorMessage("Length"); var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var attribute = new RequiredAttribute(); var adapter = new RequiredAttributeAdapter(attribute, stringLocalizer: null); var actionContext = new ActionContext(); var context = new ClientModelValidationContext(actionContext, metadata, provider, new AttributeDictionary()); context.Attributes.Add("data-val", "original"); context.Attributes.Add("data-val-required", "original"); // Act adapter.AddValidation(context); // Assert Assert.Collection( context.Attributes, kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("original", kvp.Value); }, kvp => { Assert.Equal("data-val-required", kvp.Key); Assert.Equal("original", kvp.Value); }); }
// ReSharper restore NotAccessedField.Local public TypePropertyValidationRuleMetadata(RequiredAttribute attribute) : this((ValidationAttribute) attribute) { Name = "required"; Value1 = true; _type = "boolean"; }
public void AllowEmptyStrings () { var attr = new RequiredAttribute (); Assert.IsFalse (attr.AllowEmptyStrings, "#A1"); attr.AllowEmptyStrings = true; Assert.IsTrue (attr.AllowEmptyStrings, "#A2"); }
public LocalizedRequiredAttribute(RequiredAttribute attribute, Localizer t) { AllowEmptyStrings = attribute.AllowEmptyStrings; if ( !String.IsNullOrEmpty(attribute.ErrorMessage) ) ErrorMessage = attribute.ErrorMessage; T = t; }
public PizzaRequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { if (string.IsNullOrEmpty(attribute.ErrorMessage) && string.IsNullOrEmpty(attribute.ErrorMessageResourceName)) { attribute.ErrorMessage = Errors.ValueIsRequired; } }
public ResourseBaseRequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { attribute.ErrorMessageResourceType = typeof(AvicolaGlobalResources); attribute.ErrorMessageResourceName = "Required"; }
public WeeeRequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { if (string.IsNullOrEmpty(attribute.ErrorMessage) && !string.IsNullOrEmpty(metadata.DisplayName)) { attribute.ErrorMessage = string.Format("Enter {0}", metadata.DisplayName.ToLower()); } }
public CustomizedRequiredValidatorAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { attribute.ErrorMessage = "Please enter value in {0}."; //attribute.ErrorMessageResourceType = typeof(Messages); //attribute.ErrorMessageResourceName = "PropertyValueRequired"; }
public static void Can_get_and_set_AllowEmptyStrings() { var attribute = new RequiredAttribute(); Assert.False(attribute.AllowEmptyStrings); attribute.AllowEmptyStrings = true; Assert.True(attribute.AllowEmptyStrings); attribute.AllowEmptyStrings = false; Assert.False(attribute.AllowEmptyStrings); }
public override ModelValidator Create(IStorageValidator validator, Type defaultResourceType, ModelMetadata metadata, ControllerContext context) { metadata.IsRequired = false; var attribute = new RequiredAttribute(); this.BindErrorMessageToAttribte(attribute, validator, defaultResourceType); return new RequiredAttributeAdapter(metadata, context, attribute); }
public void IsRequired () { var attr = new RequiredAttribute (); Assert.IsFalse (attr.IsValid (null), "#A1"); Assert.IsFalse (attr.IsValid (String.Empty), "#A2"); Assert.IsTrue (attr.IsValid ("string"), "#A3"); Assert.IsTrue (attr.IsValid (1), "#A4"); attr.AllowEmptyStrings = true; Assert.IsTrue (attr.IsValid (String.Empty), "#A5"); }
public void ValuesSet() { // Arrange var attribute = new RequiredAttribute(); // Act var validator = new DataAnnotationsModelValidator(attribute); // Assert Assert.Same(attribute, validator.Attribute); }
public void Constructor_SetsAttribute() { // Arrange var attribute = new RequiredAttribute(); // Act var validator = new DataAnnotationsModelValidator(attribute, stringLocalizer : null); // Assert Assert.Same(attribute, validator.Attribute); }
public void ValuesSet() { // Arrange ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length"); var attribute = new RequiredAttribute(); // Act var validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute); // Assert Assert.Same(attribute, validator.Attribute); }
public LocalizedRequiredAttributeAdapter( ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute ) : base(metadata, context, attribute) { if (attribute.ErrorMessageResourceType == null) attribute.ErrorMessageResourceType = typeof(Resources.Resources); if (attribute.ErrorMessageResourceName == null) attribute.ErrorMessageResourceName = "PropertyValueRequired"; }
public void RequiredAdapter_SetsErrorMessage() { ModelMetadata metadata = new DataAnnotationsModelMetadataProvider() .GetMetadataForProperty(null, typeof(AdaptersModel), "Required"); RequiredAttribute attribute = new RequiredAttribute(); new RequiredAdapter(metadata, new ControllerContext(), attribute); String expected = Validations.FieldIsRequired; String actual = attribute.ErrorMessage; Assert.Equal(expected, actual); }
public void NoClientRulesByDefault() { // Arrange ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length"); ControllerContext context = new ControllerContext(); RequiredAttribute attribute = new RequiredAttribute(); // Act DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute); // Assert Assert.IsFalse(validator.GetClientValidationRules().Any()); }
private void Include() { ValidationAttribute attribute = new RequiredAttribute(); var validationContext = new ValidationContext(this, null, new Dictionary<object, object>()); validationContext.DisplayName = validationContext.DisplayName; validationContext.Items.Add(null, null); validationContext.MemberName = validationContext.MemberName; validationContext.ObjectInstance.GetHashCode(); ValidationResult result = attribute.GetValidationResult(this, validationContext); result.ErrorMessage = result.ErrorMessage; result.MemberNames.GetHashCode(); }
public MyRequiredAttributeAdapter( ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute ) : base(metadata, context, attribute) { if (string.IsNullOrEmpty(attribute.ErrorMessage)) { attribute.ErrorMessageResourceType = typeof(Resources.UI); attribute.ErrorMessageResourceName = "PropertyValueRequired"; } }
public CustomRequiredAttribute( ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute ) : base(metadata, context, attribute) { if (string.IsNullOrEmpty(attribute.ErrorMessage)) { attribute.ErrorMessageResourceType = typeof(DefaultResource); attribute.ErrorMessageResourceName = "PropertyValueRequired"; } }
public void ValuesSet() { // Arrange ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length"); ControllerContext context = new ControllerContext(); RequiredAttribute attribute = new RequiredAttribute(); // Act DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute); // Assert Assert.AreSame(attribute, validator.Attribute); Assert.AreEqual(attribute.FormatErrorMessage("Length"), validator.ErrorMessage); }
public void ConstructorGuards() { // Arrange ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(object)); var attribute = new RequiredAttribute(); // Act & Assert Assert.ThrowsArgumentNull( () => new DataAnnotationsModelValidator(null, attribute), "validatorProviders"); Assert.ThrowsArgumentNull( () => new DataAnnotationsModelValidator(_noValidatorProviders, null), "attribute"); }
protected override void SetProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, object value) { base.SetProperty(controllerContext, bindingContext, propertyDescriptor, value); var metadata = bindingContext.PropertyMetadata[propertyDescriptor.Name]; var key = CreateSubPropertyName(bindingContext.ModelName, propertyDescriptor.Name); bool hasFormatException = false; ModelState state; if (bindingContext.ModelState.TryGetValue(key, out state)) { foreach (var err in state.Errors.Where(x => x.Exception != null).ToList()) { for (var inner = err.Exception; inner != null; inner = inner.InnerException) { if (inner is FormatException) { hasFormatException = true; //DefaultModelBinder.BindProperty shouldn't consider this (thanks Reflector) var msg = ExceptionHelper.LocalizeValidationException(TextManager, inner, metadata, value: state.Value); if (!string.IsNullOrEmpty(msg)) { state.Errors.Remove(err); state.Errors.Add(msg); } } } } } //Replace required message for non nullable types (again, thanks Reflector) var type = propertyDescriptor.PropertyType; bool nonNullable = type.IsValueType && Nullable.GetUnderlyingType(type) == null; if (nonNullable && value == null && !hasFormatException ) { //"Simulate" RequiredAttribute on property var attr = new RequiredAttribute(); var msg = ExceptionHelper.LocalizeValidationException(TextManager, new ValidationException("", attr, value), metadata); if (msg != null) { bindingContext.ModelState.Remove(key); bindingContext.ModelState.AddModelError(key, msg); } } }
public RequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { if (!string.IsNullOrWhiteSpace(Attribute.ErrorMessage)) return; if (Attribute.ErrorMessageResourceType == null) { Attribute.ErrorMessageResourceType = typeof (Message); } if (string.IsNullOrWhiteSpace(Attribute.ErrorMessageResourceName)) { Attribute.ErrorMessageResourceName = "PropertyValueRequired"; } }
public void ConstructorGuards() { // Arrange ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(object)); ControllerContext context = new ControllerContext(); RequiredAttribute attribute = new RequiredAttribute(); // Act & Assert ExceptionHelper.ExpectArgumentNullException( () => new DataAnnotationsModelValidator(null, context, attribute), "metadata"); ExceptionHelper.ExpectArgumentNullException( () => new DataAnnotationsModelValidator(metadata, null, attribute), "controllerContext"); ExceptionHelper.ExpectArgumentNullException( () => new DataAnnotationsModelValidator(metadata, context, null), "attribute"); }
private ValidationAttribute CopyAttribute(ValidationAttribute attribute) { ValidationAttribute result = null; if (attribute is RangeAttribute) { var attr = (RangeAttribute)attribute; result = new RangeAttribute((double)attr.Minimum, (double)attr.Maximum); } if (attribute is RegularExpressionAttribute) { var attr = (RegularExpressionAttribute)attribute; result = new RegularExpressionAttribute(attr.Pattern); } if (attribute is RequiredAttribute) result = new RequiredAttribute(); if (attribute is StringLengthAttribute) { var attr = (StringLengthAttribute)attribute; result = new StringLengthAttribute(attr.MaximumLength) { MinimumLength = attr.MinimumLength }; } if (attribute is CompareAttribute) { var attr = (CompareAttribute)attribute; result = new CompareAttribute(attr.OtherProperty); } if (attribute is DataTypeAttribute) { var attr = (DataTypeAttribute)attribute; result = new DataTypeAttribute(attr.DataType); } if (result == null && attribute.GetType().GetInterfaces().Contains(typeof(ICloneable))) result = ((ICloneable)attribute).Clone() as ValidationAttribute; return result; }
public void ClientRulesWithRequiredAttribute() { // Arrange var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length"); var context = new ControllerContext(); var attribute = new RequiredAttribute(); var adapter = new RequiredAttribute4Adapter(metadata, context, attribute); // Act var rules = adapter.GetClientValidationRules() .OrderBy(r => r.ValidationType) .ToArray(); // Assert Assert.AreEqual(1, rules.Length); Assert.AreEqual("required", rules[0].ValidationType); Assert.AreEqual(0, rules[0].ValidationParameters.Count); Assert.AreEqual(@"The Length field is required.", rules[0].ErrorMessage); }
public void GetClientValidationRules_ReturnsValidationParameters() { // Arrange var provider = new DataAnnotationsModelMetadataProvider(); var metadata = provider.GetMetadataForProperty(() => null, typeof(string), "Length"); var attribute = new RequiredAttribute(); var adapter = new RequiredAttributeAdapter(attribute); var context = new ClientModelValidationContext(metadata, provider); // Act var rules = adapter.GetClientValidationRules(context); // Assert var rule = Assert.Single(rules); Assert.Equal("required", rule.ValidationType); Assert.Empty(rule.ValidationParameters); Assert.Equal("The Length field is required.", rule.ErrorMessage); }
private static IEnumerable <ValidationError> GetValidationErrors(object value, ValidationContext validationContext, IEnumerable <ValidationAttribute> attributes, bool breakOnFirstError) { if (validationContext == null) { throw new ArgumentNullException("validationContext"); } List <ValidationError> errors = new List <ValidationError>(); ValidationError validationError; // Get the required validator if there is one and test it first, aborting on failure System.ComponentModel.DataAnnotations.RequiredAttribute required = attributes.FirstOrDefault(a => a is System.ComponentModel.DataAnnotations.RequiredAttribute) as System.ComponentModel.DataAnnotations.RequiredAttribute; if (required != null) { if (!TryValidate(value, validationContext, required, out validationError)) { errors.Add(validationError); return(errors); } } // Iterate through the rest of the validators, skipping the required validator foreach (ValidationAttribute attr in attributes) { if (attr != required) { if (!TryValidate(value, validationContext, attr, out validationError)) { errors.Add(validationError); if (breakOnFirstError) { break; } } } } return(errors); }