public void ValidatorWillThrowIfProvidedNulValidationResults()
{
Validator validator = new MockValidator(true, "template");
ValidationResults validationResults = new ValidationResults();
validator.Validate(this, null);
}
public void MultipleAddedValueValidatorsAreIncludedInResultingValidatorForAndCompositionNotIgnoringNulls()
{
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(false, null, null, CompositionType.And, null, null));
builder.AddValueValidator(failingValueValidator);
builder.AddValueValidator(succeedingValueValidator);
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]);
Assert.AreEqual(1, succeedingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, succeedingValueValidator.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]);
Assert.AreEqual(2, succeedingValueValidator.ValidatedTargets.Count);
Assert.AreSame(null, succeedingValueValidator.ValidatedTargets[1]);
}
public void ValidatesValueMethod()
{
MockValidator<object> valueValidator = new MockValidator<object>(false);
Validator validator
= new MethodReturnValueValidator<MethodReturnValueValidatorFixtureTestClass>("PublicMethod", valueValidator);
validator.Validate(new MethodReturnValueValidatorFixtureTestClass());
Assert.AreEqual(MethodReturnValueValidatorFixtureTestClass.value, valueValidator.ValidatedTargets[0]);
}
public void ValidatorWillNotUseTagIfUnavailable()
{
Validator validator = new MockValidator(true, "template");
ValidationResults validationResults = validator.Validate(this);
Assert.IsFalse(validationResults.IsValid);
IDictionary<string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.IsNull(resultsMapping["template"].Tag);
}
public void ValidatesValueProperty()
{
MockValidator<object> valueValidator = new MockValidator<object>(false);
Validator validator
= new PropertyValueValidator<PropertyValueValidatorFixtureTestClass>("PublicProperty", valueValidator);
validator.Validate(new PropertyValueValidatorFixtureTestClass());
Assert.AreEqual(PropertyValueValidatorFixtureTestClass.value, valueValidator.ValidatedTargets[0]);
}
public void ValidatesValueField()
{
MockValidator<object> valueValidator = new MockValidator<object>(false);
Validator validator
= new FieldValueValidator<FieldValueValidatorFixtureTestClass>("PublicField", valueValidator);
validator.Validate(new FieldValueValidatorFixtureTestClass());
Assert.AreEqual(FieldValueValidatorFixtureTestClass.value, valueValidator.ValidatedTargets[0]);
}
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 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 SuccessIsDeterminedByWrappedValidator()
{
string target = "";
MockValidator<object> wrappedValidator = new MockValidator<object>(false, "message");
Validator<string> validator = new GenericValidatorWrapper<string>(wrappedValidator);
ValidationResults validationResults = validator.Validate(target);
Assert.IsTrue(validationResults.IsValid);
Assert.AreSame(target, wrappedValidator.ValidatedTargets[0]);
}
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 CreatedValidationResultHasNoChildResults()
{
object target = new object();
Validator validator = new MockValidator(false);
ValidationResult validationResult = new ValidationResult("message", target, "key", "tag", validator);
Assert.AreEqual("message", validationResult.Message);
Assert.AreSame(target, validationResult.Target);
Assert.AreEqual("key", validationResult.Key);
Assert.AreEqual("tag", validationResult.Tag);
Assert.AreSame(validator, validationResult.Validator);
Assert.IsFalse(validationResult.NestedValidationResults.GetEnumerator().MoveNext());
}
public void ReturnsSuccessAfterQueryingPreviousValidatorsIfOneValidatorReturnFailure()
{
MockValidator<string> subValidator1 = new MockValidator<string>(true, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(false, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(false, "validator3");
Validator validator = new OrCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = validator.Validate(target);
Assert.IsTrue(validationResults.IsValid);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreEqual(0, subValidator3.ValidatedTargets.Count);
}
public void ReturnsSuccessWhenValidatingNullAfterQueryingPreviousValidatorsIfManyValidatorsReturnFailure()
{
MockValidator<string> subValidator1 = new MockValidator<string>(true, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(true, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(false, "validator3");
Validator validator = new OrCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = null;
ValidationResults validationResults = validator.Validate(target);
Assert.IsTrue(validationResults.IsValid);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void ReturnsSuccessIfAllValidatorsReturnSuccess()
{
MockValidator<string> subValidator1 = new MockValidator<string>(false, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(false, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(false, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = validator.Validate(target);
Assert.IsTrue(validationResults.IsValid);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void FailureIsDeterminedByWrappedValidator()
{
string target = "";
MockValidator<object> wrappedValidator = new MockValidator<object>(true, "message");
Validator<string> validator = new GenericValidatorWrapper<string>(wrappedValidator);
ValidationResults validationResults = validator.Validate(target);
Assert.IsFalse(validationResults.IsValid);
Assert.AreSame(target, wrappedValidator.ValidatedTargets[0]);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("message", resultsList[0].Message);
}
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]);
}
public void ReturnsFailureAfterQueryingAllValidatorsIfOneValidatorReturnFailure()
{
MockValidator<string> subValidator1 = new MockValidator<string>(false, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(true, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(false, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = validator.Validate(target);
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("validator2", resultsList[0].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void ReturnsCompositeFailureWhenValidatingNullAfterQueryingAllValidatorsIfManyValidatorsReturnFailure()
{
MockValidator<string> subValidator1 = new MockValidator<string>(false, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(true, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(true, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = null;
ValidationResults validationResults = validator.Validate(target);
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(2, resultsList.Count);
Assert.AreEqual("validator2", resultsList[0].Message);
Assert.AreEqual("validator3", resultsList[1].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void CallsBaseValidateMethod()
{
Page child;
MockValidator mockValidator;
child = new Page();
mockValidator = new MockValidator();
mockValidator.ValidationGroup = "theValidationGroup";
child.Validators.Add( mockValidator );
child.Validate(mockValidator.ValidationGroup);
Assert.IsTrue(mockValidator.WasCalled);
child = new Page();
mockValidator = new MockValidator();
child.Validators.Add( mockValidator );
child.Validate();
Assert.IsTrue(mockValidator.WasCalled);
}
public void NoIgnoreNullsAndAndCompositionCreatesSingleAndValidator()
{
MockValidator<object> valueValidator1 = new MockValidator<object>(false);
MockValidator<object> valueValidator2 = new MockValidator<object>(false);
CompositeValidatorBuilder builder
= new CompositeValidatorBuilder(new MockValidatedElement(false, null, null,
CompositionType.And, null, null));
builder.AddValueValidator(valueValidator1);
builder.AddValueValidator(valueValidator2);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
Assert.AreSame(typeof(AndCompositeValidator), validator.GetType());
Assert.AreEqual(null, validator.Tag);
IEnumerator<Validator> valueValidatorsEnumerator = ((AndCompositeValidator)validator).Validators.GetEnumerator();
Assert.IsTrue(valueValidatorsEnumerator.MoveNext());
Assert.AreSame(valueValidator1, valueValidatorsEnumerator.Current);
Assert.IsTrue(valueValidatorsEnumerator.MoveNext());
Assert.AreSame(valueValidator2, valueValidatorsEnumerator.Current);
Assert.IsFalse(valueValidatorsEnumerator.MoveNext());
}
public void CreatedValidationResultWithNestedResultsReturnsADifferentEnumerableWithThem()
{
object target = new object();
Validator validator = new MockValidator(false);
ValidationResult nestedResult1 = new ValidationResult("nested1", target, "key", "tag", validator);
ValidationResult nestedResult2 = new ValidationResult("nested2", target, "key", "tag", validator);
IList<ValidationResult> nestedResults = new List<ValidationResult>(new ValidationResult[] { nestedResult1, nestedResult2 });
ValidationResult validationResult = new ValidationResult("message", target, "key", "tag", validator, nestedResults);
Assert.AreEqual("message", validationResult.Message);
Assert.AreSame(target, validationResult.Target);
Assert.AreEqual("key", validationResult.Key);
Assert.AreEqual("tag", validationResult.Tag);
Assert.AreSame(validator, validationResult.Validator);
IEnumerator<ValidationResult> nestedResultsEnumerator = validationResult.NestedValidationResults.GetEnumerator();
Assert.IsTrue(nestedResultsEnumerator.MoveNext());
Assert.AreSame(nestedResult1, nestedResultsEnumerator.Current);
Assert.IsTrue(nestedResultsEnumerator.MoveNext());
Assert.AreSame(nestedResult2, nestedResultsEnumerator.Current);
Assert.IsFalse(nestedResultsEnumerator.MoveNext());
}
public void AddedValueValidatorIsIncludedInResultingValidatorForAndWithoutNulls()
{
MockValidator<object> failingValueValidator = new MockValidator<object>(true);
CompositeValidatorBuilder builder
= new CompositeValidatorBuilder(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(value);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(value, failingValueValidator.ValidatedTargets[0]);
// does it ignore nulls? it should not
validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(2, failingValueValidator.ValidatedTargets.Count);
Assert.AreSame(null, failingValueValidator.ValidatedTargets[1]);
}
public void CreationWithVoidMethodNameThrows()
{
MockValidator <object> valueValidator = new MockValidator <object>(false);
new MethodReturnValueValidator <MethodReturnValueValidatorFixtureTestClass>("VoidMmethod", valueValidator);
}
public void IgnoreNullsAndAndCompositionCreatesIgnoreNullsWrapperAndWrappedAndValidator()
{
MockValidator<object> valueValidator1 = new MockValidator<object>(false);
MockValidator<object> valueValidator2 = new MockValidator<object>(false);
CompositeValidatorBuilder builder
= new CompositeValidatorBuilder(new MockValidatedElement(true, "ignore nulls", "ignore nulls tag",
CompositionType.And, null, null));
builder.AddValueValidator(valueValidator1);
builder.AddValueValidator(valueValidator2);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
Assert.AreSame(typeof(NullIgnoringValidatorWrapper), validator.GetType());
Assert.AreSame(typeof(AndCompositeValidator), ((NullIgnoringValidatorWrapper)validator).WrappedValidator.GetType());
IEnumerator<Validator> valueValidatorsEnumerator = ((AndCompositeValidator)((NullIgnoringValidatorWrapper)validator).WrappedValidator).Validators.GetEnumerator();
Assert.IsTrue(valueValidatorsEnumerator.MoveNext());
Assert.AreSame(valueValidator1, valueValidatorsEnumerator.Current);
Assert.IsTrue(valueValidatorsEnumerator.MoveNext());
Assert.AreSame(valueValidator2, valueValidatorsEnumerator.Current);
Assert.IsFalse(valueValidatorsEnumerator.MoveNext());
}
public void CreationWithMethodWithParametersNameThrows()
{
MockValidator <object> valueValidator = new MockValidator <object>(false);
new MethodReturnValueValidator <MethodReturnValueValidatorFixtureTestClass>("PublicMethodWithParameters", valueValidator);
}
public void CreationWithNullValueValidatorThrows()
{
MockValidator <object> valueValidator = null;
new MethodReturnValueValidator <MethodReturnValueValidatorFixtureTestClass>("PublicMethod", valueValidator);
}
public void Setup()
{
AppDomain.CurrentDomain.SetData("APPBASE", Environment.CurrentDirectory);
MockValidator <object> .ResetCaches();
}
public void CanPerformValidationWithSuppliedValidationResults()
{
MockValidator<string> subValidator1 = new MockValidator<string>(false, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(true, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(false, "validator3");
Validator validator = new AndCompositeValidator(subValidator1, subValidator2, subValidator3);
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = new ValidationResults();
validator.Validate(target, validationResults);
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("validator2", resultsList[0].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void CanValidateThroughValueAccessValidatorUsingValueAccess()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(PropertyMappedControlValueAccessFixtureTestClass).AssemblyQualifiedName;
MockControl control = new MockControl();
control.Text = "control text";
validationProvider.SetSourcePropertyName(control, "StringProperty");
MockValidator valueValidator = new MockValidator(true, "message");
Validator validator = new ValueAccessValidator(new PropertyMappedControlValueAccess("StringProperty"), valueValidator);
ValidationResults validationResults
= validator.Validate(validationProvider.GetExistingValidatedControlItem(control));
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("StringProperty", resultsList[0].Key);
Assert.AreEqual("message", resultsList[0].Message);
Assert.AreEqual(null, resultsList[0].Tag);
Assert.AreSame(validationProvider.GetExistingValidatedControlItem(control), resultsList[0].Target);
Assert.AreSame(valueValidator, resultsList[0].Validator);
Assert.AreEqual("control text", valueValidator.ValidatedTargets[0]);
}
public void CreationWithNonReadablePropertyNameThrows()
{
MockValidator<object> valueValidator = new MockValidator<object>(false);
new PropertyValueValidator<PropertyValueValidatorFixtureTestClass>("NonReadableProperty", valueValidator);
}
public void CanPerformValidationWithSuppliedValidationResults()
{
MockValidator<string> subValidator1 = new MockValidator<string>(true, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(true, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(true, "validator3");
Validator validator = new OrCompositeValidator(subValidator1, subValidator2, subValidator3);
validator.Tag = "tag";
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = new ValidationResults();
validator.Validate(target, validationResults);
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.OrCompositeValidatorDefaultMessageTemplate, resultsList[0].Message));
Assert.AreEqual("tag", resultsList[0].Tag);
IList<ValidationResult> nestedResultsList = ValidationTestHelper.GetResultsList(resultsList[0].NestedValidationResults);
Assert.AreEqual(3, nestedResultsList.Count);
Assert.AreEqual("validator1", nestedResultsList[0].Message);
Assert.AreEqual("validator2", nestedResultsList[1].Message);
Assert.AreEqual("validator3", nestedResultsList[2].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void CreationWithNullValueValidatorThrows()
{
MockValidator <object> valueValidator = null;
new FieldValueValidator <FieldValueValidatorFixtureTestClass>("PublicField", valueValidator);
}
public void IgnoreNullsAndOrCompositionCreatesIgnoreNullsWrapperAndWrappedOrValidatorWithSuppliedMessageTemplate()
{
MockValidator<object> valueValidator1 = new MockValidator<object>(false);
MockValidator<object> valueValidator2 = new MockValidator<object>(false);
CompositeValidatorBuilder builder
= new CompositeValidatorBuilder(new MockValidatedElement(true, "ignore nulls", null,
CompositionType.Or, "composition template", "composition tag"));
builder.AddValueValidator(valueValidator1);
builder.AddValueValidator(valueValidator2);
Validator validator = builder.GetValidator();
Assert.IsNotNull(validator);
Assert.AreSame(typeof(NullIgnoringValidatorWrapper), validator.GetType());
Assert.AreSame(typeof(OrCompositeValidator), ((NullIgnoringValidatorWrapper)validator).WrappedValidator.GetType());
Assert.AreEqual("composition template", ((NullIgnoringValidatorWrapper)validator).WrappedValidator.MessageTemplate);
Assert.AreEqual("composition tag", ((NullIgnoringValidatorWrapper)validator).WrappedValidator.Tag);
IEnumerator<Validator> valueValidatorsEnumerator = ((OrCompositeValidator)((NullIgnoringValidatorWrapper)validator).WrappedValidator).Validators.GetEnumerator();
Assert.IsTrue(valueValidatorsEnumerator.MoveNext());
Assert.AreSame(valueValidator1, valueValidatorsEnumerator.Current);
Assert.IsTrue(valueValidatorsEnumerator.MoveNext());
Assert.AreSame(valueValidator2, valueValidatorsEnumerator.Current);
Assert.IsFalse(valueValidatorsEnumerator.MoveNext());
}
public void CreationWithNonPublicFieldNameThrows()
{
MockValidator<object> valueValidator = new MockValidator<object>(false);
new FieldValueValidator<FieldValueValidatorFixtureTestClass>("NonPublicField", valueValidator);
}
public void CreationWithNonPublicFieldNameThrows()
{
MockValidator <object> valueValidator = new MockValidator <object>(false);
new FieldValueValidator <FieldValueValidatorFixtureTestClass>("NonPublicField", valueValidator);
}
public void ReturnsCompositeFailureAfterQueryingAllValidatorsIfAllValidatorsReturnFailure()
{
MockValidator<string> subValidator1 = new MockValidator<string>(true, "validator1");
MockValidator<string> subValidator2 = new MockValidator<string>(true, "validator2");
MockValidator<string> subValidator3 = new MockValidator<string>(true, "validator3");
Validator validator = new OrCompositeValidator(subValidator1, subValidator2, subValidator3);
validator.MessageTemplate = "composite validator";
string target = new string('a', 10); // just any string, but a new one
ValidationResults validationResults = validator.Validate(target);
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.AreEqual("composite validator", resultsList[0].Message);
Assert.AreEqual(null, resultsList[0].Tag);
IList<ValidationResult> nestedResultsList = ValidationTestHelper.GetResultsList(resultsList[0].NestedValidationResults);
Assert.AreEqual(3, nestedResultsList.Count);
Assert.AreEqual("validator1", nestedResultsList[0].Message);
Assert.AreEqual("validator2", nestedResultsList[1].Message);
Assert.AreEqual("validator3", nestedResultsList[2].Message);
Assert.AreSame(target, subValidator1.ValidatedTargets[0]);
Assert.AreSame(target, subValidator2.ValidatedTargets[0]);
Assert.AreSame(target, subValidator3.ValidatedTargets[0]);
}
public void TestInitialize()
{
MockValidator <object> .ResetCaches();
ValidationFactory.SetDefaultConfigurationValidatorFactory(new SystemConfigurationSource(false));
}
