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 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 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 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);
}
}
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);
}
}
/// <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)
{
}
