public void Skips_null_items()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull(),
v => v.RuleFor(x => x.Orders).SetCollectionValidator(new OrderValidator())
};
person.Orders[0] = null;
var results = validator.Validate(person);
results.Errors.Count.ShouldEqual(2); //2 errors - 1 for person, 1 for 2nd Order.
}
public void When_using_explicitly_localized_message_with_custom_validator_does_not_fall_back_to_ResourceProvider()
{
ValidatorOptions.ResourceProviderType = typeof(MyResources);
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).SetValidator(new MyPropertyValidator())
.WithLocalizedMessage(typeof(MyOverridenResources), nameof(MyOverridenResources.notempty_error))
};
var results = validator.Validate(new Person());
results.Errors.Single().ErrorMessage.ShouldEqual("bar");
}
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 Validates_nullable_with_nullable_property()
{
var validator = new TestValidator(v => v.RuleFor(x => x.NullableInt).LessThan(x => x.OtherNullableInt));
var resultNull = validator.Validate(new Person {
NullableInt = 0, OtherNullableInt = null
});
var resultLess = validator.Validate(new Person {
NullableInt = 0, OtherNullableInt = -1
});
var resultEqual = validator.Validate(new Person {
NullableInt = 0, OtherNullableInt = 0
});
var resultMore = validator.Validate(new Person {
NullableInt = 0, OtherNullableInt = 1
});
resultNull.IsValid.ShouldBeFalse();
resultLess.IsValid.ShouldBeFalse();
resultEqual.IsValid.ShouldBeFalse();
resultMore.IsValid.ShouldBeTrue();
}
public void Nested_conditions_with_Custom_rule()
{
var validator = new TestValidator();
validator.When(x => true, () => {
validator.When(x => false, () => {
validator.Custom(x => new ValidationFailure("Custom", "The validation failed"));
});
});
var result = validator.Validate(new Person());
result.IsValid.ShouldBeTrue();
}
public void Executes_rules_in_default_ruleset_and_specific_ruleset()
{
var validator = new TestValidator();
validator.RuleSet("foo", () => {
validator.RuleFor(x => x.Age).NotEqual(0);
});
var result = validator.Validate(new Person(), ruleSet: "default,Names");
result.Errors.Count.ShouldEqual(3);
AssertExecuted(result, "default", "Names");
}
public void Nested_async_conditions_with_Custom_rule()
{
var validator = new TestValidator();
validator.When(x => true, () => {
validator.WhenAsync(async(x, c) => (false), () => {
validator.RuleFor(x => x).Custom((x, ctx) => ctx.AddFailure(new ValidationFailure("Custom", "The validation failed")));
});
});
var result = validator.Validate(new Person());
result.IsValid.ShouldBeTrue();
}
public void Executes_multiple_rulesets()
{
var validator = new TestValidator();
validator.RuleSet("Id", () => {
validator.RuleFor(x => x.Id).NotEqual(0);
});
var person = new Person();
var result = validator.Validate(new ValidationContext <Person>(person, new PropertyChain(), new RulesetValidatorSelector("Names", "Id")));
result.Errors.Count.ShouldEqual(3);
}
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 Does_not_invoke_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 = null });
results.Errors.Count.ShouldEqual(1);
results.Errors.Single().PropertyName.ShouldEqual("Surname");
}
public void Async_condition_executed_synchronosuly_with_asynchronous_collection_rule()
{
var validator = new TestValidator();
validator.RuleForEach(x => x.NickNames)
.MustAsync((n, c) => Task.FromResult(n != null))
.WhenAsync((x, token) => Task.FromResult(false));
var result = validator.Validate(new Person {
NickNames = new string[0]
});
result.IsValid.ShouldBeTrue();
}
public void Can_use_property_with_include()
{
var validator = new TestValidator();
var validator2 = new TestValidator();
validator2.RuleFor(x => x.Forename).NotNull();
validator.Include(validator2);
#pragma warning disable 618
var result = validator.Validate(new Person(), "Forename");
#pragma warning restore 618
result.IsValid.ShouldBeFalse();
}
public void Validates_with_nullable_property()
{
validator = new TestValidator(v => v.RuleFor(x => x.Id).GreaterThanOrEqualTo(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.ShouldBeTrue();
resultEqual.IsValid.ShouldBeTrue();
resultMore.IsValid.ShouldBeFalse();
}
public void Includes_nested_property()
{
var validtor = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull(),
v => v.RuleFor(x => x.Address.Id).NotEqual(0)
};
var result = validtor.Validate(new Person {
Address = new Address()
}, "Address.Id");
result.Errors.Count.ShouldEqual(1);
result.Errors[0].PropertyName.ShouldEqual("Address.Id");
}
public void Throws_exception_with_a_ruleset()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull()
};
const string ruleSetName = "blah";
validator.RuleSet(ruleSetName, () => { validator.RuleFor(x => x.Forename).NotNull(); });
Assert.Throws <ValidationException>(() => {
validator.Validate(new Person(), v => v.IncludeRuleSets(ruleSetName).ThrowOnFailures());
});
}
public void Executes_correct_rule_when_using_property_with_include()
{
var validator = new TestValidator();
var validator2 = new TestValidator();
validator2.RuleFor(x => x.Forename).NotNull();
validator2.RuleFor(x => x.Surname).NotNull();
validator.Include(validator2);
var result = validator.Validate(new Person(), "Forename");
result.Errors.Count.ShouldEqual(1);
result.Errors[0].PropertyName.ShouldEqual("Forename");
}
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 Condition_can_be_used_inside_ruleset()
{
var validator = new TestValidator();
validator.RuleSet("foo", () => { validator.When(x => x.Id > 0, () => { validator.RuleFor(x => x.Forename).NotNull(); }); });
validator.RuleFor(x => x.Surname).NotNull();
var result = validator.Validate(new Person {
Id = 5
}, ruleSet: "foo");
result.Errors.Count.ShouldEqual(1);
result.Errors.Single().PropertyName.ShouldEqual("Forename");
}
public void Validates_collection()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull(),
v => v.RuleFor(x => x.Orders).SetCollectionValidator(new OrderValidator())
};
var results = validator.Validate(person);
results.Errors.Count.ShouldEqual(3);
results.Errors[1].PropertyName.ShouldEqual("Orders[0].ProductName");
results.Errors[2].PropertyName.ShouldEqual("Orders[1].Amount");
}
public void When_the_text_is_empty_then_the_validator_should_fail()
{
string email = String.Empty;
var result = validator.Validate(new Person {
Email = email
});
result.IsValid.ShouldBeFalse();
}
public void Should_format_custom_message()
{
const string expected = "Surname";
validator.RuleFor(x => x.Surname).NotNull().WithMessage("{PropertyName}");
string error = validator.Validate(new Person()).Errors.Single().ErrorMessage;
error.ShouldEqual(expected);
}
public void When_the_text_matches_the_regular_expression_then_the_validator_should_pass()
{
string input = "S3";
var result = validator.Validate(new Person {
Surname = input
});
result.IsValid.ShouldBeTrue();
}
public void Validates_across_properties()
{
var validator = new TestValidator(
v => v.RuleFor(x => x.Forename)
.NotEqual(x => x.Surname)
.WithMessage("{ComparisonProperty}")
);
var result = validator.Validate(new Person {
Surname = "foo", Forename = "foo"
});
result.IsValid.ShouldBeFalse();
result.Errors[0].ErrorMessage.ShouldEqual("Surname");
}
public void InheritanceValidator_should_fail_if_car_iselectric_is_false()
{
var validator = new TestValidator(v => {
v.RuleFor(x => x.Vehicle).AddInheritance(i => {
i.Include <Car>(b => { b.RuleFor(m => m.IsElectric).Must(x => x); });
i.Include <Bike>(b => { b.RuleFor(m => m.HasBell).Must(x => x); });
});
});
var result = validator.Validate(new Person {
Vehicle = new Car()
});
result.IsValid.ShouldBeFalse();
}
public void Includes_nested_property_using_expression()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull(),
v => v.RuleFor(x => x.Address.Id).NotEqual(0)
};
#pragma warning disable 618
var result = validator.Validate(new Person {
Address = new Address()
}, x => x.Address.Id);
#pragma warning restore 618
result.Errors.Count.ShouldEqual(1);
result.Errors[0].PropertyName.ShouldEqual("Address.Id");
}
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 Comparison_property_uses_custom_resolver()
{
var originalResolver = ValidatorOptions.Global.DisplayNameResolver;
try {
ValidatorOptions.Global.DisplayNameResolver = (type, member, expr) => member.Name + "Foo";
var validator = new TestValidator(v => v.RuleFor(x => x.Id).LessThan(x => x.AnotherInt).WithMessage("{ComparisonProperty}"));
var result = validator.Validate(new Person {
Id = 2, AnotherInt = 1
});
result.Errors[0].ErrorMessage.ShouldEqual("AnotherIntFoo");
}
finally {
ValidatorOptions.Global.DisplayNameResolver = originalResolver;
}
}
public void Treats_root_level_RuleFor_call_as_dependent_rule_if_user_forgets_to_use_DependentRulesBuilder()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Surname).NotNull()
.DependentRules(() => {
validator.RuleFor(x => x.Forename).NotNull(); // Shouldn't be invoked
});
var results = validator.Validate(new Person {
Surname = null
});
results.Errors.Count.ShouldEqual(1); //only the root NotNull should fire
results.Errors.Single().PropertyName.ShouldEqual("Surname");
}
public void Can_validate_using_validator_for_base_type()
{
var addressValidator = new InlineValidator <IAddress>()
{
v => v.RuleFor(x => x.Line1).NotNull()
};
var validator = new TestValidator {
v => v.RuleFor(x => x.Address).SetValidator(addressValidator)
};
var result = validator.Validate(new Person {
Address = new Address()
});
result.IsValid.ShouldBeFalse();
}
public void Dependent_rules_inside_when()
{
var validator = new TestValidator();
validator.When(o => o.Forename != null, () =>
{
validator.RuleFor(o => o.Age).LessThan(1)
.DependentRules(d =>
{
d.RuleFor(o => o.Forename).NotNull();
});
});;
var result = validator.Validate(new Person());
result.IsValid.ShouldBeTrue();
}
