public void ShouldBuildThreeValidatorsWithThreeValidationAttributes()
{
ParameterInfo paramToValidate = GetParameterInfo("MethodWithMultipleValidators", "id");
Validator v = ParameterValidatorFactory.CreateValidator(paramToValidate);
Assert.IsNotNull(v);
Assert.IsTrue(v is AndCompositeValidator);
List <Validator> validators = new List <Validator>(((AndCompositeValidator)v).Validators);
Assert.AreEqual(3, validators.Count);
Assert.IsTrue(
validators.Exists(
delegate(Validator v1)
{
return(v1 is NotNullValidator);
}));
Assert.IsTrue(
validators.Exists(
delegate(Validator v1)
{
return(v1 is StringLengthValidator);
}));
Assert.IsTrue(
validators.Exists(
delegate(Validator v1)
{
return(v1 is RegexValidator);
}));
}
private Validator CreateInputParameterValidator(ParameterInfo param, string ruleSet)
{
Validator paramAttributeValidator = ParameterValidatorFactory.CreateValidator(param);
Validator typeValidator = ValidationFactory.CreateValidator(param.ParameterType, ruleSet);
return(new AndCompositeValidator(paramAttributeValidator, typeValidator));
}
public void ShouldBuildOneValidatorWithOneValidationAttribute()
{
ParameterInfo paramToValidate = GetParameterInfo("MethodWithOneValidator", "foo");
Validator v = ParameterValidatorFactory.CreateValidator(paramToValidate);
Assert.IsNotNull(v);
Assert.IsTrue(v is NotNullValidator);
}
public void ShouldUseAnExternalRuleSet()
{
ParameterInfo paramToValidate = GetParameterInfo("MethodWithObjectValidator", "objectToValidate");
Validator v = ParameterValidatorFactory.CreateValidator(paramToValidate);
Assert.IsNotNull(v);
Assert.IsTrue(v is ObjectValidator);
ObjectValidator validator = v as ObjectValidator;
Assert.AreEqual(validator.TargetRuleset, "RuleSetA");
}
public void ShouldBuildEmptyCompositeWithNoValidationAttributes()
{
ParameterInfo paramToValidate = GetParameterInfo("MethodWithNoValidators", "firstParam");
Validator validator = ParameterValidatorFactory.CreateValidator(paramToValidate);
Assert.IsNotNull(validator);
Assert.IsTrue(validator is AndCompositeValidator);
List <Validator> validators = new List <Validator>(((AndCompositeValidator)validator).Validators);
Assert.AreEqual(0, validators.Count);
}
private Validator CreateValidator(ParameterInfo parameter)
{
Validator typeValidator = CreateValidator(parameter.ParameterType);
Validator parameterValidator = ParameterValidatorFactory.CreateValidator(parameter);
if (typeValidator != null)
{
return(new AndCompositeValidator(typeValidator, parameterValidator));
}
return(parameterValidator);
}
public void ShouldBuildOneValidatorWithOneValidationAttribute()
{
ParameterInfo paramToValidate = GetParameterInfo("MethodWithOneValidator", "foo");
Validator v = ParameterValidatorFactory.CreateValidator(paramToValidate);
Assert.IsNotNull(v);
Assert.IsTrue(v is AndCompositeValidator);
List <Validator> validators = new List <Validator>(((AndCompositeValidator)v).Validators);
Assert.AreEqual(1, validators.Count);
Assert.IsTrue(validators[0] is NotNullValidator);
}
/// <summary>
/// Creates the input parameter validator.
/// </summary>
/// <param name="param">The parameter.</param>
/// <param name="ruleset">The ruleset.</param>
/// <returns>Validator.</returns>
static Validator CreateInputParameterValidator(
ParameterInfo param,
string ruleset)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
return(new AndCompositeValidator(
ParameterValidatorFactory.CreateValidator(param),
Facility.ValidatorFactory.CreateValidator(param.ParameterType, ruleset)));
}
public void ShouldObserveTheIgnoreNullsAttribute()
{
Validator validatorWithIgnoreNulls
= ParameterValidatorFactory.CreateValidator(GetParameterInfo("MethodWithIgnoreNullAttribute", "id"));
Validator validatorWithoutIgnoreNulls
= ParameterValidatorFactory.CreateValidator(GetParameterInfo("MethodWithoutIgnoreNullAttribute", "id"));
Assert.IsTrue(validatorWithIgnoreNulls.Validate(null).IsValid);
Assert.IsFalse(validatorWithoutIgnoreNulls.Validate(null).IsValid);
Assert.IsTrue(validatorWithIgnoreNulls.Validate(new string('c', 30)).IsValid);
Assert.IsTrue(validatorWithoutIgnoreNulls.Validate(new string('c', 30)).IsValid);
Assert.IsFalse(validatorWithIgnoreNulls.Validate(new string('c', 60)).IsValid);
Assert.IsFalse(validatorWithoutIgnoreNulls.Validate(new string('c', 60)).IsValid);
}
public void ShouldObserveTheCompositionTypeAttribute()
{
Validator validatorWithAndComposition
= ParameterValidatorFactory.CreateValidator(GetParameterInfo("MethodWithAndComposition", "id"));
Validator validatorWithOrComposition
= ParameterValidatorFactory.CreateValidator(GetParameterInfo("MethodWithOrComposition", "id"));
Assert.IsFalse(validatorWithAndComposition.Validate(null).IsValid);
Assert.IsFalse(validatorWithOrComposition.Validate(null).IsValid);
Assert.IsTrue(validatorWithAndComposition.Validate(new string('c', 30)).IsValid);
Assert.IsTrue(validatorWithOrComposition.Validate(new string('c', 30)).IsValid);
Assert.IsFalse(validatorWithAndComposition.Validate(new string('&', 30)).IsValid);
Assert.IsTrue(validatorWithOrComposition.Validate(new string('&', 30)).IsValid);
Assert.IsFalse(validatorWithAndComposition.Validate(new string('c', 60)).IsValid);
Assert.IsTrue(validatorWithOrComposition.Validate(new string('c', 60)).IsValid);
Assert.IsFalse(validatorWithAndComposition.Validate(new string('&', 60)).IsValid);
Assert.IsFalse(validatorWithOrComposition.Validate(new string('&', 60)).IsValid);
}
