public void Uses_named_parameters_to_validate_ruleset()
{
validator.RuleSet("Names", () => {
validator.RuleFor(x => x.Surname).NotNull();
validator.RuleFor(x => x.Forename).NotNull();
});
validator.RuleFor(x => x.Id).NotEqual(0);
var result = validator.Validate(new Person(), v => v.IncludeRuleSets("Names"));
result.Errors.Count.ShouldEqual(2);
}
public void ShouldHaveValidationErrorFor_takes_account_of_rulesets()
{
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);
testValidator.ShouldHaveValidationErrorFor(x => x.Forename, new Person(), "Names");
}
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 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 async Task RuleSet_can_be_used_inside_async_condition()
{
var validator = new TestValidator();
validator.WhenAsync(async(x, c) => (x.Id > 0), () => { validator.RuleSet("foo", () => { validator.RuleFor(x => x.Forename).NotNull(); }); });
validator.RuleFor(x => x.Surname).NotNull();
var result = await validator.ValidateAsync(new Person { Id = 5 }, ruleSet : "foo");
result.Errors.Count.ShouldEqual(1);
result.Errors.Single().PropertyName.ShouldEqual("Forename");
}
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(), v => v.IncludeRulesNotInRuleSet().IncludeRuleSets("Names"));
result.Errors.Count.ShouldEqual(3);
AssertExecuted(result, "default", "Names");
}
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_named_parameters_to_validate_ruleset()
{
validator.RuleSet("Names", () => {
validator.RuleFor(x => x.Surname).NotNull();
validator.RuleFor(x => x.Forename).NotNull();
});
validator.RuleFor(x => x.Id).NotEqual(0);
#pragma warning disable 618
var result = validator.Validate(new Person(), ruleSet: "Names");
#pragma warning restore 618
result.Errors.Count.ShouldEqual(2);
}
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 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 Executes_rules_in_default_ruleset_and_specific_ruleset()
{
var validator = new TestValidator();
validator.RuleSet("foo", () => {
validator.RuleFor(x => x.Age).NotEqual(0);
});
#pragma warning disable 618
var result = validator.Validate(new Person(), ruleSet: "default,Names");
#pragma warning restore 618
result.Errors.Count.ShouldEqual(3);
AssertExecuted(result, "default", "Names");
}
public async Task Throws_exception_with_a_ruleset_async()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull()
};
const string ruleSetName = "blah";
validator.RuleSet(ruleSetName, () => { validator.RuleFor(x => x.Forename).NotNull(); });
await Assert.ThrowsAsync <ValidationException>(async() => {
await validator.ValidateAsync(new Person(), v => v.IncludeRuleSets(ruleSetName).ThrowOnFailures());
});
}
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);
var assertionRoot = testValidator.TestValidate(new Person(), "Names").Which;
assertionRoot.Property(x => x.Forename).ShouldHaveValidationError().WithErrorCode("notnull_error");
assertionRoot.Property(x => x.Surname).ShouldHaveValidationError().WithErrorCode("notnull_error");
assertionRoot.Property(x => x.Id).ShouldNotHaveValidationError();
}
public async Task Does_not_throw_when_valid_and_a_ruleset_async()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull()
};
const string ruleSetName = "blah";
validator.RuleSet(ruleSetName, () => { validator.RuleFor(x => x.Forename).NotNull(); });
var person = new Person {
Forename = "foo",
Surname = "foo"
};
await validator.ValidateAsync(person, v => v.IncludeRuleSets(ruleSetName).ThrowOnFailures());
}
public void Does_not_throw_when_valid_and_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(); });
var person = new Person {
Forename = "foo",
Surname = "foo"
};
validator.ValidateAndThrow(person, ruleSetName);
}
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 Throws_exception_with_a_ruleset_async()
{
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(() => {
try {
validator.ValidateAndThrowAsync(new Person(), ruleSetName).Wait();
}
catch (AggregateException agrEx) {
throw agrEx.InnerException;
}
});
}
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 Does_not_throw_when_valid_and_a_ruleset_async()
{
var validator = new TestValidator {
v => v.RuleFor(x => x.Surname).NotNull()
};
const string ruleSetName = "blah";
validator.RuleSet(ruleSetName, () => { validator.RuleFor(x => x.Forename).NotNull(); });
var person = new Person {
Forename = "foo",
Surname = "foo"
};
#pragma warning disable 618
validator.ValidateAndThrowAsync(person, ruleSetName).Wait();
#pragma warning restore 618
}
public void Ruleset_cascades_to_child_validator()
{
var addressValidator = new InlineValidator <Address>();
addressValidator.RuleSet("Test", () => {
addressValidator.RuleFor(x => x.Line1).NotNull();
});
var validator = new TestValidator();
validator.RuleSet("Test", () => {
validator.RuleFor(x => x.Address).SetValidator(addressValidator);
});
var person = new Person {
Address = new Address()
};
var result = validator.Validate(new ValidationContext <Person>(person, new PropertyChain(), new RulesetValidatorSelector("Test")));
result.Errors.Count.ShouldEqual(1);
}
public void Ruleset_cascades_to_child_collection_validator()
{
var orderValidator = new InlineValidator <Order>();
orderValidator.RuleSet("Test", () => {
orderValidator.RuleFor(x => x.ProductName).NotNull();
});
var validator = new TestValidator();
validator.RuleSet("Test", () => {
validator.RuleFor(x => x.Orders).SetValidator(orderValidator);
});
var person = new Person {
Orders = { new Order(), new Order() }
};
var result = validator.Validate(new ValidationContext <Person>(person, new PropertyChain(), new RulesetValidatorSelector("Test")));
result.Errors.Count.ShouldEqual(2); //one for each order
}
public void Nested_dependent_rules_inside_ruleset_inside_method()
{
var validator = new TestValidator();
validator.RuleSet("MyRuleSet", () =>
{
validator.RuleFor(x => x.Surname).NotNull()
.DependentRules(() =>
{
validator.RuleFor(x => x.Forename).NotNull()
.DependentRules(() =>
{
BaseValidation(validator);
});
});
});
var results = validator.Validate(new Person {
Surname = "foo", Forename = "foo"
}, ruleSet: "MyRuleSet");
results.Errors.Count.ShouldEqual(1);
results.Errors.Single().PropertyName.ShouldEqual("Address");
}
public void Nested_dependent_rules_inside_ruleset_no_result_when_second_level_fails()
{
var validator = new TestValidator();
validator.RuleSet("MyRuleSet", () =>
{
validator.RuleFor(x => x.Surname).NotNull()
.DependentRules(() =>
{
validator.RuleFor(x => x.Forename).NotNull()
.DependentRules(() =>
{
validator.RuleFor(x => x.Address).NotNull();
});
});
});
var results = validator.Validate(new Person {
Surname = "bar", Forename = null
}, ruleSet: "MyRuleSet");
results.Errors.Count.ShouldEqual(1);
results.Errors[0].PropertyName.ShouldEqual("Forename");
}
