public void MultipleAddedValueValidatorsAreIncludedInResultingValidatorForAndCompositionIgnoringNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
MockValidator <object> failingValueValidator = new MockValidator <object>(true);
MockValidator <object> succeedingValueValidator = new MockValidator <object>(false);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(true, null, null, CompositionType.And, null, null));
builder.AddValueValidator(failingValueValidator);
builder.AddValueValidator(succeedingValueValidator);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
// does it validate nonnull values?
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, failingValueValidator.ValidatedTargets[0]);
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, succeedingValueValidator.ValidatedTargets[0]);
// does it ignore nulls? it should
valueAccess.Value = null;
validationResults = validator.Validate(this);
Assert.IsTrue(validationResults.IsValid); // null value is ignored so validation succeeds
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count); // no changes
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count); // no changes
}
public void CreateValidatorForExistingTypeReturnsNonEmptyValidatorBasedOnRuleDefinition()
{
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(TestClass));
ValidationRulesetData ruleData = new ValidationRulesetData("ruleset1");
typeReference.Rulesets.Add(ruleData);
ValidatedMethodReference methodReference1 = new ValidatedMethodReference("PublicMethod");
ruleData.Methods.Add(methodReference1);
ValidatedMethodReference methodReference2 = new ValidatedMethodReference("NonPublicMethod");
ruleData.Methods.Add(methodReference2);
methodReference1.Validators.Add(new MockValidatorData("validator1", false));
methodReference1.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference2.Validators.Add(new MockValidatorData("validator2", false));
methodReference2.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = this.builder.CreateValidator(typeof(TestClass), typeReference, "ruleset1");
Assert.IsNotNull(validator);
Assert.AreSame(typeof(AndCompositeValidator), validator.GetType());
IList <Validator> validators = ValidationTestHelper.CreateListFromEnumerable(((AndCompositeValidator)validator).Validators);
Assert.AreEqual(1, validators.Count);
Assert.AreEqual(1, this.mockFactory.requestedMembers.Count);
ValueAccessValidatorBuilder valueAccessValidatorBuilder1 = this.mockFactory.requestedMembers["TestClass.PublicMethod"];
Assert.AreSame(valueAccessValidatorBuilder1.BuiltValidator, validators[0]);
Assert.AreEqual(1, valueAccessValidatorBuilder1.ValueValidators.Count);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder1.ValueValidators[0]).MessageTemplate);
}
public void AddedValueValidatorIsIncludedInResultingValidatorForAndWithoutNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
MockValidator <object> failingValueValidator = new MockValidator <object>(true);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(false, null, null, CompositionType.And, null, null));
builder.AddValueValidator(failingValueValidator);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
// does it validate nonnullvalues?
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, failingValueValidator.ValidatedTargets[0]);
// does it ignore nulls? it should not
valueAccess.Value = null;
validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(2, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(null, failingValueValidator.ValidatedTargets[1]);
}
public void CreateValidatorForDefaultRuleForExistingTypeReturnsNonEmptyValidatorBasedOnDefaultRuleDefinition()
{
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(TestClass));
typeReference.DefaultRuleset = "ruleset1";
ValidationRulesetData ruleData = new ValidationRulesetData("ruleset1");
typeReference.Rulesets.Add(ruleData);
ValidatedMethodReference methodReference1 = new ValidatedMethodReference("PublicMethod");
ruleData.Methods.Add(methodReference1);
ValidatedMethodReference methodReference2 = new ValidatedMethodReference("NonPublicMethod");
ruleData.Methods.Add(methodReference2);
methodReference1.Validators.Add(new MockValidatorData("validator1", false));
methodReference1.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference2.Validators.Add(new MockValidatorData("validator2", false));
methodReference2.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = builder.CreateValidator(typeof(TestClass), typeReference, string.Empty);
Assert.IsNotNull(validator);
Assert.AreSame(typeof(ValueAccessValidator), validator.GetType());
ValueAccessValidatorBuilder valueAccessValidatorBuilder1 = mockFactory.requestedMembers["TestClass.PublicMethod"];
Assert.AreSame(valueAccessValidatorBuilder1.BuiltValidator, validator);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder1.ValueValidators[0]).MessageTemplate);
}
public void CreateValidatorForRuleWithMethodReferenceReturnsCompositeValidatorWithMethodValueAccess()
{
ValidationRulesetData ruleData = new ValidationRulesetData();
ValidatedMethodReference methodReference1 = new ValidatedMethodReference("PublicMethod");
ruleData.Methods.Add(methodReference1);
ValidatedMethodReference methodReference2 = new ValidatedMethodReference("SecondPublicMethod");
ruleData.Methods.Add(methodReference2);
methodReference1.Validators.Add(new MockValidatorData("validator1", false));
methodReference1.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference2.Validators.Add(new MockValidatorData("validator2", false));
methodReference2.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = builder.CreateValidatorForRule(typeof(TestClass), ruleData);
Assert.IsNotNull(validator);
Assert.AreSame(typeof(AndCompositeValidator), validator.GetType());
IList <Validator> validators = ValidationTestHelper.CreateListFromEnumerable(((AndCompositeValidator)validator).Validators);
Assert.AreEqual(2, validators.Count);
Assert.AreEqual(2, mockFactory.requestedMembers.Count);
ValueAccessValidatorBuilder valueAccessValidatorBuilder1 = mockFactory.requestedMembers["TestClass.PublicMethod"];
Assert.AreSame(valueAccessValidatorBuilder1.BuiltValidator, validators[0]);
Assert.AreEqual(1, valueAccessValidatorBuilder1.ValueValidators.Count);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder1.ValueValidators[0]).MessageTemplate);
ValueAccessValidatorBuilder valueAccessValidatorBuilder2 = mockFactory.requestedMembers["TestClass.SecondPublicMethod"];
Assert.AreSame(valueAccessValidatorBuilder2.BuiltValidator, validators[1]);
Assert.AreEqual(1, valueAccessValidatorBuilder2.ValueValidators.Count);
Assert.AreEqual("validator 2 message", ((MockValidator <object>)valueAccessValidatorBuilder2.ValueValidators[0]).MessageTemplate);
}
public void CreateValidatorForRuleWithInvalidFieldReferenceIgnoresInvalidField()
{
ValidationRulesetData ruleData = new ValidationRulesetData();
ValidatedFieldReference fieldReference1 = new ValidatedFieldReference("PublicField");
ruleData.Fields.Add(fieldReference1);
ValidatedFieldReference fieldReference2 = new ValidatedFieldReference("NonPublicField");
ruleData.Fields.Add(fieldReference2);
fieldReference1.Validators.Add(new MockValidatorData("validator1", false));
fieldReference1.Validators.Get("validator1").MessageTemplate = "validator 1 message";
fieldReference2.Validators.Add(new MockValidatorData("validator2", false));
fieldReference2.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = this.builder.CreateValidatorForRule(typeof(TestClass), ruleData);
Assert.IsNotNull(validator);
Assert.AreSame(typeof(AndCompositeValidator), validator.GetType());
IList <Validator> validators = ValidationTestHelper.CreateListFromEnumerable(((AndCompositeValidator)validator).Validators);
Assert.AreEqual(1, validators.Count);
Assert.AreEqual(1, this.mockFactory.requestedMembers.Count);
ValueAccessValidatorBuilder valueAccessValidatorBuilder1 = this.mockFactory.requestedMembers["TestClass.PublicField"];
Assert.AreSame(valueAccessValidatorBuilder1.BuiltValidator, validators[0]);
Assert.AreEqual(1, valueAccessValidatorBuilder1.ValueValidators.Count);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder1.ValueValidators[0]).MessageTemplate);
}
public void MultipleAddedValueValidatorsAreIncludedInResultingValidatorForAndCompositionNotIgnoringNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
MockValidator<object> failingValueValidator = new MockValidator<object>(true);
MockValidator<object> succeedingValueValidator = new MockValidator<object>(false);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(false, null, null, CompositionType.And, null, null));
builder.AddValueValidator(failingValueValidator);
builder.AddValueValidator(succeedingValueValidator);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
// does it validate nonnullvalues?
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, failingValueValidator.ValidatedTargets[0]);
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, succeedingValueValidator.ValidatedTargets[0]);
// does it ignore nulls? it should not
valueAccess.Value = null;
validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(2, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(null, failingValueValidator.ValidatedTargets[1]);
Assert.AreEqual(2, succeedingValueValidator.ValidatedTargets.Count);
Assert.AreSame(null, succeedingValueValidator.ValidatedTargets[1]);
}
public override ValueAccessValidatorBuilder GetPropertyValueAccessValidatorBuilder(PropertyInfo propertyInfo,
IValidatedElement validatedElement)
{
ValueAccessValidatorBuilder validatorBuilder = base.GetPropertyValueAccessValidatorBuilder(propertyInfo,
validatedElement);
this.requestedMembers.Add(propertyInfo.DeclaringType.Name + "." + propertyInfo.Name, validatorBuilder);
return(validatorBuilder);
}
public override ValueAccessValidatorBuilder GetMethodValueAccessValidatorBuilder(MethodInfo methodInfo,
IValidatedElement validatedElement)
{
ValueAccessValidatorBuilder validatorBuilder = base.GetMethodValueAccessValidatorBuilder(methodInfo,
validatedElement);
this.requestedMembers.Add(methodInfo.DeclaringType.Name + "." + methodInfo.Name, validatorBuilder);
return(validatorBuilder);
}
public void CanGetValidatorFromNewBuilderInstanceForAndWithoutNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(false, null, null, CompositionType.And, null, null));
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
}
public void CanGetValidatorFromNewBuilderInstanceForAndWithoutNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(false, null, null, CompositionType.And, null, null));
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
}
public void CreateValidatorForPropertyReferenceWithValidatorsReturnsValueAccessValidator()
{
ValidatedPropertyReference propertyReference = new ValidatedPropertyReference("PublicProperty");
propertyReference.Validators.Add(new MockValidatorData("validator1", false));
propertyReference.Validators.Get("validator1").MessageTemplate = "validator 1 message";
propertyReference.Validators.Add(new MockValidatorData("validator2", false));
propertyReference.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = builder.CreateValidatorForProperty(typeof(TestClass), propertyReference);
Assert.IsNotNull(validator);
Assert.AreEqual(1, mockFactory.requestedMembers.Count);
ValueAccessValidatorBuilder valueAccessValidatorBuilder = mockFactory.requestedMembers["TestClass.PublicProperty"];
Assert.AreSame(valueAccessValidatorBuilder.BuiltValidator, validator);
Assert.AreEqual(2, valueAccessValidatorBuilder.ValueValidators.Count);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder.ValueValidators[0]).MessageTemplate);
Assert.AreEqual("validator 2 message", ((MockValidator <object>)valueAccessValidatorBuilder.ValueValidators[1]).MessageTemplate);
}
public void CreateValidatorForDefaultPropertyForExistingTypeInConfigurationRetunsAppropriateValidatorBasedOnRule()
{
ValidationSettings settings = new ValidationSettings();
configurationSource.Add(ValidationSettings.SectionName, settings);
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(TestClass));
settings.Types.Add(typeReference);
typeReference.DefaultRuleset = "ruleset1";
ValidationRulesetData ruleData = new ValidationRulesetData("ruleset1");
typeReference.Rulesets.Add(ruleData);
ValidatedMethodReference methodReference1 = new ValidatedMethodReference("PublicMethod");
ruleData.Methods.Add(methodReference1);
ValidatedMethodReference methodReference2 = new ValidatedMethodReference("NonPublicMethod");
ruleData.Methods.Add(methodReference2);
methodReference1.Validators.Add(new MockValidatorData("validator1", false));
methodReference1.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference2.Validators.Add(new MockValidatorData("validator2", false));
methodReference2.Validators.Get("validator2").MessageTemplate = "validator 2 message";
// Note: Use a local builder here since the assumption was made about how and when the
// the builder uses the configuration source....
var localBuilder =
ConfigurationValidatorBuilder.FromConfiguration(
configurationSource,
mockFactory,
ValidationFactory.DefaultCompositeValidatorFactory);
Validator validator = localBuilder.CreateValidator(typeof(TestClass), string.Empty);
Assert.IsNotNull(validator);
Assert.AreSame(typeof(ValueAccessValidator), validator.GetType());
ValueAccessValidatorBuilder valueAccessValidatorBuilder1 = mockFactory.requestedMembers["TestClass.PublicMethod"];
Assert.AreSame(valueAccessValidatorBuilder1.BuiltValidator, validator);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder1.ValueValidators[0]).MessageTemplate);
}
public void CreateValidatorForRuleWithInvalidMethodReferenceIgnoresInvalidMethod()
{
ValidationRulesetData ruleData = new ValidationRulesetData();
ValidatedMethodReference methodReference1 = new ValidatedMethodReference("PublicMethod");
ruleData.Methods.Add(methodReference1);
ValidatedMethodReference methodReference2 = new ValidatedMethodReference("NonPublicMethod");
ruleData.Methods.Add(methodReference2);
methodReference1.Validators.Add(new MockValidatorData("validator1", false));
methodReference1.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference2.Validators.Add(new MockValidatorData("validator2", false));
methodReference2.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = builder.CreateValidatorForRule(typeof(TestClass), ruleData);
Assert.IsNotNull(validator);
Assert.AreSame(typeof(ValueAccessValidator), validator.GetType());
ValueAccessValidatorBuilder valueAccessValidatorBuilder1 = mockFactory.requestedMembers["TestClass.PublicMethod"];
Assert.AreSame(valueAccessValidatorBuilder1.BuiltValidator, validator);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder1.ValueValidators[0]).MessageTemplate);
}
public void CreateValidatorForDefaultPropertyForExistingTypeInConfigurationRetunsAppropriateValidatorBasedOnRule()
{
ValidationSettings settings = new ValidationSettings();
this.configurationSource.Add(ValidationSettings.SectionName, settings);
ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(TestClass));
settings.Types.Add(typeReference);
typeReference.DefaultRuleset = "ruleset1";
ValidationRulesetData ruleData = new ValidationRulesetData("ruleset1");
typeReference.Rulesets.Add(ruleData);
ValidatedMethodReference methodReference1 = new ValidatedMethodReference("PublicMethod");
ruleData.Methods.Add(methodReference1);
ValidatedMethodReference methodReference2 = new ValidatedMethodReference("NonPublicMethod");
ruleData.Methods.Add(methodReference2);
methodReference1.Validators.Add(new MockValidatorData("validator1", false));
methodReference1.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference2.Validators.Add(new MockValidatorData("validator2", false));
methodReference2.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = this.builder.CreateValidator(typeof(TestClass), string.Empty);
Assert.IsNotNull(validator);
Assert.AreSame(typeof(AndCompositeValidator), validator.GetType());
IList <Validator> validators = ValidationTestHelper.CreateListFromEnumerable(((AndCompositeValidator)validator).Validators);
Assert.AreEqual(1, validators.Count);
Assert.AreEqual(1, this.mockFactory.requestedMembers.Count);
ValueAccessValidatorBuilder valueAccessValidatorBuilder1 = this.mockFactory.requestedMembers["TestClass.PublicMethod"];
Assert.AreSame(valueAccessValidatorBuilder1.BuiltValidator, validators[0]);
Assert.AreEqual(1, valueAccessValidatorBuilder1.ValueValidators.Count);
Assert.AreEqual("validator 1 message", ((MockValidator <object>)valueAccessValidatorBuilder1.ValueValidators[0]).MessageTemplate);
}
public void MultipleAddedValueValidatorsAreIncludedInResultingValidatorForOrCompositionIgnoringNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
MockValidator<object> failingValueValidator = new MockValidator<object>(true);
MockValidator<object> succeedingValueValidator = new MockValidator<object>(false);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(true, null, null, CompositionType.Or, null, null));
builder.AddValueValidator(failingValueValidator);
builder.AddValueValidator(succeedingValueValidator);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
// does it validate nonnullvalues?
ValidationResults validationResults = validator.Validate(this);
Assert.IsTrue(validationResults.IsValid); // it's an OR validator
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, failingValueValidator.ValidatedTargets[0]);
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, succeedingValueValidator.ValidatedTargets[0]);
// does it ignore nulls? it should
valueAccess.Value = null;
validationResults = validator.Validate(this);
Assert.IsTrue(validationResults.IsValid); // null value is ignored so validation succeeds
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count); // no changes
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count); // no changes
}
