public void DoubleInitializedValidatorShouldThrowErrorTest()
{
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
ShouldThrow <InvalidOperationException>(
() => validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())));
}
public void ValidateMethodShouldRaiseErrorsChangedEvent()
{
int countInvoke = 0;
ValidatorBase validator = GetValidator();
INotifyDataErrorInfo notifyDataError = validator;
notifyDataError.ErrorsChanged += (sender, args) =>
{
args.PropertyName.ShouldEqual(PropertyToValidate);
countInvoke++;
};
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
notifyDataError.HasErrors.ShouldBeFalse();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
countInvoke.ShouldEqual(1);
notifyDataError.HasErrors.ShouldBeTrue();
if (validator is ManualValidator)
{
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
}
else
{
validator.ValidateAsync(PropertyToValidate);
}
countInvoke.ShouldEqual(2);
}
public void ValidatorShouldUsePropertyMappings()
{
ValidatorBase validator = GetValidator();
var dictionary = new Dictionary <string, ICollection <string> >
{
{
PropertyToValidate,
new List <string> {
PropertyToMap
}
}
};
validator.Initialize(new ValidatorContext(new object(), dictionary, null, null, GetServiceProvider()));
validator.IsValid.ShouldBeTrue();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
validator.IsValid.ShouldBeFalse();
validator.GetErrors(PropertyToValidate).ShouldBeEmpty();
string[] errors = validator.GetErrors(PropertyToMap).OfType <string>().ToArray();
errors.Length.ShouldEqual(1);
errors.Contains(ValidatorError).ShouldBeTrue();
validator.UpdateErrors(PropertyToMap, null, false);
validator.GetErrors(PropertyToMap).ShouldBeEmpty();
validator.IsValid.ShouldBeTrue();
}
public void IsValidShouldBeFalseIfValidatorHasErrors()
{
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.IsValid.ShouldBeTrue();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
validator.IsValid.ShouldBeFalse();
validator.UpdateErrors(PropertyToValidate, null, false);
validator.IsValid.ShouldBeTrue();
}
public void ValidatorShouldUseIgnorePropertiesCollection()
{
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), null, new List <string> {
PropertyToValidate
}, null,
GetServiceProvider()));
validator.IsValid.ShouldBeTrue();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
validator.IsValid.ShouldBeTrue();
validator.GetErrors(PropertyToValidate).ShouldBeEmpty();
}
public void GetAllErrorsShouldReturnAllValidatorErrors()
{
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
validator.UpdateErrors(PropertyToMap, ValidatorErrors, false);
var allErrors = validator.GetErrors();
allErrors.Count.ShouldEqual(2);
allErrors[PropertyToValidate].Single().ShouldEqual(ValidatorError);
allErrors[PropertyToMap].Single().ShouldEqual(ValidatorError);
}
public void UpdateErrorsShouldRaiseEvent()
{
bool isInvoked = false;
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.ErrorsChanged += (sender, args) =>
{
sender.ShouldEqual(validator);
args.PropertyName.ShouldEqual(PropertyToValidate);
isInvoked = true;
};
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
isInvoked.ShouldBeTrue();
}
public void ValidatorShouldUpdateErrors()
{
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
validator.UpdateErrors(PropertyToMap, ValidatorErrors, false);
validator.GetErrors(PropertyToValidate).OfType <object>().Single().ShouldEqual(ValidatorError);
validator.GetErrors(PropertyToMap).OfType <object>().Single().ShouldEqual(ValidatorError);
validator.ClearErrors();
validator.GetErrors(PropertyToValidate).OfType <object>().ShouldBeEmpty();
validator.GetErrors(PropertyToMap).OfType <object>().ShouldBeEmpty();
validator.IsValid.ShouldBeTrue();
}
public void GetErrorsShouldReturnValidatorErrors()
{
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.GetErrors(PropertyToValidate).ShouldBeEmpty();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
validator.GetErrors(PropertyToValidate).OfType <object>().Single().ShouldEqual(ValidatorError);
validator.UpdateErrors(PropertyToValidate, new object[] { ValidatorError, ValidatorError }, false);
var errors = validator.GetErrors(PropertyToValidate).OfType <object>().ToArray();
errors.Length.ShouldEqual(2);
errors.All(o => Equals(o, ValidatorError)).ShouldBeTrue();
}
public void UpdateErrorsShouldNotifyListeners()
{
int count = 0;
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.ErrorsChanged += (sender, args) =>
{
sender.ShouldEqual(validator);
count++;
args.PropertyName.ShouldEqual(PropertyToValidate);
};
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, true);
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
count.ShouldEqual(2);
}
public void DataErrorTest()
{
ValidatorBase validator = GetValidator();
IDataErrorInfo validatorDataError = validator;
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.IsValid().ShouldBeTrue();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
string error = validatorDataError[PropertyToValidate];
error.ShouldEqual(ValidatorError);
validator.IsValid().ShouldBeFalse();
validator.UpdateErrors(PropertyToValidate, null, false);
error = validatorDataError[PropertyToValidate];
error.ShouldBeNull();
validator.IsValid().ShouldBeTrue();
}
public virtual void ValidatorShouldClearOldErrorsValidateAll()
{
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
validator.ValidateAsync().Wait();
if (validator is ManualValidator)
{
var allErrors = validator.GetErrors();
allErrors.Count.ShouldEqual(1);
allErrors[PropertyToValidate].Single().ShouldEqual(ValidatorErrors[0]);
}
else
{
validator.IsValid.ShouldBeTrue();
}
}
public void NotifyDataErrorInfoTest()
{
ValidatorBase validator = GetValidator();
INotifyDataErrorInfo notifyDataError = validator;
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
notifyDataError.HasErrors.ShouldBeFalse();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false);
notifyDataError.HasErrors.ShouldBeTrue();
string[] errors = notifyDataError
.GetErrors(PropertyToValidate)
.OfType <string>()
.ToArray();
errors.Length.ShouldEqual(1);
errors.Contains(ValidatorError).ShouldBeTrue();
validator.UpdateErrors(PropertyToValidate, null, false);
notifyDataError.GetErrors(PropertyToValidate).ShouldBeEmpty();
notifyDataError.HasErrors.ShouldBeFalse();
}
public void UpdateErrorsShouldNotifyListeners()
{
bool isAsync = false;
ValidatorBase validator = GetValidator();
validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()));
var spyHandler = new SpyHandler
{
HandleDelegate = (o, o1) =>
{
o.ShouldEqual(validator);
((DataErrorsChangedMessage)o1).PropertyName.ShouldEqual(PropertyToValidate);
((DataErrorsChangedMessage)o1).IsAsyncValidate.ShouldEqual(isAsync);
}
};
validator.Subscribe(spyHandler).ShouldBeTrue();
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, isAsync);
isAsync = true;
validator.UpdateErrors(PropertyToValidate, ValidatorErrors, isAsync);
spyHandler.HandleCount.ShouldEqual(2);
}
