public void Can_add_new_resource_manager()
{
SetupValidation.AddResourceManager("resources", GetType().Assembly);
Assert.That(ValidationContext.ResourceManagers.Count, Is.EqualTo(1));
Assert.That(ValidationContext.ResourceManagers[0].BaseName, Is.EqualTo("resources"));
}
public void Can_add_self_referencing_negated_validator()
{
SetupValidation.For <Person>(rules => rules.Not.Null());
var rule = context.GetRuleSetsForType <Person>()[0].Rules.First() as ValidatorRule <Person, Person>;
Assert.That(rule.Validate(null).IsValid, Is.False);
}
public void Can_set_resource_on_validator()
{
SetupValidation.For <Person>(rules => rules.Property(p => p.Name).Empty().WithResource("Test"));
var rule = context.GetRuleSetsForType <Person>().First().Rules.First() as ValidatorRule <Person, string>;
Assert.That(rule.Resource, Is.EqualTo("Test"));
}
public void Can_reset_validation_context()
{
SetupValidation.AddResourceManager(new ResourceManager(GetType()));
SetupValidation.For <Person>(rules => rules.Custom(p => false));
SetupValidation.Reset();
Assert.That(ValidationContext.ResourceManagers.Count, Is.EqualTo(0));
Assert.That(ValidationContext.Current.Validate(new Person()).IsValid, Is.True);
}
public void Can_add_resource_manager()
{
var rm = new ResourceManager(GetType());
SetupValidation.AddResourceManager(rm);
Assert.That(ValidationContext.ResourceManagers.Count, Is.EqualTo(1));
Assert.That(ValidationContext.ResourceManagers[0], Is.SameAs(rm));
}
public void Can_add_validator_rule_for_each_item_of_collection()
{
SetupValidation.For <Person>(rules => rules.ForEach(p => p.Possessions).Property(i => i.Weight).GreaterThan(0));
var rule = context.GetRuleSetsForType <Person>()[0].Rules.First() as ForEachRule <Person, Item>;
var valRule = rule.Rules[0] as ValidatorRule <Item, float>;
Assert.That(valRule, Is.Not.Null);
}
public void Can_setup_validation_in_named_context()
{
var testContext = new TestValidationContext();
ValidationContext.SetNamedContext("TestContext", testContext);
SetupValidation.InContext("TestContext").For <Person>(rules => { });
Assert.That(testContext.GetRuleSetsForType <Person>().Count, Is.EqualTo(1));
}
public void Can_set_property_key()
{
SetupValidation.For <Person>(rules => rules.Property(p => p.Name).WithKey("_name").Empty());
var rule = (ValidatorRule <Person, string>)context.GetRuleSetsForType <Person>().First().Rules.First();
Assert.That(rule.Validate(new Person {
Name = "invalid"
}).BrokenRules.First().PropertyKey, Is.EqualTo("_name"));
}
public void Can_set_condition_on_validator()
{
var condition = new Predicate <Person>(p => true);
SetupValidation.For <Person>(rules => rules.Property(p => p.Name).Empty().When(condition));
var rule = context.GetRuleSetsForType <Person>()[0].Rules.First() as ValidatorRule <Person, string>;
Assert.That(rule.Condition, Is.SameAs(condition));
}
public void Can_add_negated_validator_rule_for_property()
{
SetupValidation.For <Person>(rules => rules.Property(p => p.Name).Not.Empty());
var person = new Person {
Name = ""
};
var rule = context.GetRuleSetsForType <Person>()[0].Rules.First() as ValidatorRule <Person, string>;
Assert.That(rule.Validate(person).IsValid, Is.False);
}
public void Can_convert_property()
{
SetupValidation.For <Person>(rules =>
rules.Property(p => p.Age)
.Convert(x => x.ToString())
.Length(1, 2));
var r1 = context.GetRuleSetsForType <Person>()[0].Rules.ElementAt(0) as ValidatorRule <Person, string>;
Assert.That(r1.Validate(new Person {
Age = 12
}).IsValid, Is.True);
Assert.That(r1.Validate(new Person {
Age = 120
}).IsValid, Is.False);
}
public void Can_chain_validators()
{
SetupValidation.For <Person>(rules =>
rules.Property(p => p.Name)
.Length(1, 10)
.Matches("^[A-Z][a-z]+$")
);
var person = new Person {
Name = "JOhn"
};
var r1 = context.GetRuleSetsForType <Person>()[0].Rules.ElementAt(0) as ValidatorRule <Person, string>;
var r2 = context.GetRuleSetsForType <Person>()[0].Rules.ElementAt(1) as ValidatorRule <Person, string>;
Assert.That(r1.Validate(person).IsValid, Is.True);
Assert.That(r2.Validate(person).IsValid, Is.False);
}
public void Can_setup_rules_for_type()
{
SetupValidation.For <Person>(rules => {});
Assert.That(context.GetRuleSetsForType <Person>().Count, Is.EqualTo(1));
}
public void Cannot_negate_a_negation()
{
SetupValidation.For <Person>(rules => rules.Not.Not.Null());
}
public void Can_configure_and_validate_using_fluent_syntax()
{
SetupValidation.For <Person>(
rules => {
rules.Not.Null();
rules.Property(p => p.Name)
.WithKey("_name")
.WithName("The person's name")
.Not.Empty().WithMessage("Name is required.")
.Length(2, 50).WithMessage("Name should be between 2 and 50 characters.")
.Matches("^([A-Z][a-z]* ?)+$");
rules.Property(p => p.Age)
.GreaterOrEqualTo(13).WithMessage("Age must be greater than 13")
.Convert(x => x.ToString())
.Length(1, 2).WithMessage("Age must be one or two characters");
rules.Property(p => p.Notes)
.Custom(notes => notes.Count <= 10).When(p => p.Age <= 6);
rules.ForEach(p => p.Notes)
.Not.Empty()
.Length(1, 255);
rules.Property(p => p.Possessions)
.Custom(possessions => possessions.Sum(i => i.Weight) <= 50).WithMessage("Total weights of possessions must be under 50 pounds.");
rules.ForEach(p => p.Possessions)
.Property(i => i.Weight)
.LowerThan(10).WithMessage("Can't carry a single item that weights more than 10 pounds.");
});
var p1 = new Person
{
Age = 21,
Name = "John Doe",
Notes = new List <string> {
"Note 1"
},
Possessions = new List <Item> {
new Item {
Weight = 5
}
}
};
var p2 = new Person
{
Age = 21,
Name = "John doe", // <-- should be invalid
Notes = new List <string> {
"Note 1"
},
Possessions = new List <Item> {
new Item {
Weight = 12
}
} // <-- should be invalid
};
var r1 = Validate.Instance(p1);
var r2 = p2.Validate();
Assert.That(r1.IsValid, Is.True);
Assert.That(r2.IsValid, Is.False);
Assert.That(r2.BrokenRules.Count, Is.EqualTo(2));
Assert.That(r2.BrokenRules[0].PropertyKey, Is.EqualTo("_name"));
Assert.That(r2.BrokenRules[0].Message, Is.EqualTo("The person's name does not have the correct format."));
}
