public void Validator()
        {
            IValidator validator = Substitute.For<IValidator>();
            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName);

            Assert.AreSame(validator, ((EntityPropertyValidator)entityPropertyValidationRule.Validator).InnerValidator);
        }
        public void Message()
        {
            IValidator validator = Substitute.For<IValidator>();
            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName, null, "Test Message");

            Assert.AreEqual("Test Message", entityPropertyValidationRule.Message);
        }
        public void Validator()
        {
            IValidator validator = Substitute.For <IValidator>();
            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName);

            Assert.AreSame(validator, ((EntityPropertyValidator)entityPropertyValidationRule.Validator).InnerValidator);
        }
        public void ValidateMustReturnInvalidValidationResultWhenTheSpecifiedSpecificationIsSatisfiedAndTheValidatorReturnsFalse()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For <IValidator>();

            validator.IsValid(null).ReturnsForAnyArgs(false);

            ISpecification <Customer> specification = Substitute.For <ISpecification <Customer> >();

            specification.IsSatisfiedBy(null).ReturnsForAnyArgs(true);

            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName, specification);
            ValidationResult validationResult = entityPropertyValidationRule.Validate(new Customer
            {
                FirstName = firstName
            });

            validator.Received(1).IsValid(firstName);
            specification.ReceivedWithAnyArgs(1).IsSatisfiedBy(null);

            Assert.AreEqual(1, validationResult.Errors.Count);
            Assert.AreEqual(LinqUtils.GetMemberName <Customer, string>(x => x.FirstName), validationResult.Errors[0].PropertyName);
            Assert.IsFalse(validationResult.IsValid);
        }
        public void Message()
        {
            IValidator validator = Substitute.For <IValidator>();
            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName, null, "Test Message");

            Assert.AreEqual("Test Message", entityPropertyValidationRule.Message);
        }
        public void MemberName()
        {
            IValidator validator = Substitute.For <IValidator>();
            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName);

            Assert.AreEqual(LinqUtils.GetMemberName <Customer, string>(x => x.FirstName), entityPropertyValidationRule.MemberName);
        }
        public void MemberName()
        {
            IValidator validator = Substitute.For<IValidator>();
            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName);

            Assert.AreEqual(LinqUtils.GetMemberName<Customer, string>(x => x.FirstName), entityPropertyValidationRule.MemberName);
        }
Beispiel #8
0
        public void Build()
        {
            EntityValidatorBase <Customer> customerValidator = Substitute.For <EntityValidatorBase <Customer> >();

            EntityValidationRuleBuilder <Customer, string> entityValidationRuleBuilder = new EntityValidationRuleBuilder <Customer, string>(customerValidator, Substitute.For <IPropertyDisplayNameResolver>(), x => x.Name);

            entityValidationRuleBuilder.AddValidator(new EntityPropertyValidator(new NotNullValidator()));
            entityValidationRuleBuilder.AddValidator(new EntityPropertyValidator(new NotEmptyValidator()));

            Expression <Func <Customer, bool> > expression = x => x.Name != null;

            entityValidationRuleBuilder.SetSpecification(new Specification <Customer>(expression));

            entityValidationRuleBuilder.Build();

            Assert.AreEqual(2, customerValidator.EntityValidationRules.Count);

            EntityPropertyValidationRule <Customer, string> validationRule0 = (EntityPropertyValidationRule <Customer, string>)customerValidator.EntityValidationRules[0];
            EntityPropertyValidationRule <Customer, string> validationRule1 = (EntityPropertyValidationRule <Customer, string>)customerValidator.EntityValidationRules[1];

            Assert.AreEqual(typeof(NotNullValidator).Name, validationRule0.Validator.GetValidatorTypeName());
            Assert.AreEqual(typeof(NotEmptyValidator).Name, validationRule1.Validator.GetValidatorTypeName());

            Assert.AreEqual(expression, validationRule0.Specification.Predicate);
            Assert.AreEqual(expression, validationRule1.Specification.Predicate);

            Assert.AreSame(validationRule0.Specification, validationRule1.Specification);
        }
        public void Specification()
        {
            IValidator validator = Substitute.For<IValidator>();
            ISpecification<Customer> specification = Substitute.For<ISpecification<Customer>>();
            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName, specification);

            Assert.AreSame(specification, entityPropertyValidationRule.Specification);
        }
        public void Specification()
        {
            IValidator validator = Substitute.For <IValidator>();
            ISpecification <Customer> specification = Substitute.For <ISpecification <Customer> >();
            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName, specification);

            Assert.AreSame(specification, entityPropertyValidationRule.Specification);
        }
        public void ValidateEnsureValidatorIsValidIsCalledForTheEntityProperty()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For<IValidator>();
            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName);
            entityPropertyValidationRule.Validate(new Customer
                                                      {
                                                          FirstName = firstName
                                                      });

            validator.Received(1).IsValid(firstName);
        }
        public void ValidateEnsureValidatorIsValidIsCalledForTheEntityProperty()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For <IValidator>();
            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName);

            entityPropertyValidationRule.Validate(new Customer
            {
                FirstName = firstName
            });

            validator.Received(1).IsValid(firstName);
        }
        public void ValidateByObject()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For <IValidator>();

            validator.IsValid(null).ReturnsForAnyArgs(false);

            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName);
            ValidationResult validationResult = ((IEntityValidationRule)entityPropertyValidationRule).Validate(new Customer
            {
                FirstName = firstName
            });

            validator.Received(1).IsValid(firstName);

            Assert.IsFalse(validationResult.IsValid);
        }
        public void ValidateMustReturnValidWhenValidatorIsValidReturnsTrue()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For <IValidator>();

            validator.IsValid(firstName).Returns(true);

            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName);
            ValidationResult validationResult = entityPropertyValidationRule.Validate(new Customer
            {
                FirstName = firstName
            });

            validator.Received(1).IsValid(firstName);

            Assert.AreEqual(0, validationResult.Errors.Count);
            Assert.IsTrue(validationResult.IsValid);
        }
        public void ValidateMustReturnEmptyValidationResultWhenTheSpecifiedSpecificationIsNotSatisfied()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For <IValidator>();
            ISpecification <Customer> specification = Substitute.For <ISpecification <Customer> >();

            specification.IsSatisfiedBy(null).ReturnsForAnyArgs(false);

            EntityPropertyValidationRule <Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule <Customer, string>(new EntityPropertyValidator(validator), Substitute.For <IPropertyDisplayNameResolver>(), x => x.FirstName, specification);
            ValidationResult validationResult = entityPropertyValidationRule.Validate(new Customer
            {
                FirstName = firstName
            });

            validator.DidNotReceiveWithAnyArgs().IsValid(firstName);
            specification.ReceivedWithAnyArgs(1).IsSatisfiedBy(null);

            Assert.AreEqual(0, validationResult.Errors.Count);
            Assert.IsTrue(validationResult.IsValid);
        }
Beispiel #16
0
        public void BuildShouldAddValidatorsToTheRuleSetWhenRuleSetIsGiven()
        {
            EntityValidatorBase <Customer> customerValidator = Substitute.For <EntityValidatorBase <Customer> >();

            const string ruleSetName = "TestRuleSet";
            EntityValidationRuleBuilder <Customer, string> entityValidationRuleBuilder = new EntityValidationRuleBuilder <Customer, string>(customerValidator, Substitute.For <IPropertyDisplayNameResolver>(), x => x.Name, ruleSetName);

            entityValidationRuleBuilder.AddValidator(new EntityPropertyValidator(new NotNullValidator()));
            entityValidationRuleBuilder.AddValidator(new EntityPropertyValidator(new NotEmptyValidator()));

            Assert.AreEqual(ruleSetName, entityValidationRuleBuilder.RuleSetName);

            entityValidationRuleBuilder.Build();

            Assert.AreEqual(1, customerValidator.AllEntityValidationRules.Count);

            IList <IEntityValidationRule <Customer> >       entityValidationRules = customerValidator.AllEntityValidationRules[ruleSetName];
            EntityPropertyValidationRule <Customer, string> validationRule0       = (EntityPropertyValidationRule <Customer, string>)entityValidationRules[0];
            EntityPropertyValidationRule <Customer, string> validationRule1       = (EntityPropertyValidationRule <Customer, string>)entityValidationRules[1];

            Assert.AreEqual(typeof(NotNullValidator).Name, validationRule0.Validator.GetValidatorTypeName());
            Assert.AreEqual(typeof(NotEmptyValidator).Name, validationRule1.Validator.GetValidatorTypeName());
        }
        public void ValidateMustReturnValidWhenValidatorIsValidReturnsTrue()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For<IValidator>();
            validator.IsValid(firstName).Returns(true);

            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName);
            ValidationResult validationResult = entityPropertyValidationRule.Validate(new Customer
                                                                                          {
                                                                                              FirstName = firstName
                                                                                          });

            validator.Received(1).IsValid(firstName);

            Assert.AreEqual(0, validationResult.Errors.Count);
            Assert.IsTrue(validationResult.IsValid);
        }
        public void ValidateMustReturnInvalidValidationResultWhenTheSpecifiedTheValidatorReturnsFalse()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For<IValidator>();
            validator.IsValid(null).ReturnsForAnyArgs(false);

            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName);
            ValidationResult validationResult = entityPropertyValidationRule.Validate(new Customer
            {
                FirstName = firstName
            });

            validator.Received(1).IsValid(firstName);

            Assert.AreEqual(1, validationResult.Errors.Count);
            Assert.AreEqual(LinqUtils.GetMemberName<Customer, string>(x => x.FirstName), validationResult.Errors[0].PropertyName);
            Assert.IsFalse(validationResult.IsValid);
        }
        public void ValidateMustReturnEmptyValidationResultWhenTheSpecifiedSpecificationIsSatisfiedAndTheValidatorReturnsTrue()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For<IValidator>();
            validator.IsValid(null).ReturnsForAnyArgs(true);

            ISpecification<Customer> specification = Substitute.For<ISpecification<Customer>>();
            specification.IsSatisfiedBy(null).ReturnsForAnyArgs(true);

            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName, specification);
            ValidationResult validationResult = entityPropertyValidationRule.Validate(new Customer
            {
                FirstName = firstName
            });

            validator.Received(1).IsValid(firstName);
            specification.ReceivedWithAnyArgs(1).IsSatisfiedBy(null);

            Assert.AreEqual(0, validationResult.Errors.Count);
            Assert.IsTrue(validationResult.IsValid);
        }
        public void ValidateByObject()
        {
            const string firstName = "Foo";

            IValidator validator = Substitute.For<IValidator>();
            validator.IsValid(null).ReturnsForAnyArgs(false);

            EntityPropertyValidationRule<Customer, string> entityPropertyValidationRule = new EntityPropertyValidationRule<Customer, string>(new EntityPropertyValidator(validator), Substitute.For<IPropertyDisplayNameResolver>(), x => x.FirstName);
            ValidationResult validationResult = ((IEntityValidationRule)entityPropertyValidationRule).Validate(new Customer
            {
                FirstName = firstName
            });

            validator.Received(1).IsValid(firstName);

            Assert.IsFalse(validationResult.IsValid);
        }