public void SuppliesAppropriateParametersToDefaultNegatedMessage()
{
ValueAccess valueAccess = new MockValueAccess(5, "referenced key");
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.NotEqual, null, true);
validator.Tag = "tag";
object target = 6;
string key = "key";
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, null, key, validationResults);
Assert.IsFalse(validationResults.IsValid);
ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0];
Match match = TemplateStringTester.Match(validator.MessageTemplate, validationResult.Message);
Assert.IsTrue(match.Success);
Assert.IsFalse(match.Groups["param0"].Success);
Assert.IsFalse(match.Groups["param1"].Success);
Assert.IsFalse(match.Groups["param2"].Success);
Assert.IsFalse(match.Groups["param3"].Success);
Assert.IsTrue(match.Groups["param4"].Success);
Assert.AreEqual("referenced key", match.Groups["param4"].Value);
Assert.IsTrue(match.Groups["param5"].Success);
Assert.AreEqual("NotEqual", match.Groups["param5"].Value);
}
public void MultipleAddedValueValidatorsAreIncludedInResultingValidatorForAndCompositionIgnoringNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
MockValidator <object> failingValueValidator = new MockValidator <object>(true);
MockValidator <object> succeedingValueValidator = new MockValidator <object>(false);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(true, null, null, CompositionType.And, null, null));
builder.AddValueValidator(failingValueValidator);
builder.AddValueValidator(succeedingValueValidator);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
// does it validate nonnull values?
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, failingValueValidator.ValidatedTargets[0]);
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, succeedingValueValidator.ValidatedTargets[0]);
// does it ignore nulls? it should
valueAccess.Value = null;
validationResults = validator.Validate(this);
Assert.IsTrue(validationResults.IsValid); // null value is ignored so validation succeeds
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count); // no changes
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count); // no changes
}
public void AddedValueValidatorIsIncludedInResultingValidatorForAndWithoutNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
MockValidator <object> failingValueValidator = new MockValidator <object>(true);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(false, null, null, CompositionType.And, null, null));
builder.AddValueValidator(failingValueValidator);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
// does it validate nonnullvalues?
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, failingValueValidator.ValidatedTargets[0]);
// does it ignore nulls? it should not
valueAccess.Value = null;
validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(2, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(null, failingValueValidator.ValidatedTargets[1]);
}
public void SuppliesAppropriateParametersToMessageTemplate()
{
ValueAccess valueAccess = new MockValueAccess(5, "referenced key");
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.Equal);
validator.MessageTemplate = "{0}|{1}|{2}|{3}|{4}|{5}";
validator.Tag = "tag";
object target = 6;
string key = "key";
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, null, key, validationResults);
Assert.IsFalse(validationResults.IsValid);
ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0];
System.Text.RegularExpressions.Match match = TemplateStringTester.Match(validator.MessageTemplate, validationResult.Message);
Assert.IsTrue(match.Success);
Assert.IsTrue(match.Groups["param0"].Success);
Assert.AreEqual(target.ToString(), match.Groups["param0"].Value);
Assert.IsTrue(match.Groups["param1"].Success);
Assert.AreEqual(key, match.Groups["param1"].Value);
Assert.IsTrue(match.Groups["param2"].Success);
Assert.AreEqual(validator.Tag, match.Groups["param2"].Value);
Assert.IsTrue(match.Groups["param3"].Success);
Assert.AreEqual("5", match.Groups["param3"].Value);
Assert.IsTrue(match.Groups["param4"].Success);
Assert.AreEqual("referenced key", match.Groups["param4"].Value);
Assert.IsTrue(match.Groups["param5"].Success);
Assert.AreEqual("Equal", match.Groups["param5"].Value);
}
public void ComparingComparableForLessThanWithLargerOfSameTypeReturnsSuccess()
{
ValueAccess valueAccess = new MockValueAccess(8);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.LessThan);
ValidationResults validationResults = validator.Validate(7);
Assert.IsTrue(validationResults.IsValid);
}
public void ComparingComparableForLessThanWithSmallerOfSameTypeReturnsFailure()
{
ValueAccess valueAccess = new MockValueAccess(6);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.LessThan);
ValidationResults validationResults = validator.Validate(7);
Assert.IsFalse(validationResults.IsValid);
}
public void ComparingNonComparableForLessThanReturnsFailure()
{
ValueAccess valueAccess = new MockValueAccess(7);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.LessThan);
ValidationResults validationResults = validator.Validate(new object());
Assert.IsFalse(validationResults.IsValid);
}
public void ComparingNullForEqualWithNullReturnsSuccess()
{
ValueAccess valueAccess = new MockValueAccess(null);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.Equal);
ValidationResults validationResults = validator.Validate(null);
Assert.IsTrue(validationResults.IsValid);
}
public void ComparingNonNullForEqualityWithNullReturnsFailure()
{
ValueAccess valueAccess = new MockValueAccess(null);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.Equal);
ValidationResults validationResults = validator.Validate("non null");
Assert.IsFalse(validationResults.IsValid);
}
public void ComparingComparableForLessThanWithNullReturnsFailure()
{
ValueAccess valueAccess = new MockValueAccess(null);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.LessThan);
ValidationResults validationResults = validator.Validate("a string");
Assert.IsFalse(validationResults.IsValid);
}
public void ComparingNonNullForNonEqualityWithNonEqualReturnsSuccess()
{
ValueAccess valueAccess = new MockValueAccess(5);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.NotEqual);
ValidationResults validationResults = validator.Validate("non null");
Assert.IsTrue(validationResults.IsValid);
}
public void ComparingWithValueAccessReturningAccessFailureReturnsFailure()
{
ValueAccess valueAccess = new MockValueAccess(null, null, true);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.Equal);
ValidationResults validationResults = validator.Validate("non null");
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, ValidationTestHelper.GetResultsList(validationResults).Count);
}
public void CanGetValidatorFromNewBuilderInstanceForAndWithoutNulls()
{
MockValueAccess valueAccess = new MockValueAccess(value);
ValueAccessValidatorBuilder builder = new ValueAccessValidatorBuilder(valueAccess,
new MockValidatedElement(false, null, null, CompositionType.And, null, null));
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
}
public void ReturnsFailureIfParameterToValidateIsNull()
{
MockValueAccess valueAccess = new MockValueAccess("value");
MockValidator <object> valueValidator = new MockValidator <object>(false);
Validator validator = new ValueAccessValidator(valueAccess, valueValidator);
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
}
public void ComparingComparableForGreaterThanEqualsReturnsExpectedResults()
{
ValueAccess valueAccess = new MockValueAccess(7);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.GreaterThanEqual);
Assert.IsFalse(validator.Validate(5).IsValid);
Assert.IsFalse(validator.Validate(6).IsValid);
Assert.IsTrue(validator.Validate(7).IsValid);
Assert.IsTrue(validator.Validate(8).IsValid);
Assert.IsTrue(validator.Validate(9).IsValid);
}
public void CreatingWithValueAccessAndOperatorAndNegatedSetsValuesForValidators()
{
ValueAccess valueAccess = new MockValueAccess(null);
ValueAccessComparisonValidator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.LessThan, null, true);
Assert.AreSame(valueAccess, validator.ValueAccess);
Assert.AreEqual(ComparisonOperator.LessThan, validator.ComparisonOperator);
Assert.AreEqual(null, validator.Tag);
Assert.AreEqual(true, validator.Negated);
// Assert.AreEqual(null, validator.MessageTemplate);
}
public void ComparingWithUnknownOperatorFails()
{
ValueAccess valueAccess = new MockValueAccess(7);
Validator validator = new ValueAccessComparisonValidator(valueAccess, (ComparisonOperator)100);
Assert.IsFalse(validator.Validate(5).IsValid);
Assert.IsFalse(validator.Validate(6).IsValid);
Assert.IsFalse(validator.Validate(7).IsValid);
Assert.IsFalse(validator.Validate(8).IsValid);
Assert.IsFalse(validator.Validate(9).IsValid);
}
public void ReturnsFailureIfValueValidatorReturnsFailureAndValueValidatorIsInvoked()
{
object valueToValidate = new object();
MockValueAccess valueAccess = new MockValueAccess(valueToValidate);
MockValidator <object> valueValidator = new MockValidator <object>(true);
Validator validator = new ValueAccessValidator(valueAccess, valueValidator);
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, valueValidator.ValidatedTargets.Count);
Assert.AreSame(valueToValidate, valueValidator.ValidatedTargets[0]);
}
public void FailureFromValueAccessHasCorrectValidationKey()
{
string key = new string(new char[0]);
object valueToValidate = new object();
MockValueAccess valueAccess = new MockValueAccess(valueToValidate, key);
MockValidator <object> valueValidator = new MockValidator <object>(true);
Validator validator = new ValueAccessValidator(valueAccess, valueValidator);
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual(key, resultsList[0].Key);
}
public void NegatedEqualityReturnsExpectedResults()
{
ValueAccess valueAccess = new MockValueAccess(null);
Validator validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.Equal, null, true);
Assert.IsTrue(validator.Validate(5).IsValid);
Assert.IsFalse(validator.Validate(null).IsValid);
valueAccess = new MockValueAccess(6);
validator = new ValueAccessComparisonValidator(valueAccess, ComparisonOperator.Equal, null, true);
Assert.IsTrue(validator.Validate(5).IsValid);
Assert.IsFalse(validator.Validate(6).IsValid);
Assert.IsTrue(validator.Validate("string").IsValid);
Assert.IsTrue(validator.Validate(null).IsValid);
}
public void ValueValidatorIsInvokedWithProperlySetObjectToValidateAndCurrentTargetAndKey()
{
object valueToValidate = new object();
string key = new string(new char[] { 'a', 'b', 'c' });
MockValueAccess valueAccess = new MockValueAccess(valueToValidate, key);
MockValidator <object> valueValidator = new MockValidator <object>(true, "message");
Validator validator = new ValueAccessValidator(valueAccess, valueValidator);
ValidationResults validationResults = validator.Validate(this);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(1, resultsMapping.Count);
Assert.AreSame(this, resultsMapping["message"].Target);
Assert.AreSame(key, resultsMapping["message"].Key);
Assert.AreEqual(1, valueValidator.ValidatedTargets.Count);
Assert.AreSame(valueToValidate, valueValidator.ValidatedTargets[0]);
}
