public void NotNullOrEmptyValidator_PassesNotNull()
{
IValidationRule rule = ValidationBuilder.Create().NotNullOrEmpty().Validator;
var result1 = rule.Validate("dsfj;kdsf");
var result2 = rule.Validate(new object());
Assert.True(result1.IsValid);
Assert.True(result2.IsValid);
}
public void NotNullOrEmptyValidator_FailsForNullOrEmpty()
{
IValidationRule rule = ValidationBuilder.Create().NotNullOrEmpty().Validator;
var result1 = rule.Validate(null);
var result2 = rule.Validate(string.Empty);
var result3 = rule.Validate("");
Assert.False(result1.IsValid);
Assert.False(result2.IsValid);
Assert.False(result3.IsValid);
}
public void LengthValidator_ValidateExact()
{
IValidationRule rule = ValidationBuilder.Create().Length(3).Validator;
var result1 = rule.Validate("124");
var result2 = rule.Validate("1234");
var result3 = rule.Validate(123);
var result4 = rule.Validate("1");
Assert.True(result1.IsValid);
Assert.False(result2.IsValid);
Assert.False(result3.IsValid);
Assert.False(result4.IsValid);
}
/// <summary>
/// Performs the given validation rule for the specified property.
/// </summary>
/// <param name="rule">The rule.</param>
/// <param name="property">The property.</param>
/// <param name="validationProxy">A validation proxy can be specified.
/// When supplied, the validation rule and any errors associated with it will be stored within the proxy object instead of this instance.</param>
/// <exception cref="System.ArgumentNullException">
/// PerformValidation requires a registered property to be specified.
/// or
/// PerformValidation requires a registered property to be specified.
/// </exception>
public void PerformValidation(IValidationRule rule, string property, IValidatable validationProxy = null)
{
PropertyInfo propertyInfo = null;
if (string.IsNullOrEmpty(property))
{
throw new ArgumentNullException("PerformValidation requires a registered property to be specified.");
}
else
{
propertyInfo = ValidatableBase.PropertyValidationCache[this.GetType()]
.FirstOrDefault(kv => kv.Key.Name.Equals(property)).Key;
}
if (propertyInfo == null)
{
throw new ArgumentNullException("PerformValidation requires a registered property to be specified.");
}
if (validationProxy != null && validationProxy is IValidatable)
{
var proxy = validationProxy as IValidatable;
proxy.PerformValidation(rule, propertyInfo.Name);
}
else
{
IValidationMessage result = rule.Validate(propertyInfo, this);
if (result != null)
{
this.AddValidationMessage(result, propertyInfo.Name);
}
}
}
public void LengthValidator_ValidateRange()
{
IValidationRule rule = ValidationBuilder.Create().Length(3, 5).Validator;
var result1 = rule.Validate("12");
var result2 = rule.Validate("123");
var result3 = rule.Validate("1234");
var result4 = rule.Validate("12345");
var result5 = rule.Validate("123456");
Assert.False(result1.IsValid);
Assert.True(result2.IsValid);
Assert.True(result3.IsValid);
Assert.True(result4.IsValid);
Assert.False(result5.IsValid);
}
public void Validate(string path, Schema schema, object value, List <ValidationResult> results)
{
if (_rule == null)
{
return;
}
var localResults = new List <ValidationResult>();
_rule.Validate(path, schema, value, localResults);
if (localResults.Count > 0)
{
return;
}
results.Add(
new ValidationResult(
path,
ValidationResultType.Error,
"NOT_FAILED",
"Negative check failed",
null,
null
)
);
}
private void HandleValidationRule(
ChangeOfChargesMessage changeOfChargesMessage,
IValidationRule validationRule,
HubRequestValidationResult validationResult)
{
const string unknownServerError = "Unknown server error";
try
{
if (_ruleConfigurations == null)
{
validationResult.Add(new ValidationError("VR900", unknownServerError));
_logger.LogError($"{nameof(_ruleConfigurations)} was null");
return;
}
var ruleValidationResult = validationRule.Validate(changeOfChargesMessage, _ruleConfigurations);
if (ruleValidationResult.ValidatedSuccessfully is false)
{
validationResult.Add(ruleValidationResult.ValidationError);
}
}
catch (RuleNotFoundException ruleNotFoundException)
{
validationResult.Add(new ValidationError("VRXYZ", unknownServerError));
_logger.LogError(ruleNotFoundException, "Rule configuration could not be found");
}
catch (RuleCouldNotBeMappedException ruleCouldNotBeMappedException)
{
validationResult.Add(new ValidationError("VRXYZ", unknownServerError));
_logger.LogError(ruleCouldNotBeMappedException, "Rule value could not be mapped");
}
}
public void PathValidator_DirectoryValidation()
{
IValidationRule rule = ValidationBuilder.Create().Directory().Validator;
string dir = "TestDirectory";
Directory.CreateDirectory(dir);
var result1 = rule.Validate(dir);
Assert.True(result1.IsValid);
Directory.Delete(dir);
var result2 = rule.Validate(dir);
Assert.False(result2.IsValid);
}
public async Task ValidateRule <TValidationRule, TViewModel>(IValidationRule <TViewModel> validationRule, TViewModel viewModel)
where TValidationRule : class, IValidationRule <TViewModel>
where TViewModel : class
{
if (validationRule != null)
{
await validationRule.Validate(viewModel);
}
}
public bool Validate()
{
Errors.Clear();
IsValid = validation.Validate(this);
// Errors = validation.ErrorMessages.ToList();
return(this.IsValid);
}
public void Validation_should_be_false()
{
IValidationRule <string> mockRule = A.Fake <IValidationRule <string> >();
A.CallTo(() => mockRule.Validate(A <string> ._)).Returns(false);
ValidatableObject <string> stringObject = new ValidatableObject <string>(mockRule);
stringObject.Validate();
stringObject.IsValid.Should().BeFalse();
}
private void listpicker_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ListPickerValidationControl control = (ListPickerValidationControl)sender;
if (control.SelectedItem != null)
{
IValidationRule v = (IValidationRule)control.ValidationRule;
control.IsValid = v.Validate(((CustomListBoxItem <Person>)control.SelectedItem).Value == "Choose ..." ? "" : "valid");;
}
}
public void ErrorMessage_should_be_equal_to_given_message()
{
string message = "The error message of the rule";
IValidationRule <string> mockValidationRule = A.Fake <IValidationRule <string> >();
A.CallTo(() => mockValidationRule.Message).Returns(message);
A.CallTo(() => mockValidationRule.Validate(A <string> ._)).Returns(false);
ValidatableObject <string> stringObject = new ValidatableObject <string>(mockValidationRule);
stringObject.Messages.Should().Contain(message);
}
public void PathValidator_FileValidation()
{
IValidationRule rule = ValidationBuilder.Create().File().Validator;
string filename = "test.txt";
var stream = File.Create(filename);
stream.Close();
stream.Dispose();
var result1 = rule.Validate(filename);
Assert.True(result1.IsValid);
File.Delete(filename);
var result2 = rule.Validate(filename);
Assert.False(result2.IsValid);
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
var isValid = false;
var errorMessage = "";
ValidationRule.Validate(value, out isValid, out errorMessage);
var result = new ValidationResult(isValid, errorMessage);
return(result);
}
protected override void OnLostFocus(RoutedEventArgs e)
{
bool isInputValid = true;
IValidationRule validationRule = this.ValidationRule;
if (validationRule != null)
{
isInputValid = validationRule.Validate(this.Text);
}
this.IsValid = isInputValid;
base.OnLostFocus(e);
}
/// <summary>
/// Check if validation rule is valid
/// </summary>
private void CheckRule(IValidationRule validationRule)
{
if (!validationRule.Validate())
{
if (validationRule.ValidationType == ValidationType.Error)
{
ValidationResult.Errors.Add(validationRule.GetMessage());
}
else
{
ValidationResult.Warnings.Add(validationRule.GetMessage());
}
}
}
/// <summary>
/// Executes the validation rule supplied for the specified property.
/// </summary>
/// <param name="rule">The rule.</param>
/// <param name="property">The property.</param>
/// <param name="validationProxy">The validation proxy.</param>
private void PerformValidation(IValidationRule rule, PropertyInfo property, IValidatable validationProxy = null)
{
if (validationProxy != null && validationProxy is ValidatableBase)
{
var proxy = validationProxy as ValidatableBase;
proxy.PerformValidation(rule, property);
}
var result = rule.Validate(property, this);
if (result != null)
{
AddValidationMessage(result, property.Name);
}
}
/// <summary>
/// Validates an entity against all validations defined for the entity.
/// </summary>
/// <param name="entity">The <typeparamref name="TEntity"/> to validate.</param>
/// <returns>A <see cref="ValidationResult"/> that contains the results of the validation.</returns>
public ValidationResult Validate(TEntity entity)
{
ValidationResult result = new ValidationResult();
_validations.Keys.ForEach(x =>
{
IValidationRule <TEntity> rule = _validations[x];
if (!rule.Validate(entity))
{
result.AddError(new ValidationError(rule.ValidationMessage,
rule.ValidationProperty));
}
});
return(result);
}
public bool Validate(string property, string propertyName, out ICollection <string> validationErrors)
{
switch (propertyName)
{
case "Login":
_validationRule = new LoginValidationRule();
break;
case "Password":
_validationRule = new PasswordValidationRule();
break;
default:
break;
}
return(_validationRule.Validate(property, out validationErrors));
}
public void One_ErrorMessages_should_be_equal_to_given_messages()
{
string messageMail = "The mail message of the rule";
string messageLength = "The length message of the rule";
IValidationRule <string> mockMailRule = A.Fake <IValidationRule <string> >();
A.CallTo(() => mockMailRule.Message).Returns(messageMail);
A.CallTo(() => mockMailRule.Validate(A <string> ._)).Returns(false);
IValidationRule <string> mockLengthRule = A.Fake <IValidationRule <string> >();
A.CallTo(() => mockLengthRule.Message).Returns(messageLength);
A.CallTo(() => mockLengthRule.Validate(A <string> ._)).Returns(true);
ValidatableObject <string> stringObject = new ValidatableObject <string>(mockMailRule, mockLengthRule);
stringObject.Messages.Should().Contain(messageMail);
stringObject.Messages.Should().NotContain(messageLength);
}
public void ValidateObject(object sender, EventArgs e, UIElementCollection UIElements, List <ListPickerValidationControl> listpickers)
{
foreach (UIElement ui in UIElements)
{
if (ui.GetType() == typeof(ValidationControl))
{
ValidationControl control = (ValidationControl)ui;
IValidationRule v = (IValidationRule)control.ValidationRule;
IsPageValid = v.Validate(control.Text);
control.IsValid = IsPageValid;
}
else if (ui.GetType() == typeof(ListPickerValidationControl))
{
ListPickerValidationControl control = (ListPickerValidationControl)ui;
IValidationRule v = (IValidationRule)control.ValidationRule;
IsPageValid = v.Validate(((ICustomListBox)control.SelectedItem).Value == "Choose ..." ? "" : "valid");
control.IsValid = IsPageValid;
}
}
}
/// <summary>
/// Executes the validation rule supplied for the specified property.
/// </summary>
/// <param name="rule">The rule.</param>
/// <param name="property">The property.</param>
/// <param name="validationProxy">The validation proxy.</param>
private void PerformValidation(IValidationRule rule, PropertyInfo property, IValidatable validationProxy = null)
{
if (validationProxy != null && validationProxy is ValidatableBase)
{
var proxy = validationProxy as ValidatableBase;
proxy.PerformValidation(rule, property);
}
IValidationMessage result = null;
try
{
result = rule.Validate(property, this);
}
catch (Exception)
{
throw;
}
if (result != null)
{
this.AddValidationMessage(result, property.Name);
}
}
public Option <TNewError> Validate(TValue value) => _validationRule .Validate(value) .Map(_mapError);
public override void Evaluate()
{
var valid = !_rule.Validate();
RuleState.AddMessage(!valid, ResourceName, new NotAllowedByRule());
}
