public LocalizedRegularExpressionAttribute(RegularExpressionAttribute attribute, Localizer t) : base(attribute.Pattern) { if ( !String.IsNullOrEmpty(attribute.ErrorMessage) ) ErrorMessage = attribute.ErrorMessage; T = t; }
public static void Can_set_and_get_MatchTimeout() { var attribute = new RegularExpressionAttribute("SomePattern"); attribute.MatchTimeoutInMilliseconds = 12345; Assert.Equal(12345, attribute.MatchTimeoutInMilliseconds); }
public void IsCultureCodeValidTests() { var attribute = new RegularExpressionAttribute(Expressions.CultureCode); Assert.IsTrue(attribute.IsValid(null)); Assert.IsTrue(attribute.IsValid(string.Empty)); Assert.IsTrue(attribute.IsValid("ab")); Assert.IsTrue(attribute.IsValid("XYZ")); Assert.IsTrue(attribute.IsValid("ab-WxYz")); Assert.IsTrue(attribute.IsValid("abc-wXyZ")); Assert.IsTrue(attribute.IsValid("ab-cd")); Assert.IsTrue(attribute.IsValid("UVW-XYZ")); Assert.IsTrue(attribute.IsValid("ab-123")); Assert.IsTrue(attribute.IsValid("XYZ-789")); Assert.IsTrue(attribute.IsValid("ab-CD-Efgh")); Assert.IsTrue(attribute.IsValid("UVW-XYZ-abcd")); Assert.IsTrue(attribute.IsValid("ab-123-cdef")); Assert.IsTrue(attribute.IsValid("XYZ-789-abcd")); Assert.IsFalse(attribute.IsValid("12")); Assert.IsFalse(attribute.IsValid("789")); Assert.IsFalse(attribute.IsValid("6789")); Assert.IsFalse(attribute.IsValid("A")); Assert.IsFalse(attribute.IsValid("AB-")); Assert.IsFalse(attribute.IsValid("WXYZ")); Assert.IsFalse(attribute.IsValid("AB-789-XYZ")); Assert.IsFalse(attribute.IsValid("AB-789-VWXYZ")); Assert.IsFalse(attribute.IsValid("UVW-XYZ-0000")); }
public static void Validate_successful_for_null_or_empty_value() { var attribute = new RegularExpressionAttribute("SomePattern"); AssertEx.DoesNotThrow(() => attribute.Validate(null, s_testValidationContext)); // Null is valid AssertEx.DoesNotThrow(() => attribute.Validate(string.Empty, s_testValidationContext)); // Empty string is valid }
public static void Validate_successful_for_value_matching_pattern() { var attribute = new RegularExpressionAttribute("defghi"); AssertEx.DoesNotThrow(() => attribute.Validate("defghi", s_testValidationContext)); attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); AssertEx.DoesNotThrow(() => attribute.Validate("bcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxy", s_testValidationContext)); }
public PasswordValidationAttribute() { var configuration = DependencyResolver.Current.GetService<IGalleryConfigurationService>().Current; _regexAttribute = new RegularExpressionAttribute(configuration.UserPasswordRegex) { ErrorMessage = configuration.UserPasswordHint }; }
public static void Validate_successful_for_value_matching_pattern() { var attribute = new RegularExpressionAttribute("defghi"); AssertEx.DoesNotThrow(() => attribute.Validate("defghi", s_testValidationContext)); attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); AssertEx.DoesNotThrow(() => attribute.Validate("bcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxy", s_testValidationContext)); }
public static void Validate_successful_for_value_matching_pattern() { var attribute = new RegularExpressionAttribute("defghi"); attribute.MatchTimeoutInMilliseconds = 5000; // note: timeout is just a number much larger than we expect the test to take AssertEx.DoesNotThrow(() => attribute.Validate("defghi", s_testValidationContext)); attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); attribute.MatchTimeoutInMilliseconds = 10000; // note: timeout is just a number much larger than we expect the test to take AssertEx.DoesNotThrow(() => attribute.Validate("bcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxy", s_testValidationContext)); }
public static void Validate_successful_for_value_matching_pattern() { var attribute = new RegularExpressionAttribute("defghi"); attribute.MatchTimeoutInMilliseconds = 5000; // note: timeout is just a number much larger than we expect the test to take AssertEx.DoesNotThrow(() => attribute.Validate("defghi", s_testValidationContext)); attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); attribute.MatchTimeoutInMilliseconds = 10000; // note: timeout is just a number much larger than we expect the test to take AssertEx.DoesNotThrow(() => attribute.Validate("bcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxy", s_testValidationContext)); }
public override bool IsValid(object value) { if (value != null) { var regexValidator = new RegularExpressionAttribute(_pattern); if (!regexValidator.IsValid(value)) { return false; } } return true; }
public static void Validation_throws_InvalidOperationException_for_null_or_empty_pattern() { var attribute = new RegularExpressionAttribute(null); Assert.Null(attribute.Pattern); Assert.Throws<InvalidOperationException>( () => attribute.Validate("Does not matter - Pattern is null", s_testValidationContext)); attribute = new RegularExpressionAttribute(string.Empty); AssertEx.Empty(attribute.Pattern); Assert.Throws<InvalidOperationException>( () => attribute.Validate("Does not matter - Pattern is empty", s_testValidationContext)); }
public static void Validation_throws_InvalidOperationException_for_null_or_empty_pattern() { var attribute = new RegularExpressionAttribute(null); Assert.Null(attribute.Pattern); Assert.Throws <InvalidOperationException>( () => attribute.Validate("Does not matter - Pattern is null", s_testValidationContext)); attribute = new RegularExpressionAttribute(string.Empty); AssertEx.Empty(attribute.Pattern); Assert.Throws <InvalidOperationException>( () => attribute.Validate("Does not matter - Pattern is empty", s_testValidationContext)); }
public static void Validate_throws_for_values_which_do_not_match_pattern() { var attribute = new RegularExpressionAttribute("defghi"); Assert.Throws<ValidationException>(() => attribute.Validate("zyxwvu", s_testValidationContext)); // pattern does not match Assert.Throws<ValidationException>(() => attribute.Validate("defghijkl", s_testValidationContext)); // pattern only matches beginning of value Assert.Throws<ValidationException>(() => attribute.Validate("abcdefghi", s_testValidationContext)); // pattern only matches end of value Assert.Throws<ValidationException>(() => attribute.Validate("abcdefghijkl", s_testValidationContext)); // pattern only matches part of value attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); Assert.Throws<ValidationException>(() => attribute.Validate("aaaaa", s_testValidationContext)); Assert.Throws<ValidationException>(() => attribute.Validate("zzzzz", s_testValidationContext)); Assert.Throws<ValidationException>(() => attribute.Validate("b.z", s_testValidationContext)); Assert.Throws<ValidationException>(() => attribute.Validate("a.y", s_testValidationContext)); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { var pageUrl = value as string; if (!string.IsNullOrWhiteSpace(pageUrl)) { var regExpAttribute = new RegularExpressionAttribute(PagesConstants.PageUrlRegularExpression); if (!regExpAttribute.IsValid(pageUrl)) { return new ValidationResult(errorMessage); } } return ValidationResult.Success; }
public static void Validate_throws_for_values_which_do_not_match_pattern() { var attribute = new RegularExpressionAttribute("defghi"); Assert.Throws <ValidationException>(() => attribute.Validate("zyxwvu", s_testValidationContext)); // pattern does not match Assert.Throws <ValidationException>(() => attribute.Validate("defghijkl", s_testValidationContext)); // pattern only matches beginning of value Assert.Throws <ValidationException>(() => attribute.Validate("abcdefghi", s_testValidationContext)); // pattern only matches end of value Assert.Throws <ValidationException>(() => attribute.Validate("abcdefghijkl", s_testValidationContext)); // pattern only matches part of value attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); Assert.Throws <ValidationException>(() => attribute.Validate("aaaaa", s_testValidationContext)); Assert.Throws <ValidationException>(() => attribute.Validate("zzzzz", s_testValidationContext)); Assert.Throws <ValidationException>(() => attribute.Validate("b.z", s_testValidationContext)); Assert.Throws <ValidationException>(() => attribute.Validate("a.y", s_testValidationContext)); }
public static void Validate_throws_for_values_which_do_not_match_pattern() { var attribute = new RegularExpressionAttribute("defghi"); Assert.Throws<ValidationException>(() => attribute.Validate("zyxwvu", s_testValidationContext)); // pattern does not match Assert.Throws<ValidationException>(() => attribute.Validate("defghijkl", s_testValidationContext)); // pattern only matches beginning of value Assert.Throws<ValidationException>(() => attribute.Validate("abcdefghi", s_testValidationContext)); // pattern only matches end of value Assert.Throws<ValidationException>(() => attribute.Validate("abcdefghijkl", s_testValidationContext)); // pattern only matches part of value attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); attribute.MatchTimeoutInMilliseconds = 10000; // note: timeout is just a number much larger than we expect the test to take Assert.Throws<ValidationException>(() => attribute.Validate("aaaaa", s_testValidationContext)); Assert.Throws<ValidationException>(() => attribute.Validate("zzzzz", s_testValidationContext)); Assert.Throws<ValidationException>(() => attribute.Validate("b.z", s_testValidationContext)); Assert.Throws<ValidationException>(() => attribute.Validate("a.y", s_testValidationContext)); }
public static void Validate_throws_for_values_which_do_not_match_pattern() { var attribute = new RegularExpressionAttribute("defghi"); Assert.Throws <ValidationException>(() => attribute.Validate("zyxwvu", s_testValidationContext)); // pattern does not match Assert.Throws <ValidationException>(() => attribute.Validate("defghijkl", s_testValidationContext)); // pattern only matches beginning of value Assert.Throws <ValidationException>(() => attribute.Validate("abcdefghi", s_testValidationContext)); // pattern only matches end of value Assert.Throws <ValidationException>(() => attribute.Validate("abcdefghijkl", s_testValidationContext)); // pattern only matches part of value attribute = new RegularExpressionAttribute("[^a]+\\.[^z]+"); attribute.MatchTimeoutInMilliseconds = 10000; // note: timeout is just a number much larger than we expect the test to take Assert.Throws <ValidationException>(() => attribute.Validate("aaaaa", s_testValidationContext)); Assert.Throws <ValidationException>(() => attribute.Validate("zzzzz", s_testValidationContext)); Assert.Throws <ValidationException>(() => attribute.Validate("b.z", s_testValidationContext)); Assert.Throws <ValidationException>(() => attribute.Validate("a.y", s_testValidationContext)); }
public void IsCurrencyCodeValidTests() { var attribute = new RegularExpressionAttribute(Expressions.CurrencyCode); Assert.IsTrue(attribute.IsValid(null)); Assert.IsTrue(attribute.IsValid(string.Empty)); Assert.IsTrue(attribute.IsValid("ABC")); Assert.IsTrue(attribute.IsValid("XYZ")); Assert.IsTrue(attribute.IsValid("123")); Assert.IsTrue(attribute.IsValid("789")); Assert.IsFalse(attribute.IsValid("AB")); Assert.IsFalse(attribute.IsValid("WXYZ")); Assert.IsFalse(attribute.IsValid("12")); Assert.IsFalse(attribute.IsValid("6789")); }
private ValidationAttribute CopyAttribute(ValidationAttribute attribute) { ValidationAttribute result = null; if (attribute is RangeAttribute) { var attr = (RangeAttribute)attribute; result = (attr.Minimum is double) ? new RangeAttribute((double)attr.Minimum, (double)attr.Maximum) : new RangeAttribute((int)attr.Minimum, (int)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 DA.CompareAttribute) { var attr = (DA.CompareAttribute)attribute; result = new DA.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 IsCuitValidTests() { var attribute = new RegularExpressionAttribute(Expressions.Cuit); Assert.IsTrue(attribute.IsValid(null)); Assert.IsTrue(attribute.IsValid("20245597151")); Assert.IsTrue(attribute.IsValid("20-24559715-1")); Assert.IsTrue(attribute.IsValid("27-23840320-6")); Assert.IsTrue(attribute.IsValid("27238403206")); Assert.IsTrue(attribute.IsValid(27238403206)); Assert.IsFalse(attribute.IsValid("20 24559715 1")); Assert.IsFalse(attribute.IsValid("123456789")); Assert.IsFalse(attribute.IsValid("aa-aaaaaaaa-a")); Assert.IsFalse(attribute.IsValid("4408 0412 3456 7890")); Assert.IsFalse(attribute.IsValid(0)); Assert.IsFalse(attribute.IsValid(123)); }
public void ClientRulesWithRegexAttribute() { // Arrange var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length"); var context = new ControllerContext(); var attribute = new RegularExpressionAttribute("the_pattern"); var adapter = new RegularExpressionAttributeAdapter(metadata, context, attribute); // Act var rules = adapter.GetClientValidationRules() .OrderBy(r => r.ValidationType) .ToArray(); // Assert Assert.AreEqual(1, rules.Length); Assert.AreEqual("regularExpression", rules[0].ValidationType); Assert.AreEqual(1, rules[0].ValidationParameters.Count); Assert.AreEqual("the_pattern", rules[0].ValidationParameters["pattern"]); Assert.AreEqual(@"The field Length must match the regular expression 'the_pattern'.", rules[0].ErrorMessage); }
/// <param name="type">Type of ValidationAttribute to use.</param> /// <param name="id">Item ID of the Sitecore item to use for getting the error message string.</param> /// <param name="field">Field name of the Sitecore item to use for getting the error message string.</param> /// <param name="jsonProperties">Optional Json representation of properties to set on the validation attribute.</param> /// <param name="pattern">RegEx to be used for RegularExpressio Validations</param> public SitecoreValidationAttribute(Type type, string id, string field, string jsonProperties = null, string pattern = null) : base() { if (type == typeof(RegularExpressionAttribute)) { InnerValidationAttribute = new RegularExpressionAttribute(pattern);//Activator.CreateInstance(type) as RegularExpressionAttribute; } else { InnerValidationAttribute = Activator.CreateInstance(type) as ValidationAttribute; } _type = type; _id = id; _field = field; _jsonProperties = jsonProperties; SetErrorMessage(); if (!string.IsNullOrWhiteSpace(_jsonProperties)) SetProperties(); }
private ModelValidator GetValidator(ModelMetadata metadata, ControllerContext context, ValidatorData item) { DataAnnotationsModelValidationFactory factory; if (item.GetType().Name == "NotNullValidatorData") { ValidationAttribute attribute = new RequiredAttribute { ErrorMessage = item.MessageTemplate }; if (AttributeFactories.TryGetValue(attribute.GetType(), out factory)) return factory(metadata, context, attribute); } else if (item.GetType().Name == "RegexValidatorData") { RegexValidatorData regexData = (RegexValidatorData)item; RegularExpressionAttribute regexAttribute = new RegularExpressionAttribute(regexData.Pattern) { ErrorMessage = item.GetMessageTemplate() }; if (AttributeFactories.TryGetValue(regexAttribute.GetType(), out factory)) return factory(metadata, context, regexAttribute); } return null; }
public override ModelValidator Create( IStorageValidator validator, Type defaultResourceType, ModelMetadata metadata, ControllerContext context) { StorageValidator<string> vldtr = validator as StorageValidator<string>; if (vldtr == null) throw new System.IO.InvalidDataException( "Validator value must be of type StorageValidator<string>."); //string regExp = null;// xmlElement.GetValueOrNull("regexp"); //try //{ // regExp = validator.data.regExp; //} //catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException) //{ // throw new System.IO.InvalidDataException( // string.Format("The regular expression was not set. Element: {0}", validator.Name)); //} var attribute = new RegularExpressionAttribute(vldtr.data); this.BindErrorMessageToAttribte(attribute, validator, defaultResourceType); return new RegularExpressionAttributeAdapter(metadata, context, attribute); }
/// <summary> /// Initializes a new instance of the <see cref="LocalizedRegularExpressionAttributeAdapter"/> class. /// </summary> /// <param name="metadata">The model metadata.</param> /// <param name="context">The controller context.</param> /// <param name="attribute">The <see cref="RegularExpressionAttribute"/> attribute.</param> public LocalizedRegularExpressionAttributeAdapter(ModelMetadata metadata, ControllerContext context, RegularExpressionAttribute attribute) : base(metadata, context, attribute) { }
public void CreateWithRegularExpressionAttributeRequestReturnsCorrectResult(string pattern) { // Fixture setup var regularExpressionAttribute = new RegularExpressionAttribute(pattern); var providedAttribute = new ProvidedAttribute(regularExpressionAttribute, true); ICustomAttributeProvider request = new FakeCustomAttributeProvider(providedAttribute); var expectedRequest = new RegularExpressionRequest(regularExpressionAttribute.Pattern); var expectedResult = new object(); var context = new DelegatingSpecimenContext { #pragma warning disable 618 OnResolve = r => expectedRequest.Equals(r) ? expectedResult : new NoSpecimen(r) #pragma warning restore 618 }; var sut = new RegularExpressionAttributeRelay(); // Exercise system var result = sut.Create(request, context); // Verify outcome Assert.Equal(expectedResult, result); // Teardown }
protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes) { List<ModelValidator> vals = base.GetValidators(metadata, context, attributes).ToList(); DataAnnotationsModelValidationFactory factory; // Inject our new validator. if (metadata.ContainerType != null) { // Check if we have validation for this class name. if (ValidationManager.Validators.ContainsKey(metadata.ContainerType.Name)) { var validator = ValidationManager.Validators[metadata.ContainerType.Name]; // Check if we have validation for this property name. if (validator.ContainsKey(metadata.PropertyName)) { var property = validator[metadata.PropertyName]; // Only add validation to visible properties. if (property.Visible) { // Required attribute. if (property.Required) { ValidationAttribute required; if (metadata.ModelType == typeof(bool)) { // For required booleans, enforce true. required = new EnforceTrueAttribute { ErrorMessage = property.ErrorMessage }; } else if (metadata.ModelType == typeof(int) || metadata.ModelType == typeof(long) || metadata.ModelType == typeof(double) || metadata.ModelType == typeof(float)) { // For required int, long, double, float (dropdownlists), enforce > 0. required = new GreaterThanZeroAttribute() { ErrorMessage = property.ErrorMessage }; } else { required = new RequiredAttribute { ErrorMessage = property.ErrorMessage }; } if (!AttributeFactories.TryGetValue(required.GetType(), out factory)) { factory = DefaultAttributeFactory; } yield return factory(metadata, context, required); } // Regular expression attribute. if (!string.IsNullOrEmpty(property.RegularExpression)) { RegularExpressionAttribute regEx = new RegularExpressionAttribute(property.RegularExpression) { ErrorMessage = property.ErrorMessage }; if (!AttributeFactories.TryGetValue(regEx.GetType(), out factory)) { factory = DefaultAttributeFactory; } yield return factory(metadata, context, regEx); } // Compare attribute. if (!string.IsNullOrEmpty(property.Compare)) { CompareAttribute compare = new CompareAttribute(property.Compare) { ErrorMessage = property.ErrorMessage }; if (!AttributeFactories.TryGetValue(compare.GetType(), out factory)) { factory = DefaultAttributeFactory; } yield return factory(metadata, context, compare); } } } } } }
public void IsPhoneNumberValidTests() { var attribute = new RegularExpressionAttribute(Expressions.PhoneNumber); Assert.IsTrue(attribute.IsValid(null)); Assert.IsTrue(attribute.IsValid(string.Empty)); Assert.IsTrue(attribute.IsValid("1234567")); Assert.IsTrue(attribute.IsValid("20 24559715 1")); Assert.IsTrue(attribute.IsValid("123456789")); Assert.IsTrue(attribute.IsValid("+1(234)4567789")); Assert.IsTrue(attribute.IsValid("+235 7789")); Assert.IsTrue(attribute.IsValid("00 27 238.40320")); Assert.IsTrue(attribute.IsValid("0011 87 9854 23")); Assert.IsTrue(attribute.IsValid("011 777899 854-2356")); Assert.IsTrue(attribute.IsValid("0011 (87) 9854 23")); Assert.IsTrue(attribute.IsValid("011 (777899) 854-2356")); Assert.IsTrue(attribute.IsValid("07778542356")); Assert.IsTrue(attribute.IsValid("1.234.567-0000")); Assert.IsTrue(attribute.IsValid("1/23/56/000")); Assert.IsTrue(attribute.IsValid("1/2/5/0")); Assert.IsTrue(attribute.IsValid("4408 0412 3456 7890")); Assert.IsTrue(attribute.IsValid("00")); Assert.IsTrue(attribute.IsValid(12)); Assert.IsTrue(attribute.IsValid(123)); Assert.IsTrue(attribute.IsValid(1234567890)); Assert.IsFalse(attribute.IsValid("1/2/")); Assert.IsFalse(attribute.IsValid("1/23/56/000-")); Assert.IsFalse(attribute.IsValid("-1/23/56/000")); Assert.IsFalse(attribute.IsValid("a")); Assert.IsFalse(attribute.IsValid("0")); Assert.IsFalse(attribute.IsValid("+0")); Assert.IsFalse(attribute.IsValid("+00 27 238.40320")); Assert.IsFalse(attribute.IsValid("+0011 (87) 9854 23")); Assert.IsFalse(attribute.IsValid("+011 (777899) 854-2356")); Assert.IsFalse(attribute.IsValid("+07778542356")); Assert.IsFalse(attribute.IsValid(0)); }
/// <summary> /// Initializes a new instance of the <see cref="RegexValidatorAdapter"/> class. /// </summary> /// <param name="attribute">The attribute.</param> /// <param name="descriptor">The descriptor.</param> public RegexValidatorAdapter(RegularExpressionAttribute attribute, PropertyDescriptor descriptor) : base("Regex", attribute, descriptor) { }
/// <summary> /// Creates the validator. /// </summary> /// <param name="modelMetadata">The model metadata.</param> /// <param name="context">The context.</param> /// <returns></returns> protected override ModelValidator CreateValidatorCore(ExtendedModelMetadata modelMetadata, ControllerContext context) { var attribute = new RegularExpressionAttribute(Pattern); PopulateErrorMessage(attribute); return new RegularExpressionAttributeAdapter(modelMetadata, context, attribute); }
public static void Can_construct_and_get_pattern() { var attribute = new RegularExpressionAttribute("SomePattern"); Assert.Equal("SomePattern", attribute.Pattern); }
public static void Validate_successful_for_null_or_empty_value() { var attribute = new RegularExpressionAttribute("SomePattern"); AssertEx.DoesNotThrow(() => attribute.Validate(null, s_testValidationContext)); // Null is valid AssertEx.DoesNotThrow(() => attribute.Validate(string.Empty, s_testValidationContext)); // Empty string is valid }
public static void Can_set_and_get_MatchTimeout() { var attribute = new RegularExpressionAttribute("SomePattern"); attribute.MatchTimeoutInMilliseconds = 12345; Assert.Equal(12345, attribute.MatchTimeoutInMilliseconds); }
public static void Can_construct_and_get_pattern() { var attribute = new RegularExpressionAttribute("SomePattern"); Assert.Equal("SomePattern", attribute.Pattern); }
private static IRegExFacet Create(RegularExpressionAttribute attribute, IFacetHolder holder) { return new RegExFacetAnnotation(attribute.Pattern, string.Empty, true, attribute.ErrorMessage, holder); }
public void Setup() { var attribute1 = new StringLengthAttribute(5); attribute1.ErrorMessage = "length"; var attribute2 = new RegularExpressionAttribute("a*"); attribute2.ErrorMessage = "regex"; this.validator = new ValidationAttributeValidator(attribute1, attribute2); }
public static string GetRegExErrorMessage(string pattern, string field) { var attr = new RegularExpressionAttribute(pattern); return attr.FormatErrorMessage(field); }