private static Validator CreateValidator(Type targetType, string ruleset, IConfigurationSource configurationSource, bool cacheValidator)
{
Validator wrapperValidator = null;
if (cacheValidator)
{
lock (attributeAndDefaultConfigurationValidatorsCacheLock)
{
ValidatorCacheKey key = new ValidatorCacheKey(targetType, ruleset, false);
Validator cachedValidator;
if (attributeAndDefaultConfigurationValidatorsCache.TryGetValue(key, out cachedValidator))
{
return(cachedValidator);
}
Validator validator = new AndCompositeValidator(InnerCreateValidatorFromAttributes(targetType, ruleset),
InnerCreateValidatorFromConfiguration(targetType, ruleset, configurationSource));
wrapperValidator = WrapAndInstrumentValidator(validator, configurationSource);
attributeAndDefaultConfigurationValidatorsCache[key] = wrapperValidator;
}
}
else
{
Validator validator = new AndCompositeValidator(InnerCreateValidatorFromAttributes(targetType, ruleset),
InnerCreateValidatorFromConfiguration(targetType, ruleset, configurationSource));
wrapperValidator = WrapAndInstrumentValidator(validator, configurationSource);
}
return(wrapperValidator);
}
public void ValidationRequestWithNullSuppliedValidationResultsThrows()
{
Validator validator = new AndCompositeValidator();
string target = new string('a', 10); // just any string, but a new one
validator.Validate(target, null);
}
protected virtual Validator DoGetValidator()
{
Validator validator;
if (this.valueValidators.Count == 1)
{
validator = this.valueValidators[0];
}
else if (this.validatedElement.CompositionType == CompositionType.And)
{
validator = new AndCompositeValidator(this.valueValidators.ToArray());
}
else
{
validator = new OrCompositeValidator(this.valueValidators.ToArray())
{
MessageTemplate = this.validatedElement.CompositionMessageTemplate,
Tag = this.validatedElement.CompositionTag
};
}
if (this.validatedElement.IgnoreNulls)
{
return(new OrCompositeValidator(new Validator[] { new NotNullValidator(true), validator })
{
MessageTemplate = (this.validatedElement.IgnoreNullsMessageTemplate != null) ? this.validatedElement.IgnoreNullsMessageTemplate : Resources.IgnoreNullsDefaultMessageTemplate, Tag = this.validatedElement.IgnoreNullsTag
});
}
return(validator);
}
/// <summary>
/// Creates the composite validator built by the builder.
/// </summary>
protected virtual Validator DoGetValidator()
{
// create appropriate composite validator
Validator compositeValidator;
if (CompositionType.And == this.validatedElement.CompositionType)
{
compositeValidator = new AndCompositeValidator(this.valueValidators.ToArray());
}
else
{
compositeValidator = new OrCompositeValidator(this.valueValidators.ToArray());
compositeValidator.MessageTemplate = this.validatedElement.CompositionMessageTemplate;
compositeValidator.Tag = this.validatedElement.CompositionTag;
}
// add support for ignoring nulls
Validator valueValidator;
if (this.validatedElement.IgnoreNulls)
{
valueValidator = new OrCompositeValidator(new NotNullValidator(true), compositeValidator);
valueValidator.MessageTemplate = this.validatedElement.IgnoreNullsMessageTemplate != null
? this.validatedElement.IgnoreNullsMessageTemplate
: Resources.IgnoreNullsDefaultMessageTemplate;
valueValidator.Tag = this.validatedElement.IgnoreNullsTag;
}
else
{
valueValidator = compositeValidator;
}
return(valueValidator);
}
internal static Validator GetPropertyValidator(Type type, PropertyInfo propertyInfo,
string ruleset, MemberAccessValidatorBuilderFactory memberAccessValidatorBuilderFactory)
{
Validator validator = null;
lock (attributeAndDefaultConfigurationPropertyValidatorsCacheLock)
{
PropertyValidatorCacheKey key = new PropertyValidatorCacheKey(type, propertyInfo.Name, ruleset);
if (!attributeAndDefaultConfigurationPropertyValidatorsCache.TryGetValue(key, out validator))
{
Validator attributesValidator = GetPropertyValidatorFromAttributes(type, propertyInfo, ruleset, memberAccessValidatorBuilderFactory);
Validator configurationValidator = GetPropertyValidatorFromConfiguration(type, propertyInfo, ruleset, memberAccessValidatorBuilderFactory);
if (null != attributesValidator && null != configurationValidator)
{
validator = new AndCompositeValidator(attributesValidator, configurationValidator);
}
else if (null != attributesValidator)
{
validator = attributesValidator;
}
else
{
validator = configurationValidator;
}
attributeAndDefaultConfigurationPropertyValidatorsCache[key] = validator;
}
}
return(validator);
}
public void ReturnsSuccessIfAllValidatorsReturnSuccess()
{
MockValidator <string> subValidator1 = new MockValidator <string>(false, "validator1");
MockValidator <string> subValidator2 = new MockValidator <string>(false, "validator2");
MockValidator <string> subValidator3 = new MockValidator <string>(false, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = validator.Validate(target);
Assert.IsTrue(validationResults.IsValid);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void GetValidatorTest()
{
Type type = typeof(Person);
string propertyName = "Name"; // TODO: Initialize to an appropriate value
Validator expected = new AndCompositeValidator(new NotNullValidator()); // TODO: Initialize to an appropriate value
Validator actual;
actual = ReflcationClassProperty.GetValidator(type, propertyName);
Assert.IsTrue(actual is AndCompositeValidator);
var actualValidator = actual as AndCompositeValidator;
var children = new List <Validator>(actualValidator.ListValidator);
Assert.IsTrue(children.Count == 1);
Assert.IsTrue(children[0] is NotNullValidator);
}
public void TestMethod1()
{
Customer myCustomer = new Customer()
{
firstName = " A Name tat is too long for the validation"
};
Validator shortStringValidator = new AndCompositeValidator(new NotNullValidator(), new StringLengthValidator(1, 50));
ValidationResults r = shortStringValidator.Validate(myCustomer.firstName);
//ValidationResults r = Validation.Validate<Customer>(myCustomer);
if (!r.IsValid)
{
throw new InvalidOperationException("Validation error found.");
}
}
public IValidationResult Validate()
{
if (!IsOverriden)
{
//MS Validation
Validator NotNullStringLengthValidator = new AndCompositeValidator(this.msNotNullValidator, this.msStringLengthValidator);
ValidationResults valResults = NotNullStringLengthValidator.Validate(Customer.customerNumber);
if (!valResults.IsValid) //if not valid
{
RuleValidationResult = new MyValidationResult();
RuleValidationResult.ValidationMessageList.Add(new NullValidationMessage());
}
if (Customer.EmailList != null)
{
//Some other Random Test Validation. RegexValidator in this case
Validator <string> emailAddresssValidator = new RegexValidator(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
valResults = emailAddresssValidator.Validate(Customer.EmailList.First());
}
else
{
valResults = this.msNotNullValidator.Validate(Customer.EmailList);
}
//Holidays Own Validation
//RuleValidationResult = valResults;
if (valResults != null)
{
RuleValidationResult = new MyValidationResult();
foreach (var varRes in valResults)
{
IValidationMessage val = new MSWrapperMessage(MessageTypes.Error, varRes.Message);
RuleValidationResult.ValidationMessageList.Add(val);
}
}
}
return(RuleValidationResult);
}
private static bool CompositeHasValidators(Validator validator)
{
AndCompositeValidator andValidator = validator as AndCompositeValidator;
if (andValidator != null)
{
return(((Validator[])andValidator.Validators).Length > 0);
}
OrCompositeValidator orValidator = validator as OrCompositeValidator;
if (orValidator != null)
{
return(((Validator[])orValidator.Validators).Length > 0);
}
return(false);
}
public void ReturnsFailureAfterQueryingAllValidatorsIfOneValidatorReturnFailure()
{
MockValidator <string> subValidator1 = new MockValidator <string>(false, "validator1");
MockValidator <string> subValidator2 = new MockValidator <string>(true, "validator2");
MockValidator <string> subValidator3 = new MockValidator <string>(false, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = validator.Validate(target);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("validator2", resultsList[0].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void ReturnsCompositeFailureWhenValidatingNullAfterQueryingAllValidatorsIfManyValidatorsReturnFailure()
{
MockValidator <string> subValidator1 = new MockValidator <string>(false, "validator1");
MockValidator <string> subValidator2 = new MockValidator <string>(true, "validator2");
MockValidator <string> subValidator3 = new MockValidator <string>(true, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = null;
ValidationResults validationResults = validator.Validate(target);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(2, resultsList.Count);
Assert.AreEqual("validator2", resultsList[0].Message);
Assert.AreEqual("validator3", resultsList[1].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public Validator GetValidator()
{
Validator valiator = null;
if (ListValidator.Count == 1)
{
valiator = ListValidator[0];
}
else
if (CompositType == CompositaionType.AND)
{
valiator = new AndCompositeValidator(ListValidator.ToArray());
}
else
if (CompositType == CompositaionType.OR)
{
valiator = new OrCompositeValidator(ListValidator.ToArray());
}
return(valiator);
}
public void CreatedAndCompositeValidatorFromAttributesWithPropertiesAppropiately()
{
Validator validator = ValidationFactory.CreateValidator(typeof(MockClassWithValidatorAttributesOnProperties), "");
Assert.IsNotNull(validator);
Assert.AreSame(typeof(GenericValidatorWrapper <MockClassWithValidatorAttributesOnProperties>), validator.GetType());
var validatorWrapper = validator as GenericValidatorWrapper <MockClassWithValidatorAttributesOnProperties>;
AndCompositeValidator compositeValidator = validatorWrapper.WrappedValidator as AndCompositeValidator;
Assert.IsNotNull(compositeValidator);
IList <Validator> allValidators = ValidationTestHelper.CreateListFromEnumerable <Validator>(compositeValidator.Validators);
Assert.AreEqual(2, allValidators.Count);
Assert.AreEqual(typeof(ValueAccessValidator), allValidators[0].GetType());
Assert.AreEqual(typeof(ValueAccessValidator), allValidators[1].GetType());
}
public void CanPerformValidationWithSuppliedValidationResults()
{
MockValidator <string> subValidator1 = new MockValidator <string>(false, "validator1");
MockValidator <string> subValidator2 = new MockValidator <string>(true, "validator2");
MockValidator <string> subValidator3 = new MockValidator <string>(false, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = new string('a', 10);// just any string, but a new one
ValidationResults validationResults = new ValidationResults();
validator.Validate(target, validationResults);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("validator2", resultsList[0].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void CreatedAndCompositeValidatorFromConfigAppropiately()
{
DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource();
ValidationSettings settings = new ValidationSettings();
configurationSource.Add(ValidationSettings.SectionName, settings);
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(BaseTestDomainObject));
settings.Types.Add(typeReference);
ValidationRulesetData ruleData = new ValidationRulesetData("RuleA");
typeReference.Rulesets.Add(ruleData);
ValidatedPropertyReference propertyReference1 = new ValidatedPropertyReference("Property1");
ruleData.Properties.Add(propertyReference1);
MockValidatorData validator11 = new MockValidatorData("validator1", true);
propertyReference1.Validators.Add(validator11);
validator11.MessageTemplate = "message-from-config1-RuleA";
ValidatedPropertyReference propertyReference2 = new ValidatedPropertyReference("Property2");
ruleData.Properties.Add(propertyReference2);
propertyReference2.Validators.Add(validator11);
Validator validator
= ValidationFactory.CreateValidatorFromConfiguration(typeof(BaseTestDomainObject), "RuleA", (IConfigurationSource)configurationSource);
var validatorWrapper = validator as GenericValidatorWrapper <BaseTestDomainObject>;
AndCompositeValidator compositeValidator = validatorWrapper.WrappedValidator as AndCompositeValidator;
Assert.IsNotNull(compositeValidator);
IList <Validator> allValidators = ValidationTestHelper.CreateListFromEnumerable <Validator>(compositeValidator.Validators);
Assert.AreEqual(2, allValidators.Count);
Assert.AreEqual(typeof(ValueAccessValidator), allValidators[0].GetType());
Assert.AreEqual(typeof(ValueAccessValidator), allValidators[1].GetType());
}
public void AndCompositeValidator()
{
var v = new AndCompositeValidator(PropertyName, new List <Validator> {
new RequiredValidator(), new LengthValidator(5)
});
Assert.AreEqual(v.PropertyName, PropertyName);
var o = new SimpleObject {
SimpleProperty = "12345"
};
Assert.IsTrue(v.Validate(o));
o.SimpleProperty = null;
Assert.IsFalse(v.Validate(o));
o.SimpleProperty = "123";
Assert.IsFalse(v.Validate(o));
o.SimpleProperty = "123456";
Assert.IsFalse(v.Validate(o));
}
/// <summary>
/// Creates the composite validator built by the builder.
/// </summary>
protected virtual Validator DoGetValidator()
{
// create the appropriate validator
Validator validator;
if (this.valueValidators.Count == 1)
{
validator = this.valueValidators[0];
}
else
{
if (CompositionType.And == this.validatedElement.CompositionType)
{
validator = new AndCompositeValidator(this.valueValidators.ToArray());
}
else
{
validator = new OrCompositeValidator(this.valueValidators.ToArray());
validator.MessageTemplate = this.validatedElement.CompositionMessageTemplate;
validator.Tag = this.validatedElement.CompositionTag;
}
}
// add support for ignoring nulls
Validator valueValidator;
if (this.validatedElement.IgnoreNulls)
{
valueValidator = new NullIgnoringValidatorWrapper(validator);
}
else
{
valueValidator = validator;
}
return(valueValidator);
}
