public void Dependent_rules_inside_ruleset()
{
var validator = new TestValidator();
validator.RuleSet("MyRuleSet", () => {
validator.RuleFor(x => x.Surname).NotNull()
.DependentRules(() => {
validator.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 Overrides_localization_key()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Forename).SetValidator(new CustomNotNull());
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("'Forename' is not a valid credit card number.");
}
public void Formats_string_with_placeholders_when_you_cant_edit_the_string()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Forename).NotNull().WithMessage(x => string.Format("{{PropertyName}} {0}", x.AnotherInt));
var result = validator.Validate(new Person());
result.Errors[0].ErrorMessage.ShouldEqual("Forename 0");
}
public void Async_condition_can_be_used_inside_ruleset()
{
var validator = new TestValidator();
validator.RuleSet("foo", () => {
validator.WhenAsync(async x => (x.Id > 0), () => {
validator.RuleFor(x => x.Forename).NotNull();
});
});
validator.RuleFor(x => x.Surname).NotNull();
var result = validator.ValidateAsync(new Person {
Id = 5
}, ruleSet: "foo").Result;
result.Errors.Count.ShouldEqual(1);
result.Errors.Single().PropertyName.ShouldEqual("Forename");
}
public void Sets_localised_message_via_type_name()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Surname).NotEmpty().WithLocalizedMessage(typeof(MyResources), nameof(MyResources.notempty_error));
var result = validator.Validate(new Person());
result.Errors.Single().ErrorMessage.ShouldEqual("foo");
}
public void When_condition_only_executed_once()
{
var validator = new TestValidator();
int executions = 0;
validator.When(x => {
executions++;
return(x.Age > 10);
}, () => {
validator.RuleFor(x => x.Surname).NotNull();
validator.RuleFor(x => x.Forename).NotNull();
});
validator.Validate(new Person {
Age = 11
});
executions.ShouldEqual(1);
}
public async Task Async_condition_can_be_used_inside_ruleset()
{
var validator = new TestValidator();
validator.RuleSet("foo", () => {
validator.WhenAsync(async(x, c) => (x.Id > 0), () => {
validator.RuleFor(x => x.Forename).NotNull();
});
});
validator.RuleFor(x => x.Surname).NotNull();
#pragma warning disable 618
var result = await validator.ValidateAsync(new Person { Id = 5 }, ruleSet : "foo");
#pragma warning restore 618
result.Errors.Count.ShouldEqual(1);
result.Errors.Single().PropertyName.ShouldEqual("Forename");
}
public void Async_condition_executed_synchronosuly_with_synchronous_role()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Surname).NotNull()
.WhenAsync((x, token) => Task.FromResult(false));
var result = validator.Validate(new Person());
result.IsValid.ShouldBeTrue();
}
public void ShouldHaveValidationError_with_an_unmatched_rule_and_multiple_errors_should_throw_an_exception()
{
var validator = new TestValidator();
validator.RuleFor(x => x.NullableInt).GreaterThan(1);
validator.RuleFor(x => x.Age).GreaterThan(1);
validator.RuleFor(x => x.AnotherInt).GreaterThan(2);
var result = validator.TestValidate(new Person()
{
NullableInt = 1,
Age = 1,
AnotherInt = 1
});
var ex = Assert.Throws <ValidationTestException>(() => result.ShouldHaveValidationErrorFor(x => x.NullableInt.Value));
Assert.Equal("Expected a validation error for property NullableInt.Value\n----\nProperties with Validation Errors:\n[0]: NullableInt\n[1]: Age\n[2]: AnotherInt\n", ex.Message);
}
public void Uses_func_to_get_message()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Forename).NotNull().WithMessage(x => "el foo");
var result = validator.Validate(new Person());
result.Errors[0].ErrorMessage.ShouldEqual("el foo");
}
public void Async_condition_throws_when_executed_synchronosuly_with_asynchronous_rule()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Surname)
.MustAsync((surname, c) => Task.FromResult(surname != null))
.WhenAsync((x, token) => Task.FromResult(false));
Assert.Throws <AsyncValidatorInvokedSynchronouslyException>(() => validator.Validate(new Person()));
}
public async Task Executes_customasync_rule_when_async_condition_true()
{
var validator = new TestValidator();
validator.WhenAsync(async(x, c) => (true), () => validator.RuleFor(x => x).CustomAsync(async(x, ctx, c) => ctx.AddFailure(new ValidationFailure("foo", "bar"))));
var result = await validator.ValidateAsync(new Person());
result.IsValid.ShouldBeFalse();
}
public void ShouldHaveValidationErrorFor_takes_account_of_rulesets_fluent_approach()
{
var testValidator = new TestValidator();
testValidator.RuleSet("Names", () => {
testValidator.RuleFor(x => x.Surname).NotNull();
testValidator.RuleFor(x => x.Forename).NotNull();
});
testValidator.RuleFor(x => x.Id).NotEqual(0);
#pragma warning disable 618
var assertionRoot = testValidator.TestValidate(new Person(), "Names");
#pragma warning restore 618
assertionRoot.ShouldHaveValidationErrorFor(x => x.Forename)
.WithErrorCode("NotNullValidator");
assertionRoot.ShouldHaveValidationErrorFor(x => x.Surname).WithErrorCode("NotNullValidator");
assertionRoot.ShouldNotHaveValidationErrorFor(x => x.Id);
}
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 Validates_at_model_level()
{
var v = new TestValidator();
v.RuleFor(x => x).Must(x => false);
var result = v.Validate(new Person());
result.Errors.Count.ShouldEqual(1);
result.Errors.Single().PropertyName.ShouldEqual("");
}
public void Should_use_ordinal_comparison_by_default()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Surname).NotEqual("a");
var result = validator.Validate(new Person {
Surname = "a\0"
});
result.IsValid.ShouldBeTrue();
}
public void Can_use_child_validator_at_model_level()
{
var v = new TestValidator();
v.RuleFor(x => x).SetValidator(new ChildValidator());
var result = v.Validate(new Person());
result.Errors.Count.ShouldEqual(1);
result.Errors.Single().PropertyName.ShouldEqual("Forename");
}
public void Uses_string_format_with_property_value()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Forename).Equal("Foo").WithMessage((x, forename) => $"Hello {forename}");
var result = validator.Validate(new Person {
Forename = "Jeremy"
});
result.Errors[0].ErrorMessage.ShouldEqual("Hello Jeremy");
}
public void Not_Setting_global_resource_provider_uses_default_messages_in_metadata()
{
var validator = new TestValidator();
validator.RuleFor(x => x.Forename).NotNull();
var descriptor = validator.CreateDescriptor();
var resourceType = descriptor.GetMembersWithValidators().First().First().ErrorMessageSource.ResourceType;
Assert.Equal(typeof(Messages), resourceType);
}
public void Runs_otherwise_conditons_for_Unless()
{
var validator = new TestValidator();
validator.Unless(x => x.Age > 10, () => {
validator.RuleFor(x => x.Forename).NotNull();
}).Otherwise(() => {
validator.RuleFor(x => x.Surname).NotNull();
});
var result1 = validator.Validate(new Person {
Age = 11
});
result1.Errors.Single().PropertyName.ShouldEqual("Surname");
var result2 = validator.Validate(new Person {
Age = 9
});
result2.Errors.Single().PropertyName.ShouldEqual("Forename");
}
public void Can_use_property_with_include()
{
var validator = new TestValidator();
var validator2 = new TestValidator();
validator2.RuleFor(x => x.Forename).NotNull();
validator.Include(validator2);
var result = validator.Validate(new Person(), "Forename");
result.IsValid.ShouldBeFalse();
}
public void Executes_custom_rule_when_condition_true()
{
var validator = new TestValidator();
validator.When(x => true, () => {
validator.RuleFor(x => x).Custom((x, ctx) => ctx.AddFailure(new ValidationFailure("foo", "bar")));
});
var result = validator.Validate(new Person());
result.IsValid.ShouldBeFalse();
}
public void Does_not_execute_customasync_Rule_when_condition_false()
{
var validator = new TestValidator();
validator.When(x => false, () => {
validator.RuleFor(x => x).CustomAsync(async(x, ctx, c) => ctx.AddFailure(new ValidationFailure("foo", "bar")));
});
var result = validator.Validate(new Person());
result.IsValid.ShouldBeTrue();
}
public async Task Does_not_execute_custom_Rule_when_async_condition_false()
{
var validator = new TestValidator();
validator.WhenAsync(async(x, c) => (false), () => {
validator.RuleFor(x => x).Custom((x, ctx) => ctx.AddFailure(new ValidationFailure("foo", "bar")));
});
var result = await validator.ValidateAsync(new Person());
result.IsValid.ShouldBeTrue();
}
public void Can_access_expression_in_message_lambda_regex()
{
var v = new TestValidator();
v.RuleFor(x => x.Forename).Matches(x => x.AnotherRegex).WithMessage("test {RegularExpression}");
var result = v.Validate(new Person {
Forename = "", AnotherRegex = new System.Text.RegularExpressions.Regex(@"^\w\d$")
});
result.Errors.Single().ErrorMessage.ShouldEqual(@"test ^\w\d$");
}
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(); });
typeof(ValidationException).ShouldBeThrownBy(() => validator.ValidateAndThrow(new Person(), ruleSetName));
}
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 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);
}
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 Setting_global_resource_provider_propogates_to_metadata()
{
ValidatorOptions.ResourceProviderType = typeof(TestMessages);
var validator = new TestValidator();
validator.RuleFor(x => x.Forename).NotNull();
var descriptor = validator.CreateDescriptor();
var resourceType = descriptor.GetMembersWithValidators().First().First().ErrorMessageSource.ResourceType;
Assert.Equal(typeof(TestMessages), resourceType);
}
