public void ReturnFailureForNullStringUsingResourcePattern()
{
Validator <string> validator = new RegexValidator(RegexResourceName1, typeof(TestProperties.Resources));
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void ValidatorWillCreateValidationResults()
{
Validator validator = new MockValidator(true, "template");
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(1, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("template"));
}
public void CanValidateObjectWithRulesetFromConfiguration()
{
ValidationResults validationResults
= Validation.ValidateFromConfiguration(new TestObjectWithFailingAttributesOnProperties(), "RuleA");
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(2, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config1-RuleA"));
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config2-RuleA"));
}
public void ReturnFailureForNonMatchingString()
{
Validator <string> validator = new RegexValidator(RegexPattern);
ValidationResults validationResults = validator.Validate("asdfg");
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
private void AssertValidatorIsForRuleSetA(Validator <TestObjectWithFailingAttributesOnProperties> v)
{
var validationResults = v.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
var resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(3, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config1-RuleA"));
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config2-RuleA"));
Assert.IsTrue(resultsMapping.ContainsKey("message1-RuleA"));
}
public void CanValidateObjectFromAttributesWithMultipleRuleSets()
{
ValidationResults validationResults
= Validation.ValidateFromAttributes(new TestObjectWithFailingAttributesOnProperties(), "RuleA", "RuleB");
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(2, resultsList.Count);
Assert.AreEqual("message1-RuleA", resultsList[0].Message);
Assert.AreEqual("message1-RuleB", resultsList[1].Message);
}
public void NonNegatedValidatorReturnsFailureForNullReference()
{
Validator validator = new NotNullValidator();
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual(Resources.NonNullNonNegatedValidatorDefaultMessageTemplate, resultsList[0].Message);
}
public void ReturnsFailureForValueOutsideRange()
{
Validator <string> validator = new RangeValidator <string>("aaaa", RangeBoundaryType.Exclusive, "zzzz", RangeBoundaryType.Inclusive);
ValidationResults validationResults = validator.Validate("0000");
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.RangeValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void CanCreateValidatorFromEmptyConfigurationObject()
{
AndCompositeValidatorData rwValidatorData = new AndCompositeValidatorData("validator1");
Validator validator = ((IValidatorDescriptor)rwValidatorData).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
Assert.AreSame(typeof(AndCompositeValidator), validator.GetType());
IList <Validator> validators = ValidationTestHelper.CreateListFromEnumerable <Validator>(((AndCompositeValidator)validator).Validators);
Assert.AreEqual(0, validators.Count);
}
public void ReturnsFailureForStringLongerThanMaxLengthForMaxLengthOnlyValidator()
{
Validator <string> validator = new StringLengthValidator(10);
ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 11).ToString());
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.StringLengthValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void LogsOwnValidationFailureIfValidationMethodThrows()
{
Validator validator = new SelfValidationValidator(GetType().GetMethod("ThrowingSelfValidationMethod", BindingFlags.NonPublic | BindingFlags.Instance));
ValidationResults validationResults = new ValidationResults();
validator.Validate(this, validationResults);
Assert.IsNull(suppliedValidationResults);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual(Resources.SelfValidationMethodThrownMessage, resultsList[0].Message);
}
public void CreateValidatorForNonExistingRuleReturnsEmptyValidator()
{
ValidatedTypeReference typeReference = new ValidatedTypeReference();
Validator validator = 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(0, validators.Count);
}
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 ValidatorWillSetKeyIfProvided()
{
Validator validator = new MockValidator(true, "template");
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(this, this, "key", validationResults);
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual("key", resultsMapping["template"].Key);
}
public void WhenValidatingRulesFromRuleSet_ThenValidationResultsOnlyContainExpectedRuleFailures()
{
Validator <TestObjectWithFailingAttributesOnProperties> validator
= validationFactory.CreateValidator <TestObjectWithFailingAttributesOnProperties>("RuleA");
ValidationResults validationResults = validator.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("message1-RuleA", resultsList[0].Message);
}
public void CreatedValidatorIsBasedOnValidationAttributesAndProvidedRuleset()
{
Validator <TestObjectWithFailingAttributesOnProperties> validator
= ValidationFactory.CreateValidatorFromAttributes <TestObjectWithFailingAttributesOnProperties>("RuleA");
ValidationResults validationResults = validator.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("message1-RuleA", resultsList[0].Message);
}
public void CanControlValidationSourceAndRuleSetWithAttributesOnProperties()
{
var o = container.Resolve <ObjectWithValidatorProperties>();
ValidationResults validationResults
= o.Val2.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(1, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message1-RuleA"));
}
public void ValidatorWillUseTagIfAvailable()
{
Validator validator = new MockValidator(true, "template");
validator.Tag = "tag";
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual("tag", resultsMapping["template"].Tag);
}
public void ValidatorWillSetMessageToSpecifiedMessageIfMessageTemplateIsSet()
{
Validator validator = new MockValidator(true);
validator.MessageTemplate = "overriden message";
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreSame(validator, resultsMapping["overriden message"].Validator);
}
public void ValidatorWillSetValidatorToThis()
{
Validator validator = new MockValidator(true, "template");
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(this, this, "key", validationResults);
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreSame(validator, resultsMapping["template"].Validator);
}
public void WhenValidatingAttributeRulesThatFail_ThenReceiveCorrectFailedValidationResults()
{
Validator <TestObjectWithFailingAttributesOnProperties> validator
= validationFactory.CreateValidator <TestObjectWithFailingAttributesOnProperties>();
ValidationResults validationResults = validator.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(2, resultsList.Count);
Assert.AreEqual("message1", resultsList[0].Message);
Assert.AreEqual("message2", resultsList[1].Message);
}
public void ReturnsFailureWithOverriddenMessageForNullReference()
{
string message = "overriden message";
Validator validator = new NotNullValidator(message);
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual(message, resultsList[0].Message);
}
public void CanCreateValidatorFromConfigurationFileUsingDefaultRule()
{
Validator <TestObjectWithFailingAttributesOnProperties> validator
= ValidationFactory.CreateValidatorFromConfiguration <TestObjectWithFailingAttributesOnProperties>();
ValidationResults validationResults = validator.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(2, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config1"));
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config2"));
}
// TODO fix with templated message.
public void ReturnsFailureWithOverridenMessageForValueOutsideRange()
{
string message = "overrinde message";
Validator <string> validator = new RangeValidator <string>("aaaa", RangeBoundaryType.Exclusive, "zzzz", RangeBoundaryType.Inclusive, message);
ValidationResults validationResults = validator.Validate("0000");
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual(message, resultsList[0].Message);
}
public void CanValidateObjectWithDefaultRulesetFromAttributesAndConfigurationForTheActualType()
{
ValidationResults validationResults =
Validation.Validate <TestObjectWithFailingAttributesOnProperties>(
new DerivedTestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(3, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message1"));
Assert.IsTrue(resultsMapping.ContainsKey("message2"));
Assert.IsTrue(resultsMapping.ContainsKey("message-derived"));
}
public void WhenAValidatorIsCreatedUsingANamedRuleset_ThenWillFailOnRulesFromConfigurationFileAndFromAttributes()
{
Validator <TestObjectWithFailingAttributesOnProperties> validator
= validationFactory.CreateValidator <TestObjectWithFailingAttributesOnProperties>("RuleA");
ValidationResults validationResults = validator.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(3, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config1-RuleA"));
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config2-RuleA"));
Assert.IsTrue(resultsMapping.ContainsKey("message1-RuleA"));
}
public void CreateValidatorForNonExistingTypeInConfigurationReturnsEmptyValidator()
{
ValidationSettings settings = new ValidationSettings();
configurationSource.Add(ValidationSettings.SectionName, settings);
Validator validator = builder.CreateValidator(typeof(TestClass), "ruleset1");
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 ResolvedValidatorValidatesCorrectly()
{
var validator = container.Resolve <Validator <TestObjectWithFailingAttributesOnProperties> >();
ValidationResults validationResults = validator.Validate(new TestObjectWithFailingAttributesOnProperties());
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(4, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config1"));
Assert.IsTrue(resultsMapping.ContainsKey("message-from-config2"));
Assert.IsTrue(resultsMapping.ContainsKey("message1"));
Assert.IsTrue(resultsMapping.ContainsKey("message2"));
}
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 ValidatesUsingTheRulesForTheActualTypeIfValidatingTheActualType()
{
// TODO - change to avoid relying on reflection order
object instance1 = new ObjectCollectionValidatorFixtureReferencedTestClass();
object instance2 = new DerivedObjectCollectionValidatorFixtureReferencedTestClass();
object target = new object[] { instance1, instance2 };
Validator validator = new ObjectCollectionValidator();
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, this, "key", validationResults); // setting the currentTarget and the key
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(6, resultsList.Count);
Assert.AreEqual("ReferencedObject", resultsList[0].Message);
Assert.AreEqual(null, resultsList[0].Key);
Assert.AreEqual(null, resultsList[0].Tag);
Assert.AreSame(instance1, resultsList[0].Target);
Assert.AreEqual("PropertyInReferencedObject", resultsList[1].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[1].Key);
Assert.AreEqual(null, resultsList[1].Tag);
Assert.AreSame(instance1, resultsList[1].Target);
Assert.AreEqual("DerivedReferencedObject", resultsList[2].Message);
Assert.AreEqual(null, resultsList[2].Key);
Assert.AreEqual(null, resultsList[2].Tag);
Assert.AreSame(instance2, resultsList[2].Target);
Assert.AreEqual("PropertyInDerivedReferencedObject", resultsList[3].Message);
Assert.AreEqual("PropertyInDerivedReferencedObject", resultsList[3].Key);
Assert.AreEqual(null, resultsList[3].Tag);
Assert.AreSame(instance2, resultsList[3].Target);
Assert.AreEqual("PropertyInReferencedObject", resultsList[4].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[4].Key);
Assert.AreEqual(null, resultsList[4].Tag);
Assert.AreSame(instance2, resultsList[4].Target);
Assert.AreEqual("PropertyInDerivedReferencedObject-DataAnnotations", resultsList[5].Message);
Assert.AreEqual("PropertyInDerivedReferencedObject", resultsList[5].Key);
Assert.AreEqual(null, resultsList[5].Tag);
Assert.AreSame(instance2, resultsList[5].Target);
}
