public void Validates_with_nullable_property() {
var validator = new TestValidator(v => v.RuleFor(x => x.Id).LessThanOrEqualTo(x => x.NullableInt));
var resultNull = validator.Validate(new Person { Id = 0, NullableInt = null });
var resultLess = validator.Validate(new Person { Id = 0, NullableInt = -1 });
var resultEqual = validator.Validate(new Person { Id = 0, NullableInt = 0 });
var resultMore = validator.Validate(new Person { Id = 0, NullableInt = 1 });
resultNull.IsValid.ShouldBeFalse();
resultLess.IsValid.ShouldBeFalse();
resultEqual.IsValid.ShouldBeTrue();
resultMore.IsValid.ShouldBeTrue();
}
public void When_exact_length_rule_failes_error_should_have_exact_length_error_errorcode()
{
var validator = new TestValidator { v => v.RuleFor(x => x.Surname).Length(2) };
var result = validator.Validate(new Person() { Surname = "test" });
var error = result.Errors.SingleOrDefault(e => e.ErrorCode == "exact_length_error");
error.ShouldNotBeNull();
error.PropertyName.ShouldEqual("Surname");
error.AttemptedValue.ShouldEqual("test");
error.FormattedMessageArguments.Length.ShouldEqual(0);
error.FormattedMessagePlaceholderValues.Count.ShouldEqual(5);
error.FormattedMessagePlaceholderValues.ContainsKey("PropertyName").ShouldBeTrue();
error.FormattedMessagePlaceholderValues.ContainsKey("PropertyValue").ShouldBeTrue();
error.FormattedMessagePlaceholderValues.ContainsKey("MinLength").ShouldBeTrue();
error.FormattedMessagePlaceholderValues.ContainsKey("MaxLength").ShouldBeTrue();
error.FormattedMessagePlaceholderValues.ContainsKey("TotalLength").ShouldBeTrue();
error.FormattedMessagePlaceholderValues["PropertyName"].ShouldEqual("Surname");
error.FormattedMessagePlaceholderValues["PropertyValue"].ShouldEqual("test");
error.FormattedMessagePlaceholderValues["MinLength"].ShouldEqual(2);
error.FormattedMessagePlaceholderValues["MaxLength"].ShouldEqual(2);
error.FormattedMessagePlaceholderValues["TotalLength"].ShouldEqual(4);
}
public void Should_succeed_on_case_insensitive_comparison()
{
var validator = new TestValidator { v => v.RuleFor(x => x.Surname).Equal("FOO", StringComparer.OrdinalIgnoreCase) };
var result = validator.Validate(new Person { Surname = "foo" });
result.IsValid.ShouldBeTrue();
}
public void Sets_localised_message_via_expression()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Surname).NotEmpty().WithLocalizedMessage(() => MyResources.notempty_error);
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("foo");
}
public void When_there_is_a_value_then_the_validator_should_pass() {
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotEmpty()
};
var result = validator.Validate(new Person { Surname = "Foo" });
result.IsValid.ShouldBeTrue();
}
public void When_value_is_Default_for_type_validator_should_fail_datetime() {
var validator = new TestValidator {
v => v.RuleFor(x => x.DateOfBirth).NotEmpty()
};
var result = validator.Validate(new Person { DateOfBirth = default(DateTime) });
result.IsValid.ShouldBeFalse();
}
public void When_value_is_empty_string_validator_should_pass() {
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).Empty()
};
var result = validator.Validate(new Person { Surname = "" });
result.IsValid.ShouldBeTrue();
}
public void Uses_localized_name() {
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull().WithLocalizedName(() => MyResources.CustomProperty)
};
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("'foo' must not be empty.");
}
public void When_passing_string_to_localizable_lambda_should_convert_to_string_accessor() {
var validator = new TestValidator() {
v => v.RuleFor(x => x.Surname).SetValidator(new FooValidator())
};
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("foo");
}
public void Can_access_expression_in_message()
{
var v = new TestValidator();
v.RuleFor(x => x.Forename).Matches(@"^\w\d$").WithMessage("test {RegularExpression}");
var result = v.Validate(new Person {Forename = ""});
result.Errors.Single().ErrorMessage.ShouldEqual(@"test ^\w\d$");
}
public void When_value_is_whitespace_validation_should_fail() {
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotEmpty()
};
var result = validator.Validate(new Person { Surname = " " });
result.IsValid.ShouldBeFalse();
}
public void Validates_across_properties() {
var validator = new TestValidator(
v => v.RuleFor(x => x.Forename).NotEqual(x => x.Surname)
);
var result = validator.Validate(new Person { Surname = "foo", Forename = "foo" });
result.IsValid.ShouldBeFalse();
}
public void Fails_when_collection_empty()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Children).NotEmpty()
};
var result = validator.Validate(new Person { Children = new List<Person>() });
result.IsValid.ShouldBeFalse();
}
public void When_validation_fails_error_should_be_set()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotEmpty()
};
var result = validator.Validate(new Person { Surname = null });
result.Errors.Single().ErrorMessage.ShouldEqual("'Surname' should not be empty.");
}
public void Can_use_placeholders_with_localized_messages_using_expressions()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull().WithLocalizedMessage(() => TestMessages.PlaceholderMessage, x => 1)
};
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("Test 1");
}
public void Resolves_nested_properties() {
var validator = new TestValidator {
v => v.RuleFor(x => x.Address.Country).NotNull()
};
var error = validator.Validate(new Person { Address = new Address() }).Errors.Single();
error.PropertyName.ShouldEqual("Address.Country");
}
public void When_input_is_null_then_the_validator_should_pass()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).Length(5)
};
var result = validator.Validate(new Person {Surname = null});
result.IsValid.ShouldBeTrue();
}
public void Custom_property_validators_should_respect_ResourceProvider()
{
ValidatorOptions.ResourceProviderType = typeof(MyResources);
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).SetValidator(new MyPropertyValidator())
};
var results = validator.Validate(new Person());
results.Errors.Single().ErrorMessage.ShouldEqual("foo");
}
public void ResourceProviderType_overrides_default_messagesnote() {
ValidatorOptions.ResourceProviderType = typeof(MyResources);
var validator = new TestValidator() {
v => v.RuleFor(x => x.Surname).NotEmpty()
};
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("foo");
}
public void Overwrites_resoruce_type_when_using_custom_ResourceProvider_and_custom_ResourceAccessorProvider() {
ValidatorOptions.ResourceProviderType = typeof(OverrideResources);
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull().WithLocalizedName(() => MyResources.CustomProperty, new FallbackAwareResourceAccessorBuilder())
};
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("'bar' must not be empty.");
}
public void Does_not_overwrite_resource_when_using_custom_ResourceProvider() {
ValidatorOptions.ResourceProviderType = typeof(OverrideResources);
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull().WithLocalizedName(() => MyResources.CustomProperty)
};
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("'foo' must not be empty.");
}
public void Uses_custom_property_name() {
ValidatorOptions.PropertyNameResolver = (type, prop, expr) => "foo";
var validator = new TestValidator() {
v => v.RuleFor(x => x.Surname).NotNull()
};
var error = validator.Validate(new Person()).Errors.Single();
error.PropertyName.ShouldEqual("foo");
}
public void Invokes_dependent_rule_if_parent_rule_passes() {
var validator = new TestValidator();
validator.RuleFor(x => x.Surname).NotNull()
.DependentRules(d => {
d.RuleFor(x => x.Forename).NotNull();
});
var results = validator.Validate(new Person {Surname = "foo"});
results.Errors.Count.ShouldEqual(1);
results.Errors.Single().PropertyName.ShouldEqual("Forename");
}
public void Scale_and_precision_should_work()
{
var validator = new TestValidator(v => v.RuleFor(x => x.Discount).SetValidator(new ScalePrecisionValidator(2, 4)));
var result = validator.Validate(new Person {Discount = 123.456778m});
Assert.False(result.IsValid);
result = validator.Validate(new Person {Discount = 12.34M});
Assert.True(result.IsValid);
result = validator.Validate(new Person {Discount = 12.3414M});
result.IsValid.ShouldBeFalse();
result = validator.Validate(new Person {Discount = 1.344M});
result.IsValid.ShouldBeFalse();
result = validator.Validate(new Person {Discount = 156.3M});
result.IsValid.ShouldBeTrue();
result = validator.Validate(new Person {Discount = 1565.0M}); // fail as it counts zeros
result.IsValid.ShouldBeFalse();
validator = new TestValidator(v =>
v.RuleFor(x => x.Discount)
.SetValidator(new ScalePrecisionValidator(2, 4) {IgnoreTrailingZeros = true}));
result = validator.Validate(new Person {Discount = 1565.0M}); // ignores zeros now
result.IsValid.ShouldBeTrue();
result = validator.Validate(new Person {Discount = 15655.0M});
result.IsValid.ShouldBeFalse();
result = validator.Validate(new Person {Discount = 155.0000000000000000000000000M});
result.IsValid.ShouldBeTrue();
result = validator.Validate(new Person {Discount = 155.0000000000000000000000001M});
result.IsValid.ShouldBeFalse();
result = validator.Validate(new Person {Discount = 00000000000000000000155.0000000000000000000000000M});
result.IsValid.ShouldBeTrue();
}
public void Executes_rule_for_each_item_in_collection() {
var validator = new TestValidator {
v => v.RuleForEach(x => x.NickNames).NotNull()
};
var person = new Person {
NickNames = new[] { null, "foo", null }
};
var result = validator.Validate(person);
result.Errors.Count.ShouldEqual(2);
}
public void WrapperSucceedsIfNotNullValueSucceedsForWrappedValidator()
{
var validator = new TestValidator();
var wrapperValidator = new NullIgnoringValidatorWrapper(validator);
object value = "test value";
var rawResults = validator.Validate(value);
var wrapperResults = wrapperValidator.Validate(value);
Assert.IsTrue(rawResults.IsValid);
Assert.IsTrue(wrapperResults.IsValid);
}
public void WrapperIgnoresNullValues()
{
var validator = new TestValidator();
var wrapperValidator = new NullIgnoringValidatorWrapper(validator);
object value = null;
var rawResults = validator.Validate(value);
var wrapperResults = wrapperValidator.Validate(value);
Assert.IsFalse(rawResults.IsValid);
Assert.AreEqual("Invalid value", rawResults.ElementAt(0).Message);
Assert.IsTrue(wrapperResults.IsValid);
}
public void WrapperIgnoresNullValues()
{
var validator = new TestValidator();
var wrapperValidator = new NullIgnoringValidatorWrapper(validator);
object value = null;
var rawResults = validator.Validate(value);
var wrapperResults = wrapperValidator.Validate(value);
Assert.IsFalse(rawResults.IsValid);
Assert.AreEqual("Invalid value", rawResults.ElementAt(0).Message);
Assert.IsTrue(wrapperResults.IsValid);
}
public ResponseModel ValidateTestInsData(TestInsQueryFilter testInsQueryFilter)
{
try
{
TestValidator validator = new TestValidator();
var validationResult = validator.Validate(testInsQueryFilter);
return(MainValidator.IterationValidationResult(validationResult));
}
catch (Exception err)
{
throw new Exception(err.Message);
}
}
public void Correctly_gets_collection_indicies() {
var validator = new TestValidator {
v => v.RuleForEach(x => x.NickNames).NotNull()
};
var person = new Person {
NickNames = new[] { null, "foo", null }
};
var result = validator.Validate(person);
result.Errors[0].PropertyName.ShouldEqual("NickNames[0]");
result.Errors[1].PropertyName.ShouldEqual("NickNames[2]");
}
public void GivenValidDateTimeExtensionMethod_WhenDateTimeProvided_ThenShouldReturnExpectedResult(
DateTime reservationDate, bool expectedResult)
{
var sut = new TestValidations
{
DateTime = reservationDate
};
var validator = new TestValidator();
var result = validator.Validate(sut);
Assert.Equal(result.IsValid, expectedResult);
}
public void IsValid()
{
var entity = new TestEntity
{
Url = "http://www.google.com/",
HttpUrl = "http://www.google.com/",
HttpsUrl = "https://www.google.com/"
};
var validator = new TestValidator();
var result = validator.Validate(entity);
Assert.IsTrue(result.IsValid);
}
public void WrapperFailsIfNotNullValueFailsForWrappedValidator()
{
var validator = new TestValidator();
var wrapperValidator = new NullIgnoringValidatorWrapper(validator);
object value = "some value";
var rawResults = validator.Validate(value);
var wrapperResults = wrapperValidator.Validate(value);
Assert.IsFalse(rawResults.IsValid);
Assert.AreEqual("Invalid value", rawResults.ElementAt(0).Message);
Assert.IsFalse(wrapperResults.IsValid);
Assert.AreEqual("Invalid value", wrapperResults.ElementAt(0).Message);
}
public void Dependent_rules_inside_ruleset() {
var validator = new TestValidator();
validator.RuleSet("MyRuleSet", () => {
validator.RuleFor(x => x.Surname).NotNull()
.DependentRules(d => {
d.RuleFor(x => x.Forename).NotNull();
});
});
var results = validator.Validate(new Person { Surname = "foo" }, ruleSet: "MyRuleSet");
results.Errors.Count.ShouldEqual(1);
results.Errors.Single().PropertyName.ShouldEqual("Forename");
}
public void WrapperFailsIfNotNullValueFailsForWrappedValidator()
{
var validator = new TestValidator();
var wrapperValidator = new NullIgnoringValidatorWrapper(validator);
object value = "some value";
var rawResults = validator.Validate(value);
var wrapperResults = wrapperValidator.Validate(value);
Assert.IsFalse(rawResults.IsValid);
Assert.AreEqual("Invalid value", rawResults.ElementAt(0).Message);
Assert.IsFalse(wrapperResults.IsValid);
Assert.AreEqual("Invalid value", wrapperResults.ElementAt(0).Message);
}
public void Invalid()
{
var entity = new TestEntity
{
Url = "ftp://www.google.com/",
HttpUrl = "https://www.google.com/",
HttpsUrl = "http://www.google.com/"
};
var validator = new TestValidator();
var result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(3, result.Errors.Count);
}
public void should_be_valid_if_all_settings_valid()
{
_validator.Validate(_emailSettings).IsValid.Should().BeTrue();
}
public ActionResult App(Test account)
{
//validate my data
TestValidator validator = new TestValidator();
ValidationResult result = validator.Validate(account);
int time;
if (Session["time"] == null)
{
time = 0;
Session["time"] = time;
return(View("App", account));
}
time = (int)Session["time"];
Session["time"] = time + 1;
if (result.IsValid == false)
{
if (time >= 3)
{
// Show the captcha.
account.b = true;
ViewBag.ErrMessage = "Invalid Captcha";
return(View("App", account));
}
else
{
ViewBag.Err = "Invalid CouponCode";
return(View("App", account));
}
}
else
{
return(View("Success", account));
}
/* if (count <= 3)
* {
* count=count +1;
*
* ViewBag.error = "Invalid CouponCode";
* return View("Index", account);
* }
* else
* {
*
* return View("captcha",account);
* }
* }
*
* else
* {
* ViewBag.account = account;
* return View("Success");
* }
* }
*
*/
/* public ActionResult Check(Account acc)
* {
*
*
* if (!this.IsCaptchaValid(""))
* {
* ViewBag.error = "Invalid Captcha";
* return View("captcha", acc);
* }
* else
* {
* ViewBag.account = acc;
* return View("Success");
*
* }
* }*/
}