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);
AssertExecuted(result, "Test");
}
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 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).SetCollectionValidator(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 async Task TestAsyncWithDependentRules_AsyncEntry()
{
var validator = new TestValidator();
validator.RuleFor(o => o)
.MustAsync(async(p, ct) => await
#if NET35
TaskEx
#else
Task
#endif
.FromResult(p.Forename != null))
.DependentRules(() => {
validator.RuleFor(o => o.Address).NotNull();
validator.RuleFor(o => o.Age).MustAsync(async(p, token) => await
#if NET35
TaskEx
#else
Task
#endif
.FromResult(p > 10));
});
var result = await validator.ValidateAsync(new Person());
Assert.Equal(1, result.Errors.Count);
Assert.True(result.Errors.Any(x => x.PropertyName == ""));
result = await validator.ValidateAsync(new Person()
{
Forename = "Foo"
});
Assert.Equal(2, result.Errors.Count);
Assert.True(result.Errors.Count(x => x.PropertyName == "Address") == 1, "Address");
Assert.True(result.Errors.Count(x => x.PropertyName == "Age") == 1, "Age");
}
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");
}
public void Correctly_assigns_default_localized_error_message()
{
var originalCulture = Thread.CurrentThread.CurrentUICulture;
try {
var validator = new TestValidator(v => v.RuleFor(x => x.Surname).NotEmpty());
foreach (var culture in new[] { "en", "de", "fr", "es", "de", "it", "nl", "pl", "pt", "ru", "sv", "ar" })
{
Thread.CurrentThread.CurrentUICulture = new CultureInfo(culture);
var message = ValidatorOptions.LanguageManager.GetStringForValidator <NotEmptyValidator>();
var errorMessage = new MessageFormatter().AppendPropertyName("Surname").BuildMessage(message);
Debug.WriteLine(errorMessage);
var result = validator.Validate(new Person {
Surname = null
});
result.Errors.Single().ErrorMessage.ShouldEqual(errorMessage);
}
}
finally {
// Always reset the culture.
Thread.CurrentThread.CurrentUICulture = originalCulture;
}
}
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 AbstractValidatorTester()
{
CultureScope.SetDefaultCulture();
validator = new TestValidator();
testValidatorWithPreValidate = new TestValidatorWithPreValidate();
}
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 ValidatorDescriptorTester()
{
CultureScope.SetDefaultCulture();
validator = new TestValidator();
}
public LessThanOrEqualToValidatorTester()
{
CultureScope.SetDefaultCulture();
validator = new TestValidator(v => v.RuleFor(x => x.Id).LessThanOrEqualTo(value));
}
public void Scale_and_precision_should_work()
{
var validator = new TestValidator(v => v.RuleFor(x => x.Discount).ScalePrecision(2, 4));
var result = validator.Validate(new Person {
Discount = 123.456778m
});
result.IsValid.ShouldBeFalse();
result.Errors[0].ErrorMessage.ShouldEqual("'Discount' must not be more than 4 digits in total, with allowance for 2 decimals. 3 digits and 6 decimals were found.");
result = validator.Validate(new Person {
Discount = 12.34M
});
result.IsValid.ShouldBeTrue();
result = validator.Validate(new Person {
Discount = 12.3414M
});
result.IsValid.ShouldBeFalse();
result.Errors[0].ErrorMessage.ShouldEqual("'Discount' must not be more than 4 digits in total, with allowance for 2 decimals. 2 digits and 4 decimals were found.");
result = validator.Validate(new Person {
Discount = 1.344M
});
result.IsValid.ShouldBeFalse();
result.Errors[0].ErrorMessage.ShouldEqual("'Discount' must not be more than 4 digits in total, with allowance for 2 decimals. 1 digits and 3 decimals were found.");
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();
result.Errors[0].ErrorMessage.ShouldEqual("'Discount' must not be more than 4 digits in total, with allowance for 2 decimals. 4 digits and 1 decimals were found.");
validator = new TestValidator(v => v.RuleFor(x => x.Discount).ScalePrecision(2, 4, 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.Errors[0].ErrorMessage.ShouldEqual("'Discount' must not be more than 4 digits in total, with allowance for 2 decimals. 5 digits and 0 decimals were found.");
result = validator.Validate(new Person {
Discount = 155.0000000000000000000000000M
});
result.IsValid.ShouldBeTrue();
result = validator.Validate(new Person {
Discount = 155.0000000000000000000000001M
});
result.IsValid.ShouldBeFalse();
result.Errors[0].ErrorMessage.ShouldEqual("'Discount' must not be more than 4 digits in total, with allowance for 2 decimals. 3 digits and 25 decimals were found.");
result = validator.Validate(new Person {
Discount = 00000000000000000000155.0000000000000000000000000M
});
result.IsValid.ShouldBeTrue();
}
public UserStateTester()
{
validator = new TestValidator();
}
public CustomMessageFormatTester()
{
validator = new TestValidator();
CultureScope.SetDefaultCulture();
}
public void Setup()
{
validator = new TestValidator();
}
public CustomMessageFormatTester()
{
validator = new TestValidator();
}
public UserSeverityTester()
{
validator = new TestValidator();
}
public void Setup()
{
ValidatorOptions.CascadeMode = CascadeMode.Continue;
validator = new TestValidator();
}
public CascadingFailuresTester()
{
ValidatorOptions.CascadeMode = CascadeMode.Continue;
validator = new TestValidator();
}
public AbstractValidatorTester()
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
validator = new TestValidator();
}
public ValidatorTesterTester()
{
validator = new TestValidator();
validator.RuleFor(x => x.Forename).NotNull();
}
public ChainingValidatorsTester()
{
validator = new TestValidator();
}
public void Setup()
{
validator = new TestValidator(v => v.RuleFor(x => x.Id).LessThanOrEqualTo(value));
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
}
public void Setup()
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us");
validator = new TestValidator();
}
public CustomValidatorTester()
{
validator = new TestValidator();
}
public GreaterThanValidatorTester()
{
CultureScope.SetDefaultCulture();
validator = new TestValidator(v => v.RuleFor(x => x.Id).GreaterThan(value));
}
public CascadingFailuresTester()
{
SetBothGlobalCascadeModes(CascadeMode.Continue);
_validator = new TestValidator();
}
public OnFailureTests()
{
_validator = new TestValidator();
}
public CustomFailureActionTester()
{
validator = new TestValidator();
}
public CascadeModePropertiesTesterLegacy()
{
SetBothGlobalCascadeModes(CascadeMode.Continue);
_validator = new TestValidator();
}
