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 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 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 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 void MethodNodeHasConfiguredMethodNameAsNodeName()
{
ValidatedMethodReference methodReference = new ValidatedMethodReference("MethodName");
MethodNode methodNode = new MethodNode(methodReference);
Assert.AreEqual("MethodName", methodNode.Name);
}
public void CreateValidatorForMethodReferenceWithoutValidatorsReturnsNull()
{
ValidatedMethodReference methodReference = new ValidatedMethodReference("PublicMethod");
Validator validator = builder.CreateValidatorForMethod(typeof(TestClass), methodReference);
Assert.IsNull(validator);
}
/// <summary>
/// Updates the flyweight for a method.
/// </summary>
/// <param name="validatedMethodReference">The method reference configuration object.</param>
/// <param name="methodInfo">The method.</param>
public void UpdateFlyweight(ValidatedMethodReference validatedMethodReference, MethodInfo methodInfo)
{
if (methodInfo == null)
{
throw new ArgumentNullException("methodInfo");
}
UpdateFlyweight(validatedMethodReference, methodInfo, methodInfo.ReturnType);
}
public void CanDeserializeSerializedSectionWithNamedRuleSpecifyingMultipleValidatorsForMethod()
{
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);
ValidatedMethodReference rwValidationMethodReference = new ValidatedMethodReference("System.Object.GetHashCode");
rwValidationRule.Methods.Add(rwValidationMethodReference);
ValidatorData rwMethodValidatorData1 = new MockValidatorData("ruleset-validator1", false);
rwValidationMethodReference.Validators.Add(rwMethodValidatorData1);
ValidatorData rwMethodValidatorData2 = new MockValidatorData("ruleset-validator2", false);
rwValidationMethodReference.Validators.Add(rwMethodValidatorData2);
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).Methods.Count);
Assert.AreEqual("System.Object.GetHashCode", roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Name);
Assert.AreEqual(2, roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Validators.Count);
Assert.AreEqual("ruleset-validator1", roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Validators.Get(0).Name);
Assert.AreSame(typeof(MockValidatorData), roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Validators.Get(0).GetType());
Assert.AreEqual(false, ((MockValidatorData)roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Validators.Get(0)).ReturnFailure);
Assert.AreEqual("ruleset-validator2", roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Validators.Get(1).Name);
Assert.AreSame(typeof(MockValidatorData), roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Validators.Get(1).GetType());
Assert.AreEqual(false, ((MockValidatorData)roSettings.Types.Get(0).Rulesets.Get(0).Methods.Get(0).Validators.Get(1)).ReturnFailure);
}
}
public void CreateValidatorForMethodWithArgumentsReferenceWithValidatorsReturnsNull()
{
ValidatedMethodReference methodReference = new ValidatedMethodReference("PublicMethodWithArguments");
methodReference.Validators.Add(new MockValidatorData("validator1", false));
methodReference.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference.Validators.Add(new MockValidatorData("validator2", false));
methodReference.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = builder.CreateValidatorForMethod(typeof(TestClass), methodReference);
Assert.IsNull(validator);
Assert.AreEqual(0, mockFactory.requestedMembers.Count);
}
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 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 ValidatedMethodsEnumerableIncludesPublicMethodWithValidatorsOnly()
{
ValidationRulesetData rulesetData = new ValidationRulesetData();
ValidatedMethodReference nonExistingMethodReference
= new ValidatedMethodReference("NonExistingMethod");
rulesetData.Methods.Add(nonExistingMethodReference);
nonExistingMethodReference.Validators.Add(new MockValidatorData("validator1", false));
ValidatedMethodReference publicMethodWithoutValidatorsReference
= new ValidatedMethodReference("PublicMethodWithoutValidators");
rulesetData.Methods.Add(publicMethodWithoutValidatorsReference);
ValidatedMethodReference nonPublicMethodReference
= new ValidatedMethodReference("NonPublicMethod");
rulesetData.Methods.Add(nonPublicMethodReference);
nonPublicMethodReference.Validators.Add(new MockValidatorData("validator1", false));
ValidatedMethodReference publicMethodReference
= new ValidatedMethodReference("PublicMethod");
rulesetData.Methods.Add(publicMethodReference);
publicMethodReference.Validators.Add(new MockValidatorData("validator1", false));
ValidatedMethodReference secondPublicMethodReference
= new ValidatedMethodReference("SecondPublicMethod");
rulesetData.Methods.Add(secondPublicMethodReference);
secondPublicMethodReference.Validators.Add(new MockValidatorData("validator1", false));
ConfigurationValidatedType validatedType
= new ConfigurationValidatedType(rulesetData, typeof(ConfigurationValidatedTypeFixtureTestClass));
IEnumerator <IValidatedElement> validatedMethodsEnumerator
= ((IValidatedType)validatedType).GetValidatedMethods().GetEnumerator();
Assert.IsTrue(validatedMethodsEnumerator.MoveNext());
Assert.AreSame(typeof(ConfigurationValidatedTypeFixtureTestClass).GetMethod("PublicMethod"),
validatedMethodsEnumerator.Current.MemberInfo);
Assert.IsTrue(validatedMethodsEnumerator.MoveNext());
Assert.AreSame(typeof(ConfigurationValidatedTypeFixtureTestClass).GetMethod("SecondPublicMethod"),
validatedMethodsEnumerator.Current.MemberInfo);
Assert.AreSame(typeof(string), validatedMethodsEnumerator.Current.TargetType);
Assert.IsFalse(validatedMethodsEnumerator.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());
}
public Validator CreateValidatorForMethod(Type type, ValidatedMethodReference methodReference)
{
if (methodReference.Validators.Count == 0)
{
return(null);
}
MethodInfo methodInfo = ValidationReflectionHelper.GetMethod(type, methodReference.Name, false);
if (methodInfo == null)
{
return(null);
}
ConfigurationValidatedElement validatedElement = new ConfigurationValidatedElement(methodReference, methodInfo);
return(CreateValidatorForValidatedElement(validatedElement, this.GetCompositeValidatorBuilderForMethod));
}
public void CreateValidatorForMethodReferenceWithValidatorsReturnsValueAccessValidator()
{
ValidatedMethodReference methodReference = new ValidatedMethodReference("PublicMethod");
methodReference.Validators.Add(new MockValidatorData("validator1", false));
methodReference.Validators.Get("validator1").MessageTemplate = "validator 1 message";
methodReference.Validators.Add(new MockValidatorData("validator2", false));
methodReference.Validators.Get("validator2").MessageTemplate = "validator 2 message";
Validator validator = builder.CreateValidatorForMethod(typeof(TestClass), methodReference);
Assert.IsNotNull(validator);
Assert.AreEqual(1, mockFactory.requestedMembers.Count);
ValueAccessValidatorBuilder valueAccessValidatorBuilder = mockFactory.requestedMembers["TestClass.PublicMethod"];
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 FlyweightUpdatedWithValidatedMethodReferenceReturnsCorrectValues()
{
ValidatedMethodReference methodReference = new ValidatedMethodReference("Method");
methodReference.Validators.Add(new MockValidatorData("validator1", false));
methodReference.Validators.Get("validator1").MessageTemplate = "method validator 1 message";
methodReference.Validators.Add(new MockValidatorData("validator2", false));
methodReference.Validators.Get("validator2").MessageTemplate = "method validator 2 message";
methodReference.Validators.Add(new MockValidatorData("validator3", false));
methodReference.Validators.Get("validator3").MessageTemplate = "method validator 3 message";
methodReference.Validators.Add(new MockValidatorData("validator4", false));
methodReference.Validators.Get("validator4").MessageTemplate = "method validator 4 message";
ConfigurationValidatedElement validatedElement = new ConfigurationValidatedElement();
MethodInfo methodInfo = typeof(ConfigurationValidatedElementFixtureTestClass).GetMethod("Method");
validatedElement.UpdateFlyweight(methodReference, methodInfo);
Assert.AreSame(typeof(DateTime), ((IValidatedElement)validatedElement).TargetType);
Assert.AreSame(methodInfo, ((IValidatedElement)validatedElement).MemberInfo);
Assert.AreEqual(CompositionType.And, ((IValidatedElement)validatedElement).CompositionType);
Assert.AreEqual(false, ((IValidatedElement)validatedElement).IgnoreNulls);
IEnumerator <IValidatorDescriptor> validatorDescriptorsEnumerator
= ((IValidatedElement)validatedElement).GetValidatorDescriptors().GetEnumerator();
Assert.IsNotNull(validatorDescriptorsEnumerator);
Assert.IsTrue(validatorDescriptorsEnumerator.MoveNext());
Assert.AreEqual("method validator 1 message",
((MockValidatorData)validatorDescriptorsEnumerator.Current).MessageTemplate);
Assert.IsTrue(validatorDescriptorsEnumerator.MoveNext());
Assert.AreEqual("method validator 2 message",
((MockValidatorData)validatorDescriptorsEnumerator.Current).MessageTemplate);
Assert.IsTrue(validatorDescriptorsEnumerator.MoveNext());
Assert.AreEqual("method validator 3 message",
((MockValidatorData)validatorDescriptorsEnumerator.Current).MessageTemplate);
Assert.IsTrue(validatorDescriptorsEnumerator.MoveNext());
Assert.AreEqual("method validator 4 message",
((MockValidatorData)validatorDescriptorsEnumerator.Current).MessageTemplate);
Assert.IsFalse(validatorDescriptorsEnumerator.MoveNext());
}
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);
}
/// <summary>
/// Creates an instance of <see cref="MethodNode"/> based on runtime configuration data.
/// </summary>
/// <param name="methodData">The corresponding runtime configuration data.</param>
public MethodNode(ValidatedMethodReference methodData)
: this(methodData.Name)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationValidatedElement"/> class for a method.
/// </summary>
/// <param name="validatedMethodReference">The method reference configuration object.</param>
/// <param name="methodInfo">The method.</param>
public ConfigurationValidatedElement(ValidatedMethodReference validatedMethodReference, MethodInfo methodInfo)
{
UpdateFlyweight(validatedMethodReference, methodInfo);
}
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="MethodNode"/> based on runtime configuration data.
/// </summary>
/// <param name="methodData">The corresponding runtime configuration data.</param>
public MethodNode(ValidatedMethodReference methodData)
: this(methodData.Name)
{
}
public void UpdateFlyweight(ValidatedMethodReference validatedMethodReference, MethodInfo methodInfo)
{
UpdateFlyweight(validatedMethodReference, methodInfo, methodInfo.ReturnType);
}
