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 }