public void Should_be_valid_when_condition_returns_true_using_instance_property() { var validator = new CustomValidator<Person, int>((p, v) => p.Age % v == 0); var person = new Person {Age = 16}; Assert.That(validator.Validate(person, 4), Is.True); }
public void Should_be_invalid_when_value_is_lower_using_instance_property() { var validator = new GreaterOrEqualToValidator<Person, int>(p => p.Age); var person = new Person { Age = 18 }; Assert.That(validator.Validate(person, 16), Is.False); }
public void Should_be_valid_when_value_is_greater_using_instance_property() { var validator = new GreaterThanValidator<Person, int>(p => p.Age); var person = new Person {Age = 18}; Assert.That(validator.Validate(person, 21), Is.True); }
public void Should_be_valid_when_values_are_equal_using_instance_property() { var validator = new EqualValidator<Person, int>(p => p.Age); var person = new Person {Age = 15}; Assert.That(validator.Validate(person, 15), Is.True); }
public void Should_be_invalid_when_length_is_lower_than_min_value_using_instance_property() { var validator = new LengthValidator<Person>(p => p.Name.Length, p => p.Age); var person = new Person { Name = "Bob", Age = 8 }; Assert.That(validator.Validate(person, "AB"), Is.False); }
public void Should_be_invalid_when_value_is_equal_using_instance_property() { var validator = new LowerThanValidator<Person, int>(p => p.Age); var person = new Person { Age = 18 }; Assert.That(validator.Validate(person, 18), Is.False); }
public void Should_be_valid_when_length_is_between_values_using_instance_property() { var validator = new LengthValidator<Person>(p => p.Name.Length, p => p.Age); var person = new Person {Name = "Bob", Age = 8}; Assert.That(validator.Validate(person, "ABCDE"), Is.True); }
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 Should_be_valid_when_inner_validator_is_invalid() { var validator = CreateMock<IValidator<Person, string>>(); var negated = new NegatedValidator<Person, string>(validator); var person = new Person(); validator.Expect(v => v.Validate(person, "Test")).Return(false); Assert.That(negated.Validate(person, "Test"), Is.True); }
public void Can_access_broken_rule_details() { var rule = CreateStub<IRule>(); var person = new Person(); var brokenRule = new BrokenRule(rule, person, "FullName", "Full Name", -123); Assert.That(brokenRule.InvalidInstance, Is.EqualTo(person)); Assert.That(brokenRule.InvalidValue, Is.EqualTo(-123)); Assert.That(brokenRule.PropertyDisplayName, Is.EqualTo("Full Name")); Assert.That(brokenRule.PropertyKey, Is.EqualTo("FullName")); }
public void Should_validate_against_validator() { var validator = CreateMock<IValidator<Person, string>>(); var person = new Person {Name = "Bob"}; var rule = new ValidatorRule<Person, string>("", "", validator, p => p.Name); validator.Expect(v => v.Validate(person, "Bob")).Return(true); rule.Validate(person); VerifyAll(); }
public void Should_return_valid_result_if_validator_returned_valid() { var validator = CreateMock<IValidator<Person, string>>(); var person = new Person { Name = "Bob" }; var rule = new ValidatorRule<Person, string>("", "", validator, p => p.Name); validator.Stub(v => v.Validate(person, "Bob")).Return(true); var result = rule.Validate(person); Assert.That(result.IsValid, Is.True); }
public void Should_format_message() { var rule = CreateStub<IRule>(); rule.Stub(r => r.Message).Return("{Instance.Name} has invalid {Property}: {Value}"); var person = new Person {Name = "John Doe"}; var brokenRule = new BrokenRule(rule, person, "Age", "Age", -123); var message = brokenRule.Message; Assert.That(message, Is.EqualTo("John Doe has invalid Age: -123")); }
public void Should_always_be_valid_if_condition_is_not_met() { var person = new Person(); var rule1 = new TestConditionalRule<Person>(true) { Condition = (p => false) }; var rule2 = new TestConditionalRule<Person>(false) { Condition = (p => false) }; var result1 = rule1.Validate(person); var result2 = rule2.Validate(person); Assert.That(result1.IsValid, Is.True); Assert.That(result2.IsValid, Is.True); }
public void Should_run_validation_when_condition_is_not_set() { var person = new Person(); var rule1 = new TestConditionalRule<Person>(true); var rule2 = new TestConditionalRule<Person>(false); var result1 = rule1.Validate(person); var result2 = rule2.Validate(person); Assert.That(result1.IsValid, Is.True); Assert.That(result2.IsValid, Is.False); }
public void Should_return_invalid_result_with_broken_rule_if_validator_returned_invalid() { var validator = CreateMock<IValidator<Person, string>>(); var person = new Person { Name = "Bob" }; var rule = new ValidatorRule<Person, string>("", "", validator, p => p.Name) { Message = "Invalid name" }; validator.Stub(v => v.Validate(person, "Bob")).Return(false); var result = rule.Validate(person); Assert.That(result.IsValid, Is.False); Assert.That(result.BrokenRules[0].Message, Is.EqualTo("Invalid name")); }
public void Can_use_resource_as_message() { ValidationContext.ResourceManagers.Add(TestMessages.ResourceManager); var rule = CreateStub<IRule>(); rule.Stub(r => r.Resource).Return("personInvalidName"); var person = new Person(); var brokenRule = new BrokenRule(rule, person, "Name", "Name", "John Doe"); var message = brokenRule.Message; Assert.That(message, Is.EqualTo("John Doe is not a valid name.")); }
public void Can_validate_against_current_validation_context() { var person = new Person(); var expectedResult = new ValidationResult(); var context = CreateMock<IValidationContext>(); ValidationContext.Current = context; context.Expect(c => c.Validate(person)).Return(expectedResult); var result = Validate.Instance(person); Assert.That(result, Is.SameAs(expectedResult)); VerifyAll(); }
public void Can_validate_against_named_validation_context_using_alternate_syntax() { var person = new Person(); var expectedResult = new ValidationResult(); var context = CreateMock<IValidationContext>(); ValidationContext.SetNamedContext("TestContext", context); context.Expect(c => c.Validate(person)).Return(expectedResult); var result = person.ValidateInContext("TestContext"); Assert.That(result, Is.SameAs(expectedResult)); VerifyAll(); }
public void Should_return_all_broken_rules() { var person = new Person { Possessions = new List<Item> { new Item(), new Item() } }; var rule = new ForEachRule<Person, Item>(p => p.Possessions); rule.Rules.Add(CreateMock<RuleBase<Item>>()); rule.Rules.Add(CreateMock<RuleBase<Item>>()); rule.Rules[0].Expect(r => r.Validate(person.Possessions[0])).Return(new RuleExecutionResult(new List<BrokenRule> { new BrokenRule(null, null, "", "", null) })); rule.Rules[1].Expect(r => r.Validate(person.Possessions[0])).Return(new RuleExecutionResult(new List<BrokenRule> { new BrokenRule(null, null, "", "", null), new BrokenRule(null, null, "", "", null) })); rule.Rules[0].Expect(r => r.Validate(person.Possessions[1])).Return(new RuleExecutionResult(new List<BrokenRule> { new BrokenRule(null, null, "", "", null), new BrokenRule(null, null, "", "", null) })); rule.Rules[1].Expect(r => r.Validate(person.Possessions[1])).Return(new RuleExecutionResult(new List<BrokenRule> { new BrokenRule(null, null, "", "", null) }) { StopEvaluation = true }); var result = rule.Validate(person); Assert.That(result.IsValid, Is.False); Assert.That(result.StopEvaluation, Is.True); Assert.That(result.BrokenRules.Count, Is.EqualTo(6)); }
public void Should_aggregate_results() { var person = new Person(); var rules = new List<IRule> { CreateMock<IRule>(), CreateMock<IRule>() }; rules[0].Stub(r => r.Validate(person)).Return(new RuleExecutionResult(new List<BrokenRule> { new BrokenRule(null, null, "", "", null), new BrokenRule(null, null, "", "", null) })); rules[1].Stub(r => r.Validate(person)).Return(new RuleExecutionResult(new List<BrokenRule> { new BrokenRule(null, null, "", "", null) }) { StopEvaluation = true }); var ruleSet = new RuleSet(typeof(Person), rules); var result = ruleSet.Validate(person); Assert.That(result.IsValid, Is.False); Assert.That(result.BrokenRules.Count, Is.EqualTo(3)); }
public void Can_stop() { var person = new Person(); var rules = new List<IRule> { CreateMock<IRule>(), CreateMock<IRule>(), CreateMock<IRule>() }; rules[0].Stub(r => r.Validate(person)).Return(new RuleExecutionResult()); rules[1].Stub(r => r.Validate(person)).Return(new RuleExecutionResult {StopEvaluation = true}); rules[2].Expect(r => r.Validate(person)).Repeat.Never(); var ruleSet = new RuleSet(typeof(Person), rules); ruleSet.Validate(person); VerifyAll(); }
public void Should_validate_against_each_rule_if_not_stopped() { var person = new Person(); var rules = new List<IRule> { CreateMock<IRule>(), CreateMock<IRule>(), CreateMock<IRule>() }; rules[0].Expect(r => r.Validate(person)).Return(new RuleExecutionResult()); rules[1].Expect(r => r.Validate(person)).Return(new RuleExecutionResult()); rules[2].Expect(r => r.Validate(person)).Return(new RuleExecutionResult()); var ruleSet = new RuleSet(typeof (Person), rules); ruleSet.Validate(person); VerifyAll(); }
public void Can_stop() { var person = new Person { Possessions = new List<Item> { new Item(), new Item(), new Item() } }; var rule = new ForEachRule<Person, Item>(p => p.Possessions); rule.Rules.Add(CreateMock<RuleBase<Item>>()); rule.Rules.Add(CreateMock<RuleBase<Item>>()); rule.Rules[0].Expect(r => r.Validate(person.Possessions[0])).Return(new RuleExecutionResult()); rule.Rules[1].Expect(r => r.Validate(person.Possessions[0])).Return(new RuleExecutionResult()); rule.Rules[0].Expect(r => r.Validate(person.Possessions[1])).Return(new RuleExecutionResult {StopEvaluation = true}); rule.Rules[1].Expect(r => r.Validate(person.Possessions[1])).Repeat.Never(); rule.Rules[0].Expect(r => r.Validate(person.Possessions[2])).Repeat.Never(); rule.Rules[1].Expect(r => r.Validate(person.Possessions[2])).Repeat.Never(); rule.Validate(person); VerifyAll(); }
public void Should_validate_each_rule_against_each_object_in_list() { var person = new Person {Possessions = new List<Item>{new Item(), new Item(), new Item()}}; var rule = new ForEachRule<Person, Item>(p => p.Possessions); rule.Rules.Add(CreateMock<RuleBase<Item>>()); rule.Rules.Add(CreateMock<RuleBase<Item>>()); rule.Rules[0].Expect(r => r.Validate(person.Possessions[0])).Return(new RuleExecutionResult()); rule.Rules[1].Expect(r => r.Validate(person.Possessions[0])).Return(new RuleExecutionResult()); rule.Rules[0].Expect(r => r.Validate(person.Possessions[1])).Return(new RuleExecutionResult()); rule.Rules[1].Expect(r => r.Validate(person.Possessions[1])).Return(new RuleExecutionResult()); rule.Rules[0].Expect(r => r.Validate(person.Possessions[2])).Return(new RuleExecutionResult()); rule.Rules[1].Expect(r => r.Validate(person.Possessions[2])).Return(new RuleExecutionResult()); rule.Validate(person); VerifyAll(); }
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_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.")); }