public void IsValidWhenAllValidatorsAreValid()
{
var validatableObject = new ValidatableTestObject();
var validator = PropertyValidator
.For(validatableObject, o => o.SomeStringProperty)
.Required("Error occurred!");
var anotherValidator = PropertyValidator
.For(validatableObject, o => o.AnotherStringProperty)
.Required("Error occurred!");
var modelValidator = new ModelValidator(validator, anotherValidator);
Assert.IsFalse(modelValidator.IsValid);
validatableObject.SomeStringProperty = "valid";
Assert.IsFalse(modelValidator.IsValid);
validatableObject.AnotherStringProperty = "valid";
Assert.IsTrue(modelValidator.IsValid);
validatableObject.AnotherStringProperty = "";
Assert.IsFalse(modelValidator.IsValid);
}
public void ValidationResultReturnsUnvalidatedIfNoValidators()
{
var validatableObject = new ValidatableTestObject();
var validator = PropertyValidator.For(validatableObject, o => o.SomeStringProperty);
var result = validator.ValidationResult;
Assert.AreEqual(PropertyValidationResult.Unvalidated, result);
}
public void TryParseDecimal_culture_specific_should_pass()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.DecimalValue);
validator.TryParseDecimal(new CultureInfo("fr-FR"))
.Validate(new Row()
{
DecimalValue = "-1234,55"
});
Assert.True(validator.IsValid);
}
public void TryParseDecimal_negative_value_should_pass()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.DecimalValue);
validator.TryParseDecimal(CultureInfo.InvariantCulture)
.Validate(new Row()
{
DecimalValue = "-1234.55"
});
Assert.True(validator.IsValid);
}
public void TryParseDecimal_should_fail()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.DecimalValue);
validator.TryParseDecimal()
.Validate(new Row()
{
DecimalValue = "a1234"
});
Assert.False(validator.IsValid);
}
public void DoesNotShowErrorWhenUnvalidated()
{
var viewModel = new ValidatableTestObject();
var testValidator = PropertyValidator.For(viewModel, x => x.SomeStringProperty)
.Required("Please enter some text");
var validationMessage = new ValidationMessage();
validationMessage.Validator = testValidator;
Assert.IsFalse(validationMessage.ShowError);
}
public void RequiredIsUnvalidatedAndNotValidIfPropertyNeverChanges()
{
var validatableObject = new ValidatableTestObject();
var validator = PropertyValidator
.For(validatableObject, o => o.SomeStringProperty)
.Required("Please provide a value for SomeStringProperty!");
var result = validator.ValidationResult;
Assert.IsFalse(result.IsValid);
Assert.AreEqual(PropertyValidationResult.Unvalidated, result);
}
public void TryDateTime_should_fail()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.DateTimeValue);
validator
.TryParseDateTime("yyyyMMdd")
.Validate(new Row()
{
DateTimeValue = "20201320"
});
Assert.False(validator.IsValid);
}
public void IsNotNull_should_fail()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.Key);
validator
.IsNotNull()
.Validate(new Row()
{
Key = null
});
Assert.False(validator.IsValid);
}
public void IsNotNull_default_message()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.Key);
validator
.IsNotNull()
.Validate(new Row()
{
Key = null
});
Assert.Equal("Field Key : Value is mandatory", validator.ValidationErrors[0].ErrorMessage);
}
public void IsNotNull_should_pass()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.Key);
validator
.IsNotNull()
.Validate(new Row()
{
Key = "hasValue"
});
Assert.True(validator.IsValid);
}
public void TryRegex_should_fail()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.Key);
validator
.TryRegex("^[a-z0-9\\-]+$")
.Validate(new Row()
{
Key = "key-0123"
});
Assert.True(validator.IsValid);
}
public void IsStringValues_should_fail()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.Key);
validator
.IsNotNullOrEmpty()
.IsStringValues(TypesValues)
.Validate(new Row()
{
Key = "B"
});
Assert.False(validator.IsValid);
}
public void RequiredValidatesPropertyNotEmpty()
{
var validatableObject = new ValidatableTestObject();
var validator = PropertyValidator
.For(validatableObject, o => o.SomeStringProperty)
.Required("Please provide a value for SomeStringProperty!");
validatableObject.SomeStringProperty = "";
var result = validator.ValidationResult;
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Please provide a value for SomeStringProperty!", result.Message);
}
public void ValidationResultReturnsSuccessIfValidatorsPass()
{
var validatableObject = new ValidatableTestObject();
// Validator validates that the property is equal to the string "Inigo Montoya".
var validator = PropertyValidator
.For(validatableObject, o => o.SomeStringProperty)
.ValidIfTrue(value => value == "Inigo Montoya", "Error occurred!");
validatableObject.SomeStringProperty = "Inigo Montoya";
var result = validator.ValidationResult;
Assert.IsTrue(result.IsValid);
}
public void ShowsErrorWhenValidationResultIsInvalid()
{
var viewModel = new ValidatableTestObject();
var testValidator = PropertyValidator.For(viewModel, x => x.SomeStringProperty)
.Required("Please enter some text");
var validationMessage = new ValidationMessage();
validationMessage.Validator = testValidator;
viewModel.SomeStringProperty = "valid";
viewModel.SomeStringProperty = "";
Assert.AreEqual(ValidationStatus.Invalid, testValidator.ValidationResult.Status);
Assert.IsTrue(validationMessage.ShowError);
}
public void ValidationResultReturnsFailureIfAnyValidatorsFail()
{
var validatableObject = new ValidatableTestObject();
var validator = PropertyValidator
.For(validatableObject, o => o.SomeStringProperty)
.Required("String may not be null or empty")
.ValidIfTrue(value => value == "Inigo Montoya", "Error occurred!")
.ValidIfTrue(value => value == "My name is not Inigo Montoya", "Doh!");
validatableObject.SomeStringProperty = "My name is not Inigo Montoya";
var result = validator.ValidationResult;
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Error occurred!", result.Message);
}
public CredentialsViewModel()
{
LoginCommand = new ActionCommand(_ => Result = AuthenticationDialogResult.Ok);
CancelCommand = new ActionCommand(_ => Result = AuthenticationDialogResult.Cancel);
LoginValidator = PropertyValidator.For(this, x => x.Login)
.Required(Resources.LoginRequired);
PasswordValidator = PropertyValidator.For(this, x => x.Password)
.Required(Resources.PasswordRequired);
ModelValidator = new ModelValidator(LoginValidator, PasswordValidator);
ModelValidator.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(ModelValidator.IsValid))
{
IsValid = ModelValidator.IsValid;
}
};
}
public CredentialsViewModel(string username)
{
LoginCommand = new RelayCommand(Accept, () => IsValid);
CancelCommand = new RelayCommand(Cancel);
ForgotPasswordCommand = new RelayCommand(() => BrowserHelper.OpenDefaultBrowser(BitbucketResources.PasswordResetUrl));
SignUpCommand = new RelayCommand(() => BrowserHelper.OpenDefaultBrowser(BitbucketResources.SignUpLinkUrl));
LoginValidator = PropertyValidator.For(this, x => x.Login).Required(BitbucketResources.LoginRequired);
PasswordValidator = PropertyValidator.For(this, x => x.Password).Required(BitbucketResources.PasswordRequired);
_modelValidator.Add(LoginValidator);
_modelValidator.Add(PasswordValidator);
_modelValidator.IsValidChanged += (s, e) => LoginCommand.RaiseCanExecuteChanged();
// Set last to allow validator to run
if (!string.IsNullOrWhiteSpace(username))
{
Login = username;
}
}
public void ClassValidator_list_oneerror()
{
ClassValidator <Row> validator = ClassValidator <Row>
.Init()
.AddProperty(PropertyValidator <Row> .For(x => x.Key).IsNotNull())
.AddProperty(PropertyValidator <Row> .For(x => x.DateTimeValue).IsNotNull()) // error
.ValidateList(
new List <Row>()
{
new Row()
{
Key = "notnull", DateTimeValue = null
},
new Row()
{
Key = "notnull", DateTimeValue = null
}
}
);
Assert.Equal(2, validator.ValidationErrors.Count);
}
public void IsNotNull_override_message()
{
PropertyValidator <Row> validatorA = PropertyValidator <Row> .For(x => x.Key);
validatorA
.IsNotNull().OverrideErrorMessage(m => $"override default message")
.Validate(new Row()
{
Key = null
});
Assert.Equal("override default message", validatorA.ValidationErrors[0].ErrorMessage);
PropertyValidator <Row> validatorB = PropertyValidator <Row> .For(x => x.Key);
validatorB
.IsNotNull().OverrideErrorMessage(m => $"override default message", true)
.Validate(new Row()
{
Key = null
});
Assert.Equal("Field Key : override default message", validatorB.ValidationErrors[0].ErrorMessage);
}
public void EndToEndTestShowsErrorMessageWhenReactiveValidatorIsNotValid()
{
var textBox = new TextBox();
var viewModel = new ValidatableTestObject();
var testValidator = PropertyValidator.For(viewModel, x => x.SomeStringProperty)
.Required("Please enter some text");
var validationMessage = new ValidationMessage();
BindControlToViewModel(viewModel, nameof(viewModel.SomeStringProperty), textBox, TextBox.TextProperty);
validationMessage.Validator = testValidator;
Assert.IsFalse(validationMessage.ShowError);
textBox.Text = "x";
Assert.AreEqual("x", viewModel.SomeStringProperty);
textBox.Text = "";
Assert.AreEqual("", viewModel.SomeStringProperty);
Assert.IsFalse(testValidator.ValidationResult.IsValid);
Assert.IsTrue(validationMessage.ShowError);
}
public void ValidationResultNotifiesWhenValidationStateChanges()
{
var validatableObject = new ValidatableTestObject();
// Validator validates that the property is equal to the string "Inigo Montoya".
var validator = PropertyValidator
.For(validatableObject, o => o.SomeStringProperty)
.ValidIfTrue(value => value == "Inigo Montoya", "Error occurred!");
PropertyValidationResult validationResult = null;
validator.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(validator.ValidationResult))
{
validationResult = validator.ValidationResult;
}
};
Assert.IsNull(validationResult); // Precondition
validatableObject.SomeStringProperty = "not empty";
Assert.AreEqual(validationResult, validator.ValidationResult);
Assert.IsFalse(validationResult.IsValid);
}
public void IsStringValues_without_and_with_ignore_case()
{
var row = new Row()
{
Key = "p"
};
PropertyValidator <Row> validatorMustFail = PropertyValidator <Row> .For(x => x.Key);
validatorMustFail
.IsNotNullOrEmpty()
.IsStringValues(TypesValues)
.Validate(row);
Assert.False(validatorMustFail.IsValid);
PropertyValidator <Row> validatorMustSuccess = PropertyValidator <Row> .For(x => x.Key);
validatorMustSuccess
.IsNotNullOrEmpty()
.IsStringValues(TypesValues, StringComparer.CurrentCultureIgnoreCase)
.Validate(row);
Assert.True(validatorMustSuccess.IsValid);
}
public void ValidatorsRunInOrderAndStopWhenInvalid()
{
List <int> results = new List <int>();
var validatableObject = new ValidatableTestObject();
var validator = PropertyValidator
.For(validatableObject, o => o.SomeStringProperty)
.ValidIfTrue(value => { results.Add(0); return(true); }, "Error occurred!")
.ValidIfTrue(value => { results.Add(1); return(true); }, "Error occurred!")
.ValidIfTrue(value => { results.Add(2); return(true); }, "Error occurred!")
.ValidIfTrue(value => { results.Add(3); return(false); }, "Error occurred!")
.ValidIfTrue(value => { results.Add(4); return(true); }, "Error occurred!");
validatableObject.SomeStringProperty = "My name is not Inigo Montoya";
var result = validator.ValidationResult;
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Error occurred!", result.Message);
Assert.AreEqual(4, results.Count);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(i, results[i]);
}
}
public void IfTest_trials()
{
PropertyValidator <Row> validator = PropertyValidator <Row> .For(x => x.DecimalValue);
validator.If(x => x.Key == "P", p => p.IsNotNull().TryParseDecimal());
validator.Validate(new Row()
{
Key = "Z"
});
Assert.True(validator.IsValid);
validator.Validate(new Row()
{
Key = "P"
});
Assert.False(validator.IsValid);
validator.Validate(new Row()
{
Key = "P", DecimalValue = "123"
});
Assert.True(validator.IsValid);
validator.Validate(new Row()
{
Key = "P", DecimalValue = "123,12"
}); // test decimal separator
Assert.True(validator.IsValid);
validator.Validate(new Row()
{
Key = "Z", DecimalValue = "123,12"
});
Assert.True(validator.IsValid);
}
public CredentialsViewModel(string username)
{
LoginCommand = new ActionCommand(_ => Result = AuthenticationDialogResult.Ok);
CancelCommand = new ActionCommand(_ => Result = AuthenticationDialogResult.Cancel);
LoginValidator = PropertyValidator.For(this, x => x.Login).Required(Resources.LoginRequired);
PasswordValidator = PropertyValidator.For(this, x => x.Password).Required(Resources.PasswordRequired);
ModelValidator = new ModelValidator(LoginValidator, PasswordValidator);
ModelValidator.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(ModelValidator.IsValid))
{
IsValid = ModelValidator.IsValid;
}
};
// set last to allow validator to run
if (!string.IsNullOrWhiteSpace(username))
{
Login = username;
}
}
public void IsNotNull_should_fail()
{
PropertyValidator <Row> validator1 = PropertyValidator <Row> .For(x => x.Key);
validator1
.IsNotNull()
.HasLength(1, 5)
.Validate(new Row()
{
Key = ""
});
Assert.False(validator1.IsValid);
PropertyValidator <Row> validator2 = PropertyValidator <Row> .For(x => x.Key);
validator2
.IsNotNull()
.HasLength(0, 5)
.Validate(new Row()
{
Key = "123456"
});
Assert.False(validator2.IsValid);
}
