public void AddRuleSet()
{
EntityValidatorBase <Customer> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <Customer> >();
entityValidatorBase.AddRuleSet("Test", x =>
{
x.AddRule(y => y.RuleFor(z => z.FirstName).NotNull());
x.AddRule(y => y.RuleFor(z => z.LastName).NotEmpty());
});
SortedList <string, IList <IEntityValidationRule <Customer> > > validationRules = entityValidatorBase.AllEntityValidationRules;
Assert.IsTrue(validationRules.ContainsKey("Test"));
IList <IEntityValidationRule <Customer> > entityValidationRules = validationRules["Test"];
Assert.IsNotNull(entityValidationRules);
Assert.AreEqual(2, entityValidationRules.Count);
Assert.AreEqual("FirstName", entityValidationRules[0].MemberName);
Assert.IsInstanceOf <NotNullValidator>(((EntityPropertyValidator)entityValidationRules[0].Validator).InnerValidator);
Assert.AreEqual("LastName", entityValidationRules[1].MemberName);
Assert.IsInstanceOf <NotEmptyValidator>(((EntityPropertyValidator)entityValidationRules[1].Validator).InnerValidator);
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityValidationRuleBuilder{TEntity, TProperty}"/> class.
/// </summary>
/// <param name="entityValidatorBase">The entity validator base.</param>
/// <param name="propertyDisplayNameResolver">The property display name resolver.</param>
/// <param name="propertyExpression">The property expression.</param>
/// <param name="ruleSetName">The rule set name.</param>
/// <exception cref="System.ArgumentNullException">propertyExpression</exception>
public EntityValidationRuleBuilder(EntityValidatorBase <TEntity> entityValidatorBase, IPropertyDisplayNameResolver propertyDisplayNameResolver, Expression <Func <TEntity, TProperty> > propertyExpression, string ruleSetName = "")
{
if (entityValidatorBase == null)
{
throw new ArgumentNullException("entityValidatorBase");
}
if (propertyExpression == null)
{
throw new ArgumentNullException("propertyExpression");
}
if (propertyDisplayNameResolver == null)
{
throw new ArgumentNullException("propertyDisplayNameResolver");
}
if (ruleSetName == null)
{
throw new ArgumentNullException("ruleSetName");
}
m_EntityValidatorBase = entityValidatorBase;
m_PropertyDisplayNameResolver = propertyDisplayNameResolver;
m_PropertyExpression = propertyExpression;
m_RuleSetName = ruleSetName;
m_Validators = new List <IEntityPropertyValidator>();
}
public void ValidateAndThrowExceptionShouldRunTheCorrectRuleSet()
{
EntityValidatorBase <Customer> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <Customer> >();
entityValidatorBase.AddRule(x => x.RuleFor(y => y.FirstName).NotNull());
entityValidatorBase.AddRuleSet("Test", x =>
{
x.AddRule(y => y.RuleFor(z => z.FirstName).NotEmpty());
x.AddRule(y => y.RuleFor(z => z.LastName).NotEmpty());
});
Assert.DoesNotThrow(() => entityValidatorBase.ValidateAndThrowException(new Customer
{
FirstName = string.Empty
}));
Assert.Throws <ValidationException>(() => entityValidatorBase.ValidateAndThrowException(new Customer
{
FirstName = null
}));
Assert.DoesNotThrow(() => entityValidatorBase.ValidateAndThrowException(new Customer
{
FirstName = "Test",
LastName = "Test"
}, "Test"));
Assert.Throws <ValidationException>(() => entityValidatorBase.ValidateAndThrowException(new Customer
{
FirstName = string.Empty,
LastName = "Test"
}, "Test"));
}
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 ValidationRules()
{
EntityValidatorBase <string> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <string> >();
IEntityValidationRule <string> entityValidationRule = Substitute.For <IEntityValidationRule <string> >();
entityValidatorBase.AddRule(entityValidationRule);
Assert.AreSame(entityValidationRule, entityValidatorBase.ValidationRules.Single());
}
public void AddRule()
{
EntityValidatorBase <string> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <string> >();
IEntityValidationRule <string> entityValidationRule = Substitute.For <IEntityValidationRule <string> >();
entityValidatorBase.AddRule(entityValidationRule);
IList <IEntityValidationRule <string> > validationRules = entityValidatorBase.GetValidationRulesByRuleSetName();
Assert.AreEqual(1, validationRules.Count);
}
public void RuleForShouldCallEntityValidationRuleSetRulesetName()
{
EntityValidatorBase <Customer> entityValidator = Substitute.For <EntityValidatorBase <Customer> >();
const string ruleSetName = "TestRuleSet";
EntityValidationRuleSetBuilder <Customer> ruleSetBuilder = new EntityValidationRuleSetBuilder <Customer>(Substitute.For <IPropertyDisplayNameResolver>(), entityValidator, ruleSetName);
EntityValidationRuleBuilder <Customer, string> entityValidationRuleBuilder = (EntityValidationRuleBuilder <Customer, string>)ruleSetBuilder.RuleFor(x => x.FirstName);
Assert.AreEqual(ruleSetName, entityValidationRuleBuilder.RuleSetName);
}
public void GetValidationRulesByRuleSetNameShouldReturnEmptyValidationRuleListWhenNoRuleSetIsFound()
{
EntityValidatorBase <string> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <string> >();
IEntityValidationRule <string> entityValidationRule = Substitute.For <IEntityValidationRule <string> >();
entityValidatorBase.AddRule("Test", entityValidationRule);
IList <IEntityValidationRule <string> > validationRules = entityValidatorBase.GetValidationRulesByRuleSetName(string.Empty);
Assert.IsNotNull(validationRules);
Assert.AreEqual(0, validationRules.Count);
}
public void ValidateAndThrowExceptionShouldNotThrowExceptionWhenValid()
{
EntityValidatorBase <Customer> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <Customer> >();
entityValidatorBase.AddRule(x => x.RuleFor(y => y.FirstName).NotEmpty());
Assert.DoesNotThrow(() => entityValidatorBase.ValidateAndThrowException(new Customer
{
FirstName = "Test"
}));
}
public void ValidateAndThrowExceptionShouldThrowExceptionWhenInvalid()
{
EntityValidatorBase <Customer> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <Customer> >();
entityValidatorBase.AddRule(x => x.RuleFor(y => y.FirstName).NotEmpty());
Assert.Throws <ValidationException>(() => entityValidatorBase.ValidateAndThrowException(new Customer
{
FirstName = string.Empty
}));
}
public void SetMessage()
{
EntityValidatorBase <Customer> customerValidator = Substitute.For <EntityValidatorBase <Customer> >();
EntityValidationRuleBuilder <Customer, string> entityValidationRuleBuilder = new EntityValidationRuleBuilder <Customer, string>(customerValidator, Substitute.For <IPropertyDisplayNameResolver>(), x => x.Name);
const string message = "Costumer name cannot be empty.";
entityValidationRuleBuilder.SetMessage(message);
Assert.AreEqual(message, entityValidationRuleBuilder.Message);
}
public void AddRuleShouldCallEntityValidationRuleSetRulesetName()
{
EntityValidatorBase <Customer> entityValidator = Substitute.For <EntityValidatorBase <Customer> >();
const string ruleSetName = "TestRuleSet";
EntityValidationRuleSetBuilder <Customer> ruleSetBuilder = new EntityValidationRuleSetBuilder <Customer>(Substitute.For <IPropertyDisplayNameResolver>(), entityValidator, ruleSetName);
IEntityValidationRule <Customer> entityValidationRule = Substitute.For <IEntityValidationRule <Customer> >();
ruleSetBuilder.AddRule(entityValidationRule);
entityValidator.Received(1).AddRule(ruleSetName, entityValidationRule);
}
public void AddRuleShouldAddToRuleSetCollectionOfTheValidator()
{
EntityValidatorBase <Customer> entityValidator = Substitute.ForPartsOf <EntityValidatorBase <Customer> >();
const string ruleSetName = "TestRuleSet";
EntityValidationRuleSetBuilder <Customer> ruleSetBuilder = new EntityValidationRuleSetBuilder <Customer>(Substitute.For <IPropertyDisplayNameResolver>(), entityValidator, ruleSetName);
ruleSetBuilder.AddRule(x => x.RuleFor(y => y.FirstName).NotNull());
IList <IEntityValidationRule <Customer> > validationRules = entityValidator.AllEntityValidationRules[ruleSetName];
Assert.IsNotNull(validationRules);
Assert.AreEqual(1, validationRules.Count);
Assert.AreEqual("FirstName", validationRules[0].MemberName);
}
public void ValidateExceptionShouldRunTheCorrectRuleSet()
{
EntityValidatorBase <Customer> entityValidatorBase = Substitute.ForPartsOf <EntityValidatorBase <Customer> >();
entityValidatorBase.AddRule(x => x.RuleFor(y => y.FirstName).NotNull());
entityValidatorBase.AddRuleSet("Test", x =>
{
x.AddRule(y => y.RuleFor(z => z.FirstName).NotEmpty());
x.AddRule(y => y.RuleFor(z => z.LastName).NotEmpty());
});
ValidationResult validationResult = entityValidatorBase.Validate(new Customer
{
FirstName = string.Empty
});
Assert.IsTrue(validationResult.IsValid);
validationResult = entityValidatorBase.Validate(new Customer
{
FirstName = null
});
Assert.IsFalse(validationResult.IsValid);
validationResult = entityValidatorBase.Validate(new Customer
{
FirstName = "Test",
LastName = "Test"
}, "Test");
Assert.IsTrue(validationResult.IsValid);
validationResult = entityValidatorBase.Validate(new Customer
{
FirstName = string.Empty,
LastName = "Test"
}, "Test");
Assert.IsFalse(validationResult.IsValid);
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityValidationRuleSetBuilder{TEntity}"/> class.
/// </summary>
/// <param name="propertyDisplayNameResolver">The property display name resolver.</param>
/// <param name="entityValidator">The entity validator.</param>
/// <param name="ruleSetName">The rule set name.</param>
public EntityValidationRuleSetBuilder(IPropertyDisplayNameResolver propertyDisplayNameResolver, EntityValidatorBase <TEntity> entityValidator, string ruleSetName)
{
if (propertyDisplayNameResolver == null)
{
throw new ArgumentNullException("propertyDisplayNameResolver");
}
if (entityValidator == null)
{
throw new ArgumentNullException("entityValidator");
}
if (ruleSetName == null)
{
throw new ArgumentNullException("ruleSetName");
}
m_EntityValidator = entityValidator;
m_RuleSetName = ruleSetName;
m_PropertyDisplayNameResolver = propertyDisplayNameResolver;
}
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());
}
