private void BuildRuleNode(RuleSetNode ruleNode, ValidationRulesetData rule) { SelfNode selfNode = new SelfNode(); ruleNode.AddNode(selfNode); AddValidatorNodes(selfNode, rule.Validators); foreach (ValidatedFieldReference fieldReference in rule.Fields) { FieldNode fieldNode = new FieldNode(fieldReference); AddValidatorNodes(fieldNode, fieldReference.Validators); ruleNode.AddNode(fieldNode); } foreach (ValidatedPropertyReference proprtyReference in rule.Properties) { PropertyNode propertyNode = new PropertyNode(proprtyReference); AddValidatorNodes(propertyNode, proprtyReference.Validators); ruleNode.AddNode(propertyNode); } foreach (ValidatedMethodReference methodReference in rule.Methods) { MethodNode methodNode = new MethodNode(methodReference); AddValidatorNodes(methodNode, methodReference.Validators); ruleNode.AddNode(methodNode); } }
private static IConfigurationSource GetNotNullValidationConfig() { var validatorData = new NotNullValidatorData() { Name = "Not Null", MessageTemplate = "City cannot be null" }; var fieldRef = new ValidatedFieldReference() { Name = "City" }; fieldRef.Validators.Add(validatorData); var rulesetData = new ValidationRulesetData("default"); rulesetData.Fields.Add(fieldRef); var typeData = new ValidatedTypeReference(typeof(TargetAddress)); typeData.Rulesets.Add(rulesetData); typeData.DefaultRuleset = rulesetData.Name; var section = new ValidationSettings(); section.Types.Add(typeData); var configSource = new DictionaryConfigurationSource(); configSource.Add(BlockSectionNames.Validation, section); return(configSource); }
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 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 CreateValidatorForTypeWithoutValidatorConfigurationReturnsNull() { ValidationRulesetData ruleData = new ValidationRulesetData("ruleset1"); Validator validator = builder.CreateValidatorForType(typeof(TestClass), ruleData); Assert.IsNull(validator); }
public void Given() { container = new UnityContainer(); var configurationSource = new DictionaryConfigurationSource(); ValidationSettings settings = new ValidationSettings(); configurationSource.Add(ValidationSettings.SectionName, settings); ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(BaseTestDomainObject)); settings.Types.Add(typeReference); typeReference.DefaultRuleset = "RuleA"; 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"; MockValidatorData validator12 = new MockValidatorData("validator2", true); propertyReference1.Validators.Add(validator12); validator12.MessageTemplate = "message-from-config2-RuleA"; MockValidatorData validator13 = new MockValidatorData("validator3", false); propertyReference1.Validators.Add(validator13); validator13.MessageTemplate = "message-from-config3-RuleA"; var typeRegistrationProvider = new ValidationTypeRegistrationProvider(); var configurator = new UnityContainerConfigurator(container); configurator.RegisterAll(configurationSource, typeRegistrationProvider); }
internal ValidationConfigurationBuilderRuleset( ValidationConfigurationBuilderType <TEntity> builderType, ValidationRulesetData ruleset) { this.BuilderType = builderType; this.Ruleset = ruleset; }
public void CanDeserializeSerializedSectionWithTypeWithValidatorsForNamedRule() { ValidationSettings rwSettings = new ValidationSettings(); ValidatedTypeReference rwStringType = new ValidatedTypeReference(typeof(string)); rwSettings.Types.Add(rwStringType); ValidationRulesetData rwValidationRule = new ValidationRulesetData("ruleset"); rwStringType.Rulesets.Add(rwValidationRule); ValidatorData rwValidatorData = new MockValidatorData("validator1", true); rwValidationRule.Validators.Add(rwValidatorData); IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>(); sections[ValidationSettings.SectionName] = rwSettings; using (ConfigurationFileHelper configurationFileHelper = new ConfigurationFileHelper(sections)) { IConfigurationSource configurationSource = configurationFileHelper.ConfigurationSource; ValidationSettings roSettings = configurationSource.GetSection(ValidationSettings.SectionName) as ValidationSettings; Assert.IsNotNull(roSettings); Assert.AreEqual(1, roSettings.Types.Count); Assert.AreEqual(typeof(string).FullName, roSettings.Types.Get(0).Name); Assert.AreEqual(1, roSettings.Types.Get(0).Rulesets.Count); Assert.AreEqual("ruleset", roSettings.Types.Get(0).Rulesets.Get(0).Name); Assert.AreEqual(1, roSettings.Types.Get(0).Rulesets.Get(0).Validators.Count); Assert.AreEqual("validator1", roSettings.Types.Get(0).Rulesets.Get(0).Validators.Get(0).Name); Assert.AreSame(typeof(MockValidatorData), roSettings.Types.Get(0).Rulesets.Get(0).Validators.Get(0).GetType()); Assert.AreEqual(true, ((MockValidatorData)roSettings.Types.Get(0).Rulesets.Get(0).Validators.Get(0)).ReturnFailure); } }
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 RuleSetHasRuleNameAsNodeName() { ValidationRulesetData ruleData = new ValidationRulesetData("Rule"); RuleSetNode ruleSetNode = new RuleSetNode(ruleData); Assert.AreEqual("Rule", ruleSetNode.Name); }
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 CanBuildValidationInstanceFactoryFromGivenConfiguration() { DictionaryConfigurationSource configurationSource = new DictionaryConfigurationSource(); ValidationSettings settings = new ValidationSettings(); configurationSource.Add(ValidationSettings.SectionName, settings); ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(BaseTestDomainObject)); settings.Types.Add(typeReference); typeReference.DefaultRuleset = "RuleA"; 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"; ValidationFactory.SetDefaultConfigurationValidatorFactory(configurationSource); ValidatorFactory factory = ValidationFactory.DefaultCompositeValidatorFactory; var validator = factory.CreateValidator <BaseTestDomainObject>("RuleA"); var results = validator.Validate(new BaseTestDomainObject()); Assert.IsNotNull(factory); Assert.IsFalse(results.IsValid); Assert.AreEqual(validator11.MessageTemplate, results.ElementAt(0).Message); }
public void CanCreateValidatorForTypeWithMultipleValidatorConfigurations() { ValidationRulesetData ruleData = new ValidationRulesetData("ruleset1"); ruleData.Validators.Add(new MockValidatorData("validator1", false)); ruleData.Validators.Get("validator1").MessageTemplate = "validator 1 message"; ruleData.Validators.Add(new MockValidatorData("validator2", false)); ruleData.Validators.Get("validator2").MessageTemplate = "validator 2 message"; Validator validator = builder.CreateValidatorForType(typeof(TestClass), ruleData); Assert.IsNotNull(validator); CompositeValidatorBuilder compositeValidatorBuilder = mockFactory.requestedTypes["TestClass"]; Assert.IsNotNull(compositeValidatorBuilder); Assert.AreSame(compositeValidatorBuilder.BuiltValidator, validator); Assert.AreEqual(false, compositeValidatorBuilder.IgnoreNulls); Assert.AreEqual(CompositionType.And, compositeValidatorBuilder.CompositionType); IDictionary <string, MockValidator <object> > valueValidators = ValidationTestHelper.CreateMockValidatorsMapping(compositeValidatorBuilder.ValueValidators); Assert.AreEqual(2, valueValidators.Count); Assert.IsTrue(valueValidators.ContainsKey("validator 1 message")); Assert.IsTrue(valueValidators.ContainsKey("validator 2 message")); }
public void CreateValidatorForDefaultRuleForExistingTypeNonExistingDefaultRuleSetReturnsEmptyValidator() { ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(TestClass)); typeReference.DefaultRuleset = "ruleset2"; 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(AndCompositeValidator), validator.GetType()); IList <Validator> validators = ValidationTestHelper.CreateListFromEnumerable(((AndCompositeValidator)validator).Validators); Assert.AreEqual(0, validators.Count); Assert.AreEqual(0, mockFactory.requestedMembers.Count); }
public Validator CreateValidatorForType(Type type, ValidationRulesetData ruleData) { if (ruleData.Validators.Count == 0) { return(null); } ConfigurationValidatedType validatedElement = new ConfigurationValidatedType(ruleData, type); return(CreateValidatorForValidatedElement(validatedElement, this.GetCompositeValidatorBuilderForType)); }
public void ValidatedPropertiesEnumerableIncludesPublicPropertyWithValidatorsOnly() { ValidationRulesetData rulesetData = new ValidationRulesetData(); ValidatedPropertyReference nonExistingPropertyReference = new ValidatedPropertyReference("NonExistingProperty"); rulesetData.Properties.Add(nonExistingPropertyReference); nonExistingPropertyReference.Validators.Add(new MockValidatorData("validator1", false)); ValidatedPropertyReference publicPropertyWithoutValidatorsReference = new ValidatedPropertyReference("PublicPropertyWithoutValidators"); rulesetData.Properties.Add(publicPropertyWithoutValidatorsReference); ValidatedPropertyReference writeOnlyPublicPropertyReference = new ValidatedPropertyReference("WriteOnlyPublicProperty"); rulesetData.Properties.Add(writeOnlyPublicPropertyReference); writeOnlyPublicPropertyReference.Validators.Add(new MockValidatorData("validator1", false)); ValidatedPropertyReference nonPublicPropertyReference = new ValidatedPropertyReference("NonPublicProperty"); rulesetData.Properties.Add(nonPublicPropertyReference); nonPublicPropertyReference.Validators.Add(new MockValidatorData("validator1", false)); ValidatedPropertyReference publicPropertyReference = new ValidatedPropertyReference("PublicProperty"); rulesetData.Properties.Add(publicPropertyReference); publicPropertyReference.Validators.Add(new MockValidatorData("validator1", false)); ValidatedPropertyReference secondPublicPropertyReference = new ValidatedPropertyReference("SecondPublicProperty"); rulesetData.Properties.Add(secondPublicPropertyReference); secondPublicPropertyReference.Validators.Add(new MockValidatorData("validator1", false)); ConfigurationValidatedType validatedType = new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass)); IEnumerator <IValidatedElement> validatedPropertiesEnumerator = ((IValidatedType)validatedType).GetValidatedProperties().GetEnumerator(); Assert.IsTrue(validatedPropertiesEnumerator.MoveNext()); Assert.AreSame(typeof(ConfigurationValidatedTypeFixtureTestClass).GetProperty("PublicProperty"), validatedPropertiesEnumerator.Current.MemberInfo); Assert.IsTrue(validatedPropertiesEnumerator.MoveNext()); Assert.AreSame(typeof(ConfigurationValidatedTypeFixtureTestClass).GetProperty("SecondPublicProperty"), validatedPropertiesEnumerator.Current.MemberInfo); Assert.AreSame(typeof(string), validatedPropertiesEnumerator.Current.TargetType); Assert.IsFalse(validatedPropertiesEnumerator.MoveNext()); }
public void ValidatedPropertiesEnumerableIsEmptyIfRulesetDataHasNoProperties() { ValidationRulesetData rulesetData = new ValidationRulesetData(); ConfigurationValidatedType validatedType = new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass)); IEnumerator <IValidatedElement> validatedPropertiesEnumerator = ((IValidatedType)validatedType).GetValidatedProperties().GetEnumerator(); Assert.IsFalse(validatedPropertiesEnumerator.MoveNext()); }
internal void CreateAlternativeRuleset(string rulesetName) { if (this.TypeReference.Rulesets.Get(rulesetName) != null) { throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "The ruleset with name '{0}' has already been registered yet for type {1}.", rulesetName, this.TypeReference.Name)); } var ruleset = new ValidationRulesetData(rulesetName); this.TypeReference.Rulesets.Add(ruleset); }
public void CreateValidatorForEmptyRuleReturnsEmptyCompositeValidator() { ValidationRulesetData ruleData = new ValidationRulesetData(); 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(0, validators.Count); }
public void DoesNotSupportSelfValidation() { ValidationRulesetData rulesetData = new ValidationRulesetData(); ConfigurationValidatedType validatedType = new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass)); IEnumerator <MethodInfo> selfValidationMethodsEnumerator = ((IValidatedType)validatedType).GetSelfValidationMethods().GetEnumerator(); Assert.IsFalse(selfValidationMethodsEnumerator.MoveNext()); }
public void CanDeserializeSerializedSectionWithNamedRuleSpecifyingMultipleValidatorsForField() { ValidationSettings rwSettings = new ValidationSettings(); ValidatedTypeReference rwStringType = new ValidatedTypeReference(typeof(string)); rwSettings.Types.Add(rwStringType); ValidationRulesetData rwValidationRule = new ValidationRulesetData("ruleset"); rwStringType.Rulesets.Add(rwValidationRule); ValidatorData rwValidatorData = new MockValidatorData("validator1", true); rwValidationRule.Validators.Add(rwValidatorData); ValidatedFieldReference rwValidationFieldReference = new ValidatedFieldReference("System.Object.GetHashCode"); rwValidationRule.Fields.Add(rwValidationFieldReference); ValidatorData rwFieldValidatorData1 = new MockValidatorData("ruleset-validator1", false); rwValidationFieldReference.Validators.Add(rwFieldValidatorData1); ValidatorData rwFieldValidatorData2 = new MockValidatorData("ruleset-validator2", false); rwValidationFieldReference.Validators.Add(rwFieldValidatorData2); IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>(); sections[ValidationSettings.SectionName] = rwSettings; using (ConfigurationFileHelper configurationFileHelper = new ConfigurationFileHelper(sections)) { IConfigurationSource configurationSource = configurationFileHelper.ConfigurationSource; ValidationSettings roSettings = configurationSource.GetSection(ValidationSettings.SectionName) as ValidationSettings; Assert.IsNotNull(roSettings); Assert.AreEqual(1, roSettings.Types.Count); Assert.AreEqual(typeof(string).FullName, roSettings.Types.Get(0).Name); Assert.AreEqual(1, roSettings.Types.Get(0).Rulesets.Count); Assert.AreEqual("ruleset", roSettings.Types.Get(0).Rulesets.Get(0).Name); Assert.AreEqual(1, roSettings.Types.Get(0).Rulesets.Get(0).Validators.Count); Assert.AreEqual("validator1", roSettings.Types.Get(0).Rulesets.Get(0).Validators.Get(0).Name); Assert.AreSame(typeof(MockValidatorData), roSettings.Types.Get(0).Rulesets.Get(0).Validators.Get(0).GetType()); Assert.AreEqual(true, ((MockValidatorData)roSettings.Types.Get(0).Rulesets.Get(0).Validators.Get(0)).ReturnFailure); Assert.AreEqual(1, roSettings.Types.Get(0).Rulesets.Get(0).Fields.Count); Assert.AreEqual("System.Object.GetHashCode", roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Name); Assert.AreEqual(2, roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Validators.Count); Assert.AreEqual("ruleset-validator1", roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Validators.Get(0).Name); Assert.AreSame(typeof(MockValidatorData), roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Validators.Get(0).GetType()); Assert.AreEqual(false, ((MockValidatorData)roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Validators.Get(0)).ReturnFailure); Assert.AreEqual("ruleset-validator2", roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Validators.Get(1).Name); Assert.AreSame(typeof(MockValidatorData), roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Validators.Get(1).GetType()); Assert.AreEqual(false, ((MockValidatorData)roSettings.Types.Get(0).Rulesets.Get(0).Fields.Get(0).Validators.Get(1)).ReturnFailure); } }
public ValidationConfigurationBuilderRuleset <TEntity> ForRuleset(string rulesetName) { var ruleset = this.TypeReference.Rulesets.Get(rulesetName); if (ruleset == null) { ruleset = new ValidationRulesetData(rulesetName); this.TypeReference.Rulesets.Add(ruleset); //throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, // "The ruleset with name '{0}' has not been registered yet for type {1}.", // rulesetName, this.TypeReference.Name)); } return(new ValidationConfigurationBuilderRuleset <TEntity>(this, ruleset)); }
public void CreatedInstanceReturnsCorrectValuesOnImplementedInterfaces() { ValidationRulesetData rulesetData = new ValidationRulesetData(); ConfigurationValidatedType validatedType = new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass)); Assert.AreSame(typeof(ConfigurationValidatedTypeFixtureTestClass), ((IValidatedType)validatedType).MemberInfo); Assert.AreSame(typeof(ConfigurationValidatedTypeFixtureTestClass), ((IValidatedType)validatedType).TargetType); Assert.AreEqual(CompositionType.And, ((IValidatedType)validatedType).CompositionType); Assert.AreEqual(null, ((IValidatedType)validatedType).CompositionMessageTemplate); Assert.AreEqual(false, ((IValidatedType)validatedType).IgnoreNulls); Assert.AreEqual(null, ((IValidatedType)validatedType).IgnoreNullsMessageTemplate); }
public void ValidatedMethodsEnumerableSkipsPublicMethodWithoutValidators() { ValidationRulesetData rulesetData = new ValidationRulesetData(); ValidatedMethodReference publicMethodWithoutValidatorsReference = new ValidatedMethodReference("PublicMethodWithoutValidators"); rulesetData.Methods.Add(publicMethodWithoutValidatorsReference); ConfigurationValidatedType validatedType = new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass)); IEnumerator <IValidatedElement> validatedMethodsEnumerator = ((IValidatedType)validatedType).GetValidatedMethods().GetEnumerator(); Assert.IsFalse(validatedMethodsEnumerator.MoveNext()); }
private void BuildFieldReferences(ValidationRulesetData validationRule, RuleSetNode ruleNode) { foreach (FieldNode fieldNode in ruleNode.Hierarchy.FindNodesByType(ruleNode, typeof(FieldNode))) { ValidatedFieldReference fieldReference = new ValidatedFieldReference(); fieldReference.Name = fieldNode.Name; foreach (ValidatorData validator in FindValidators(fieldNode)) { fieldReference.Validators.Add(validator); } validationRule.Fields.Add(fieldReference); } }
private void BuildPropertyReferences(ValidationRulesetData validationRule, RuleSetNode ruleNode) { foreach (PropertyNode propertyNode in ruleNode.Hierarchy.FindNodesByType(ruleNode, typeof(PropertyNode))) { ValidatedPropertyReference propertyReference = new ValidatedPropertyReference(); propertyReference.Name = propertyNode.Name; foreach (ValidatorData validator in FindValidators(propertyNode)) { propertyReference.Validators.Add(validator); } validationRule.Properties.Add(propertyReference); } }
private void BuildMethodReferences(ValidationRulesetData validationRule, RuleSetNode ruleNode) { foreach (MethodNode methodNode in ruleNode.Hierarchy.FindNodesByType(ruleNode, typeof(MethodNode))) { ValidatedMethodReference methodReference = new ValidatedMethodReference(); methodReference.Name = methodNode.Name; foreach (ValidatorData validator in FindValidators(methodNode)) { methodReference.Validators.Add(validator); } validationRule.Methods.Add(methodReference); } }
public void CanCreateValidatorForTypeWithMultipleValidationConfigurationWithProvidedRulesetThroughTopLevelFactoryMethod() { ValidationSettings settings = new ValidationSettings(); configurationSource.Add(ValidationSettings.SectionName, settings); ValidatedTypeReference typeReference = new ValidatedTypeReference(typeof(TestClass)); settings.Types.Add(typeReference); typeReference.DefaultRuleset = "RuleB"; ValidationRulesetData ruleDataA = new ValidationRulesetData("RuleA"); typeReference.Rulesets.Add(ruleDataA); ruleDataA.Validators.Add(new MockValidatorData("validator1", false)); ruleDataA.Validators.Get("validator1").MessageTemplate = "Message1-RuleA"; ruleDataA.Validators.Add(new MockValidatorData("validator2", false)); ruleDataA.Validators.Get("validator2").MessageTemplate = "Message2-RuleA"; ruleDataA.Validators.Add(new MockValidatorData("validator3", false)); ruleDataA.Validators.Get("validator3").MessageTemplate = "Message3-RuleA"; ValidationRulesetData ruleDataB = new ValidationRulesetData("RuleB"); typeReference.Rulesets.Add(ruleDataB); ruleDataB.Validators.Add(new MockValidatorData("validator1", false)); ruleDataB.Validators.Get("validator1").MessageTemplate = "Message1-RuleB"; ruleDataB.Validators.Add(new MockValidatorData("validator2", false)); ruleDataB.Validators.Get("validator2").MessageTemplate = "Message1-RuleB"; // 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), "RuleA"); Assert.IsNotNull(validator); CompositeValidatorBuilder compositeValidatorBuilder = mockFactory.requestedTypes["TestClass"]; Assert.IsNotNull(compositeValidatorBuilder); Assert.AreEqual(false, compositeValidatorBuilder.IgnoreNulls); Assert.AreEqual(CompositionType.And, compositeValidatorBuilder.CompositionType); IDictionary <string, MockValidator <object> > valueValidators = ValidationTestHelper.CreateMockValidatorsMapping(compositeValidatorBuilder.ValueValidators); Assert.AreEqual(3, valueValidators.Count); Assert.IsTrue(valueValidators.ContainsKey("Message1-RuleA")); Assert.IsTrue(valueValidators.ContainsKey("Message2-RuleA")); Assert.IsTrue(valueValidators.ContainsKey("Message3-RuleA")); }
public void ValidatedPropertiesEnumerableSkipsNonExistingPropertyWithValidators() { ValidationRulesetData rulesetData = new ValidationRulesetData(); ValidatedPropertyReference nonExistingPropertyReference = new ValidatedPropertyReference("NonExistingProperty"); rulesetData.Properties.Add(nonExistingPropertyReference); nonExistingPropertyReference.Validators.Add(new MockValidatorData("validator1", false)); ConfigurationValidatedType validatedType = new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass)); IEnumerator <IValidatedElement> validatedPropertiesEnumerator = ((IValidatedType)validatedType).GetValidatedProperties().GetEnumerator(); Assert.IsFalse(validatedPropertiesEnumerator.MoveNext()); }
public void ValidatedMethodsEnumerableSkipsVoidPublicMethodWithValidators() { ValidationRulesetData rulesetData = new ValidationRulesetData(); ValidatedMethodReference nonPublicMethodReference = new ValidatedMethodReference("VoidPublicMethod"); rulesetData.Methods.Add(nonPublicMethodReference); nonPublicMethodReference.Validators.Add(new MockValidatorData("validator1", false)); ConfigurationValidatedType validatedType = new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass)); IEnumerator <IValidatedElement> validatedMethodsEnumerator = ((IValidatedType)validatedType).GetValidatedMethods().GetEnumerator(); Assert.IsFalse(validatedMethodsEnumerator.MoveNext()); }
private void BuildRules(ValidatedTypeReference typeReference, TypeNode typeNode) { foreach (RuleSetNode ruleNode in typeNode.Hierarchy.FindNodesByType(typeNode, typeof(RuleSetNode))) { ValidationRulesetData validationRule = new ValidationRulesetData(ruleNode.Name); BuildPropertyReferences(validationRule, ruleNode); BuildMethodReferences(validationRule, ruleNode); BuildFieldReferences(validationRule, ruleNode); SelfNode selfNode = ruleNode.Hierarchy.FindNodeByType(ruleNode, typeof(SelfNode)) as SelfNode; if (selfNode != null) { foreach (ValidatorData validator in FindValidators(selfNode)) { validationRule.Validators.Add(validator); } } typeReference.Rulesets.Add(validationRule); } }
/// <summary> /// Creates an instance of <see cref="RuleSetNode"/> based on runtime configuration data. /// </summary> /// <param name="ruleData">The corresponding runtime configuration data.</param> public RuleSetNode(ValidationRulesetData ruleData) : base(ruleData.Name) { }