private void AttachValidators(PropertyValidationRule rule)
{
bool notNullOrEmptyPredicate(PropertyValue x) => x.Value != null && !string.IsNullOrEmpty(x.Value.ToString());
if (rule.CharCountMax.HasValue)
{
RuleFor(s => s.Value.ToString())
.MaximumLength(rule.CharCountMax.Value).WithName(rule.Property.Name)
.When(notNullOrEmptyPredicate);
}
if (rule.CharCountMin.HasValue)
{
RuleFor(s => s.Value.ToString())
.MinimumLength(rule.CharCountMin.Value).WithName(rule.Property.Name)
.When(notNullOrEmptyPredicate);
}
if (!string.IsNullOrEmpty(rule.RegExp))
{
RuleFor(s => s.Value.ToString())
.Matches(rule.RegExp).WithName(rule.Property.Name)
.When(notNullOrEmptyPredicate);
}
}
public void Validate_OneStep_AddFaults()
{
var validationContext = A.Fake <IValidationContext <TestDataObject> >();
var validationStep = A.Fake <IPropertyValidationStep <TestDataObject, string> >();
var testData = A.Fake <TestDataObject>();
testData.StrValue = "Test";
var validationFault = A.Fake <IValidationFault>();
A.CallTo(() => validationContext.InstanceForValidation).Returns(testData);
A.CallTo(() => validationStep.Validate(A <IPropertyValidationContext <TestDataObject, string> > ._))
.Invokes((IPropertyValidationContext <TestDataObject, string> context) =>
context.AddFault(validationFault))
.Returns(false);
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
rule.AddValidationStep(validationStep);
rule.Validate(validationContext);
A.CallTo(() =>
validationContext.AddFaults(A <IEnumerable <IValidationFault> > .That.IsSameSequenceAs(validationFault)))
.MustHaveHappenedOnceExactly();
}
public void Validate_TwoStepsWithBreak_DoesStepsValidationOnlyForFirstStep()
{
var validationContext = A.Fake <IValidationContext <TestDataObject> >();
var validationStep = A.Fake <IPropertyValidationStep <TestDataObject, string> >();
var validationStep2 = A.Fake <IPropertyValidationStep <TestDataObject, string> >();
var testData = A.Fake <TestDataObject>();
testData.StrValue = "Test";
A.CallTo(() => validationContext.InstanceForValidation).Returns(testData);
A.CallTo(() => validationContext.BreakRuleValidationAfterFirstFailedValidation).Returns(true);
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
rule.AddValidationStep(validationStep);
rule.AddValidationStep(validationStep2);
rule.Validate(validationContext);
A.CallTo(() =>
validationStep.Validate(
A <IPropertyValidationContext <TestDataObject, string> > .That.Matches(x =>
x.InstanceForValidation == testData)))
.MustHaveHappenedOnceExactly();
A.CallTo(() =>
validationStep2.Validate(
A <IPropertyValidationContext <TestDataObject, string> > ._))
.MustNotHaveHappened();
}
public void Validate_NoSteps_DoesNothing()
{
var validationContext = A.Fake <IValidationContext <TestDataObject> >();
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
rule.Validate(validationContext);
A.CallTo(() => validationContext.AddFaults(A <IEnumerable <IValidationFault> > ._)).MustNotHaveHappened();
}
public void PropertyValue_Tests()
{
Tested1 tobj1 = new Tested1() { StringProp = "Test Value" };
PropertyValidationRule<string, string> tObj = new PropertyValidationRule<string, string>("TestRuleName", "TestDescription", "StringProp");
Assert.Equal("Test Value", tObj.PropertyValue(tobj1));
Assert.Equal("Tests2 Value", tObj.PropertyValue(new Tested2()));
Assert.Null(tObj.PropertyValue(new Tested3()));
}
public void SetFaultMessage_Text_HasFaultMessageIsTrueAndFaultMessageIsSet()
{
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
Assert.False(rule.HasFaultMessage);
Assert.Null(rule.FaultMessage);
rule.SetFaultMessage("Fault text");
Assert.True(rule.HasFaultMessage);
Assert.Equal("Fault text", rule.FaultMessage);
}
public IStartPropertyRuleBuilder <T, TProperty> RuleFor <TProperty>(Expression <Func <T, TProperty> > propertyExpression)
{
Ensure.IsNotNull(propertyExpression, nameof(propertyExpression));
Ensure.That(propertyExpression.IsPropertyOf(), nameof(propertyExpression),
$"{nameof(propertyExpression)} must be a property in class {typeof(T).Name}");
var rule = new PropertyValidationRule <T, TProperty>(propertyExpression);
_rules.Add(rule);
var ruleBuilder = new PropertyRuleBuilder <T, TProperty>(rule);
return(ruleBuilder);
}
public virtual PropertyValidationRuleEntity FromModel(PropertyValidationRule rule)
{
if (rule == null)
{
throw new ArgumentNullException(nameof(rule));
}
Id = rule.Id;
CharCountMax = rule.CharCountMax;
CharCountMin = rule.CharCountMin;
IsUnique = rule.IsUnique;
RegExp = rule.RegExp;
PropertyId = rule.PropertyId;
return(this);
}
public virtual PropertyValidationRule ToModel(PropertyValidationRule rule)
{
if (rule == null)
{
throw new ArgumentNullException(nameof(rule));
}
rule.Id = Id;
rule.CharCountMax = CharCountMax;
rule.CharCountMin = CharCountMin;
rule.IsUnique = IsUnique;
rule.RegExp = RegExp;
rule.PropertyId = PropertyId;
return(rule);
}
private void AttachValidators(PropertyValidationRule rule)
{
if (rule.CharCountMax.HasValue)
{
AddLenghtMaxValidationRule(rule);
}
if (rule.CharCountMin.HasValue)
{
AddLenghtMinValidationRule(rule);
}
if (!string.IsNullOrEmpty(rule.RegExp))
{
AddRegexValidationRule(rule);
}
}
public void Validate_OneStepWithTrueCondition_DoesStepValidation()
{
var validationContext = A.Fake <IValidationContext <TestDataObject> >();
var validationStep = A.Fake <IPropertyValidationStep <TestDataObject, string> >();
var testData = A.Fake <TestDataObject>();
testData.StrValue = "Test";
A.CallTo(() => validationContext.InstanceForValidation).Returns(testData);
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
rule.AddValidationStep(validationStep);
rule.SetCondition(_ => true);
rule.Validate(validationContext);
A.CallTo(() =>
validationStep.Validate(
A <IPropertyValidationContext <TestDataObject, string> > ._))
.MustHaveHappenedOnceExactly();
}
public void Affects_CallWithWrongPropertyName_ReturnsFalse()
{
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
Assert.False(rule.Affects("IntValue"));
}
public void Affects_CallWithPropertyExpressionFromWrongClass_ReturnsFalse()
{
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
Assert.False(rule.Affects(x => "Test".Length));
}
public void Affects_CallWithPropertyExpression_ReturnsTrue()
{
var rule = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
Assert.True(rule.Affects(x => x.StrValue));
}
public void Ctor_Call_NoException()
{
var _ = new PropertyValidationRule <TestDataObject, string>(x => x.StrValue);
}
private void AddRegexValidationRule(PropertyValidationRule validationRule)
{
RuleFor(s => s.Value.ToString()).Matches(validationRule.RegExp).WithName(validationRule.Property.Name);
}
private void AddLenghtMinValidationRule(PropertyValidationRule validationRule)
{
RuleFor(s => s.Value.ToString())
.MinimumLength(validationRule.CharCountMin.Value).WithName(validationRule.Property.Name);
}
public PropertyValueValidator(PropertyValidationRule rule)
{
AttachValidators(rule);
}
